@0xtorch/evm 0.0.1

package/src/getTransactionFull/getTransactionFull.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'bun:test'
+import { createEthereumChain } from '../chains'
+import { isIntegrationTest } from '../tests'
+import { getTransactionFull } from './getTransactionFull'
+
+describe.if(isIntegrationTest)('getTransactionFull', () => {
+  it('should get transaction full', async () => {
+    const chain = createEthereumChain(process.env.ETHERSCAN_API_KEY ?? '')
+    const hash =
+      '0x78ef484e62a5174b5fb716cde105a9669fc333e7ccb59c8eced163a9802a9c43'
+
+    const transaction = await getTransactionFull({
+      chain,
+      hash,
+    })
+
+    expect(transaction).toBeDefined()
+    expect(transaction?.hash).toBe(hash)
+    expect(transaction?.block.number).toBe(19_023_982n)
+    expect(transaction?.nativeTokenPrice).toBeDefined()
+    expect(
+      transaction?.logs.filter((log) => log.type === 'decoded'),
+    ).toHaveLength(5)
+    expect(transaction?.internalTransactions).toHaveLength(1)
+    expect(transaction?.erc20Transfers).toHaveLength(2)
+    expect(transaction?.erc721Transfers).toHaveLength(0)
+    expect(transaction?.erc1155Transfers).toHaveLength(0)
+    expect(transaction?.app).toBeUndefined()
+    expect(transaction?.function).toBeDefined()
+    expect(transaction?.actions).toHaveLength(3)
+    expect(transaction?.accountAddresses).toHaveLength(0)
+    expect(transaction?.accountActions).toHaveLength(0)
+  }, 60_000)
+})

package/src/getTransactionFull/getTransactionFull.ts

@@ -0,0 +1,30 @@
+import type { Config, FiatCurrency } from '@0xtorch/core'
+import { coingeckoCryptoCurrencyDataSource, usd } from '@0xtorch/core'
+import { analyzer } from '../analyzer'
+import type { Chain } from '../chains'
+import { decoder } from '../decoder'
+import type { Hex } from '../types'
+import { getTransactionFullCustom } from './getTransactionFullCustom'
+
+type GetTransactionFullParameters = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly fiat?: FiatCurrency
+}
+
+export const getTransactionFull = async (
+  { chain, hash, fiat = usd }: GetTransactionFullParameters,
+  config?: Config,
+) =>
+  await getTransactionFullCustom(
+    {
+      chain,
+      hash,
+      appDataSource: undefined,
+      priceDataSource: coingeckoCryptoCurrencyDataSource,
+      fiat,
+      decoder,
+      analyzer,
+    },
+    config,
+  )

package/src/getTransactionFull/getTransactionFullCustom.ts

@@ -0,0 +1,91 @@
+import type { Config } from '@0xtorch/core'
+import type {
+  GetTransactionFullCustomParameters,
+  GetTransactionFullCustomParametersAllUndefined,
+  GetTransactionFullCustomParametersD,
+  GetTransactionFullCustomParametersDA,
+  GetTransactionFullCustomParametersP,
+  GetTransactionFullCustomParametersPD,
+  GetTransactionFullCustomParametersPDA,
+  GetTransactionFullCustomReturnType,
+} from './types'
+import { getTransactionFullCustomWithD } from './withD'
+import { getTransactionFullCustomWithDA } from './withDA'
+import { getTransactionFullCustomWithP } from './withP'
+import { getTransactionFullCustomWithPD } from './withPD'
+import { getTransactionFullCustomWithPDA } from './withPDA'
+import { getTransactionFullCustomWithAllUndefined } from './withUndefined'
+
+export const getTransactionFullCustom = async <
+  T extends GetTransactionFullCustomParameters,
+>(
+  parameters: T,
+  config?: Config,
+): Promise<GetTransactionFullCustomReturnType<T>> => {
+  if (isParametersAllUndefined(parameters)) {
+    const data = await getTransactionFullCustomWithAllUndefined(
+      parameters,
+      config,
+    )
+    return data as GetTransactionFullCustomReturnType<T>
+  }
+  if (isParametersP(parameters)) {
+    const data = await getTransactionFullCustomWithP(parameters, config)
+    return data as GetTransactionFullCustomReturnType<T>
+  }
+  if (isParametersPD(parameters)) {
+    const data = await getTransactionFullCustomWithPD(parameters, config)
+    return data as GetTransactionFullCustomReturnType<T>
+  }
+  if (isParametersPDA(parameters)) {
+    const data = await getTransactionFullCustomWithPDA(parameters, config)
+    return data as GetTransactionFullCustomReturnType<T>
+  }
+  if (isParametersD(parameters)) {
+    const data = await getTransactionFullCustomWithD(parameters, config)
+    return data as GetTransactionFullCustomReturnType<T>
+  }
+  if (isParametersDA(parameters)) {
+    const data = await getTransactionFullCustomWithDA(parameters, config)
+    return data as GetTransactionFullCustomReturnType<T>
+  }
+  throw new Error('not implemented')
+}
+
+const isParametersAllUndefined = (
+  parameters: GetTransactionFullCustomParameters,
+): parameters is GetTransactionFullCustomParametersAllUndefined =>
+  parameters.priceDataSource === undefined && parameters.decoder === undefined
+
+const isParametersP = (
+  parameters: GetTransactionFullCustomParameters,
+): parameters is GetTransactionFullCustomParametersP =>
+  parameters.priceDataSource !== undefined && parameters.decoder === undefined
+
+const isParametersPD = (
+  parameters: GetTransactionFullCustomParameters,
+): parameters is GetTransactionFullCustomParametersPD =>
+  parameters.priceDataSource !== undefined &&
+  parameters.decoder !== undefined &&
+  parameters.analyzer === undefined
+
+const isParametersPDA = (
+  parameters: GetTransactionFullCustomParameters,
+): parameters is GetTransactionFullCustomParametersPDA =>
+  parameters.priceDataSource !== undefined &&
+  parameters.decoder !== undefined &&
+  parameters.analyzer !== undefined
+
+const isParametersD = (
+  parameters: GetTransactionFullCustomParameters,
+): parameters is GetTransactionFullCustomParametersD =>
+  parameters.priceDataSource === undefined &&
+  parameters.decoder !== undefined &&
+  parameters.analyzer === undefined
+
+const isParametersDA = (
+  parameters: GetTransactionFullCustomParameters,
+): parameters is GetTransactionFullCustomParametersDA =>
+  parameters.priceDataSource === undefined &&
+  parameters.decoder !== undefined &&
+  parameters.analyzer !== undefined

package/src/getTransactionFull/index.ts

@@ -0,0 +1,2 @@
+export { getTransactionFull } from './getTransactionFull'
+export { getTransactionFullCustom } from './getTransactionFullCustom'

package/src/getTransactionFull/types.ts

@@ -0,0 +1,98 @@
+import type {
+  CryptoCurrencyDataSource,
+  CryptoCurrencyPrice,
+  FiatCurrency,
+} from '@0xtorch/core'
+import type { Analyzer } from '../analyzer'
+import type { AppDataSource } from '../apps'
+import type { Chain } from '../chains'
+import type { Decoder } from '../decoder'
+import type { Hex, TransactionFull } from '../types'
+
+export type GetTransactionFullCustomParameters =
+  | GetTransactionFullCustomParametersAllUndefined
+  | GetTransactionFullCustomParametersP
+  | GetTransactionFullCustomParametersPD
+  | GetTransactionFullCustomParametersPDA
+  | GetTransactionFullCustomParametersD
+  | GetTransactionFullCustomParametersDA
+
+export type GetTransactionFullCustomParametersAllUndefined = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly appDataSource: AppDataSource | undefined
+  readonly priceDataSource: undefined
+  readonly fiat: undefined
+  readonly decoder: undefined
+  readonly analyzer: undefined
+}
+
+export type GetTransactionFullCustomParametersP = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly appDataSource: AppDataSource | undefined
+  readonly priceDataSource: CryptoCurrencyDataSource
+  readonly fiat: FiatCurrency
+  readonly decoder: undefined
+  readonly analyzer: undefined
+}
+
+export type GetTransactionFullCustomParametersPD = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly appDataSource: AppDataSource | undefined
+  readonly priceDataSource: CryptoCurrencyDataSource
+  readonly fiat: FiatCurrency
+  readonly decoder: Decoder
+  readonly analyzer: undefined
+}
+
+export type GetTransactionFullCustomParametersPDA = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly appDataSource: AppDataSource | undefined
+  readonly priceDataSource: CryptoCurrencyDataSource
+  readonly fiat: FiatCurrency
+  readonly decoder: Decoder
+  readonly analyzer: Analyzer<CryptoCurrencyPrice | undefined>
+}
+
+export type GetTransactionFullCustomParametersD = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly appDataSource: AppDataSource | undefined
+  readonly priceDataSource: undefined
+  readonly fiat: undefined
+  readonly decoder: Decoder
+  readonly analyzer: undefined
+}
+
+export type GetTransactionFullCustomParametersDA = {
+  readonly chain: Chain
+  readonly hash: Hex
+  readonly appDataSource: AppDataSource | undefined
+  readonly priceDataSource: undefined
+  readonly fiat: undefined
+  readonly decoder: Decoder
+  readonly analyzer: Analyzer<undefined>
+}
+
+export type GetTransactionFullCustomReturnType<
+  T extends GetTransactionFullCustomParameters,
+> = T extends GetTransactionFullCustomParametersAllUndefined
+  ? TransactionFull<undefined, false, false> | undefined
+  : T extends GetTransactionFullCustomParametersP
+    ? TransactionFull<CryptoCurrencyPrice | undefined, false, false> | undefined
+    : T extends GetTransactionFullCustomParametersPD
+      ?
+          | TransactionFull<CryptoCurrencyPrice | undefined, true, false>
+          | undefined
+      : T extends GetTransactionFullCustomParametersPDA
+        ?
+            | TransactionFull<CryptoCurrencyPrice | undefined, true, true>
+            | undefined
+        : T extends GetTransactionFullCustomParametersD
+          ? TransactionFull<undefined, true, false> | undefined
+          : T extends GetTransactionFullCustomParametersDA
+            ? TransactionFull<undefined, true, true> | undefined
+            : never

package/src/getTransactionFull/withD.ts

@@ -0,0 +1,57 @@
+import type { Config } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getTransactionDetail } from './getTransactionDetail'
+import type {
+  GetTransactionFullCustomParametersD,
+  GetTransactionFullCustomReturnType,
+} from './types'
+
+export const getTransactionFullCustomWithD = async (
+  parameters: GetTransactionFullCustomParametersD,
+  config?: Config,
+): Promise<
+  GetTransactionFullCustomReturnType<GetTransactionFullCustomParametersD>
+> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const { chain, hash, appDataSource, decoder } = 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 app from data source
+  const app =
+    appDataSource === undefined || transactionDecoded.to === null
+      ? undefined
+      : await appDataSource.getApp(
+          chain.id,
+          toLowerHex(transactionDecoded.to),
+          {
+            timeout: timeoutTimestamp - Date.now(),
+            logger: config?.logger,
+          },
+        )
+
+  return {
+    ...transactionDecoded,
+    app,
+    nativeTokenPrice: undefined,
+  }
+}

package/src/getTransactionFull/withDA.ts

@@ -0,0 +1,78 @@
+/* eslint-disable unicorn/filename-case */
+import type { Config } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getTransactionDetail } from './getTransactionDetail'
+import type {
+  GetTransactionFullCustomParametersDA,
+  GetTransactionFullCustomReturnType,
+} from './types'
+
+export const getTransactionFullCustomWithDA = async (
+  parameters: GetTransactionFullCustomParametersDA,
+  config?: Config,
+): Promise<
+  GetTransactionFullCustomReturnType<GetTransactionFullCustomParametersDA>
+> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const { chain, hash, appDataSource, 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 app from data sourc
+  const app =
+    appDataSource === undefined || transactionDecoded.to === null
+      ? undefined
+      : await appDataSource.getApp(
+          chain.id,
+          toLowerHex(transactionDecoded.to),
+          {
+            timeout: timeoutTimestamp - Date.now(),
+            logger: config?.logger,
+          },
+        )
+
+  const transactionForAnalyzer = {
+    ...transactionDecoded,
+    app,
+    nativeTokenPrice: undefined,
+  }
+
+  // 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/withP.ts

@@ -0,0 +1,69 @@
+import type { Config, CryptoCurrencyPrice } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getTransactionDetail } from './getTransactionDetail'
+import type {
+  GetTransactionFullCustomParametersP,
+  GetTransactionFullCustomReturnType,
+} from './types'
+
+export const getTransactionFullCustomWithP = async (
+  parameters: GetTransactionFullCustomParametersP,
+  config?: Config,
+): Promise<
+  GetTransactionFullCustomReturnType<GetTransactionFullCustomParametersP>
+> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const { chain, hash, appDataSource, priceDataSource, fiat } = parameters
+
+  // get transaction detail
+  const transactionDetail = await getTransactionDetail(chain, hash, config)
+  if (transactionDetail === undefined) {
+    return undefined
+  }
+
+  const timestampMs = Number(transactionDetail.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 || transactionDetail.to === null
+      ? undefined
+      : appDataSource.getApp(chain.id, toLowerHex(transactionDetail.to), {
+          timeout: timeoutForDataSources,
+          logger: config?.logger,
+        }),
+    // get native token prices
+    priceDataSource.getHistoricalPrices(
+      {
+        targetCurrencies: [chain.nativeToken.currency],
+        vsCurrency: fiat,
+        from,
+        to,
+      },
+      {
+        timeout: timeoutForDataSources,
+        logger: config?.logger,
+      },
+    ),
+  ])
+
+  const closestPrice = prices.reduce(
+    (closestPrice: CryptoCurrencyPrice | undefined, price) =>
+      closestPrice === undefined ||
+      Math.abs(price.timestamp - timestampMs) <
+        Math.abs(closestPrice.timestamp - timestampMs)
+        ? price
+        : closestPrice,
+    undefined,
+  )
+
+  return {
+    ...transactionDetail,
+    app,
+    nativeTokenPrice: closestPrice,
+  }
+}

package/src/getTransactionFull/withPD.ts

@@ -0,0 +1,119 @@
+/* eslint-disable unicorn/filename-case */
+import type { Config, CryptoCurrency, CryptoCurrencyPrice } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getTransactionDetail } from './getTransactionDetail'
+import type {
+  GetTransactionFullCustomParametersPD,
+  GetTransactionFullCustomReturnType,
+} from './types'
+
+export const getTransactionFullCustomWithPD = async (
+  parameters: GetTransactionFullCustomParametersPD,
+  config?: Config,
+): Promise<
+  GetTransactionFullCustomReturnType<GetTransactionFullCustomParametersPD>
+> => {
+  const timeoutTimestamp =
+    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
+
+  const { chain, hash, appDataSource, priceDataSource, fiat, decoder } =
+    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]
+
+  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,
+  )
+
+  return {
+    ...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,
+      ),
+    })),
+  }
+}