@0xtorch/evm 0.0.30 → 0.0.32

package/getAccountsTransactionFulls/withPDA.ts

@@ -1,167 +0,0 @@
-/* eslint-disable unicorn/filename-case */
-import type { Config, CryptoCurrencyPrice } from '@0xtorch/core'
-import { toLowerHex } from '../types'
-import { getDecodedTransactionsPrices } from './getDecodedTransactionsPrices'
-import { getHashesAndInternalTxs } from './getHashesAndInternalTxs'
-import { getTransactionDetails } from './getTransactionDetails'
-import { getTransactionsApps } from './getTransactionsApps'
-import type {
-  GetAccountsTransactionFullsCustomParametersPDA,
-  GetAccountsTransactionFullsCustomReturnType,
-} from './types'
-
-export const getAccountsTransactionFullsCustomWithPDA = async (
-  {
-    chain,
-    addresses,
-    fromBlock,
-    toBlock,
-    appDataSource,
-    priceDataSource,
-    fiat,
-    decoder,
-    analyzer,
-    onFetchHashes,
-    onFetchTransaction,
-  }: GetAccountsTransactionFullsCustomParametersPDA,
-  config?: Config,
-): Promise<
-  GetAccountsTransactionFullsCustomReturnType<GetAccountsTransactionFullsCustomParametersPDA>
-> => {
-  const timeoutTimestamp =
-    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-
-  // get transaction hash & internal transaction by explorer
-  const { hashes, internalTransactions } = await getHashesAndInternalTxs(
-    chain,
-    addresses,
-    fromBlock,
-    toBlock,
-    config,
-  )
-  if (hashes.length === 0) {
-    return []
-  }
-  if (onFetchHashes !== undefined) {
-    onFetchHashes(hashes.map((hash) => toLowerHex(hash)))
-  }
-
-  // get transaction detail of hashes
-  const timeoutForGetTransactionDetail = timeoutTimestamp - Date.now()
-  const transactionDetails = await getTransactionDetails(
-    chain,
-    hashes,
-    internalTransactions,
-    onFetchTransaction,
-    {
-      timeout: timeoutForGetTransactionDetail,
-      logger: config?.logger,
-    },
-  )
-
-  // decode
-  const { transactions: transactionsDecoded } = await decoder.decode(
-    {
-      chain,
-      transactions: transactionDetails,
-    },
-    {
-      timeout: timeoutTimestamp - Date.now(),
-      logger: config?.logger,
-    },
-  )
-
-  const timeoutForDataSources = timeoutTimestamp - Date.now()
-  const [apps, prices] = await Promise.all([
-    // get apps
-    getTransactionsApps(appDataSource, transactionDetails, {
-      timeout: timeoutForDataSources,
-      logger: config?.logger,
-    }),
-    // get prices
-    getDecodedTransactionsPrices(
-      chain,
-      priceDataSource,
-      fiat,
-      transactionsDecoded,
-      {
-        timeout: timeoutForDataSources,
-        logger: config?.logger,
-      },
-    ),
-  ])
-
-  const transactionsForAnalyzer = transactionsDecoded.map((transaction) => {
-    const lowerTo =
-      transaction.to === null ? undefined : toLowerHex(transaction.to)
-    const app = apps.find(({ address }) => address === lowerTo)?.app
-    const timestampMs = Number(transaction.block.timestamp) * 1000
-    const nativeTokenPrice = prices
-      .filter(
-        ({ cryptoCurrencyId }) =>
-          cryptoCurrencyId === chain.nativeToken.currency.id,
-      )
-      .reduce(
-        (closestPrice: CryptoCurrencyPrice | undefined, price) =>
-          closestPrice === undefined ||
-          Math.abs(price.timestamp - timestampMs) <
-            Math.abs(closestPrice.timestamp - timestampMs)
-            ? price
-            : closestPrice,
-        undefined,
-      )
-    return {
-      ...transaction,
-      app,
-      nativeTokenPrice,
-      internalTransactions: transaction.internalTransactions.map(
-        (internalTransaction) => ({
-          ...internalTransaction,
-          price: nativeTokenPrice,
-        }),
-      ),
-      erc20Transfers: transaction.erc20Transfers.map((transfer) => ({
-        ...transfer,
-        price: prices
-          .filter(
-            ({ cryptoCurrencyId }) =>
-              cryptoCurrencyId === transfer.token.currency.id,
-          )
-          .reduce(
-            (closestPrice: CryptoCurrencyPrice | undefined, price) =>
-              closestPrice === undefined ||
-              Math.abs(price.timestamp - timestampMs) <
-                Math.abs(closestPrice.timestamp - timestampMs)
-                ? price
-                : closestPrice,
-            undefined,
-          ),
-      })),
-    }
-  })
-
-  // analyze
-  const timeoutForAnalyzer = timeoutTimestamp - Date.now()
-  const analyzedDatas = await Promise.all(
-    transactionsForAnalyzer.map((transactionForAnalyzer) =>
-      analyzer.analyze(
-        {
-          chain,
-          transaction: transactionForAnalyzer,
-          accountAddresses: addresses,
-        },
-        {
-          timeout: timeoutForAnalyzer,
-          logger: config?.logger,
-        },
-      ),
-    ),
-  )
-
-  return transactionsForAnalyzer.map((transactionForAnalyzer, index) => ({
-    ...transactionForAnalyzer,
-    accountAddresses: addresses,
-    actions: analyzedDatas[index].actions,
-    accountActions: analyzedDatas[index].accountActions,
-  }))
-}

package/getAccountsTransactionFulls/withUndefined.ts

@@ -1,88 +0,0 @@
-import type { Config } from '@0xtorch/core'
-import type { LowerHex } from '../types'
-import { toLowerHex } from '../types'
-import { getHashesAndInternalTxs } from './getHashesAndInternalTxs'
-import { getTransactionDetails } from './getTransactionDetails'
-import type {
-  GetAccountsTransactionFullsCustomParametersAllUndefined,
-  GetAccountsTransactionFullsCustomReturnType,
-} from './types'
-
-export const getAccountsTransactionFullsCustomWithAllUndefined = async (
-  {
-    chain,
-    addresses,
-    fromBlock,
-    toBlock,
-    appDataSource,
-    onFetchHashes,
-    onFetchTransaction,
-  }: GetAccountsTransactionFullsCustomParametersAllUndefined,
-  config?: Config,
-): Promise<
-  GetAccountsTransactionFullsCustomReturnType<GetAccountsTransactionFullsCustomParametersAllUndefined>
-> => {
-  const timeoutTimestamp =
-    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-
-  // get transaction hash & internal transaction by explorer
-  const { hashes, internalTransactions } = await getHashesAndInternalTxs(
-    chain,
-    addresses,
-    fromBlock,
-    toBlock,
-    config,
-  )
-  if (hashes.length === 0) {
-    return []
-  }
-  if (onFetchHashes !== undefined) {
-    onFetchHashes(hashes.map((hash) => toLowerHex(hash)))
-  }
-
-  // get transaction detail of hashes
-  const timeoutForGetTransactionDetail = timeoutTimestamp - Date.now()
-  const transactionDetails = await getTransactionDetails(
-    chain,
-    hashes,
-    internalTransactions,
-    onFetchTransaction,
-    {
-      timeout: timeoutForGetTransactionDetail,
-      logger: config?.logger,
-    },
-  )
-
-  // get app of to address
-  const toAddresses = [
-    ...new Set(
-      transactionDetails
-        .map(({ to }) => (to === null ? undefined : toLowerHex(to)))
-        .filter((toAddress): toAddress is LowerHex => toAddress !== undefined),
-    ),
-  ]
-  const timeoutForGetApps = timeoutTimestamp - Date.now()
-  const apps = await Promise.all(
-    toAddresses.map((toAddress) =>
-      appDataSource === undefined
-        ? undefined
-        : appDataSource.getApp(chain.id, toAddress, {
-            timeout: timeoutForGetApps,
-            logger: config?.logger,
-          }),
-    ),
-  )
-
-  return transactionDetails.map((transactionDetail) => {
-    const appIndex =
-      transactionDetail.to === null
-        ? -1
-        : toAddresses.indexOf(toLowerHex(transactionDetail.to))
-    const app = appIndex < 0 ? undefined : apps[appIndex]
-    return {
-      ...transactionDetail,
-      app,
-      nativeTokenPrice: undefined,
-    }
-  })
-}

package/getTransactionFull/getTransactionFull.ts

@@ -1,30 +0,0 @@
-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/getTransactionFull/getTransactionFullCustom.ts

@@ -1,91 +0,0 @@
-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/getTransactionFull/index.ts

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

package/getTransactionFull/types.ts

@@ -1,98 +0,0 @@
-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/getTransactionFull/withD.ts

@@ -1,57 +0,0 @@
-import type { Config } from '@0xtorch/core'
-import { getTransactionDetail } from '../getTransactionDetail'
-import { toLowerHex } from '../types'
-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/getTransactionFull/withDA.ts

@@ -1,78 +0,0 @@
-/* eslint-disable unicorn/filename-case */
-import type { Config } from '@0xtorch/core'
-import { getTransactionDetail } from '../getTransactionDetail'
-import { toLowerHex } from '../types'
-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/getTransactionFull/withP.ts

@@ -1,69 +0,0 @@
-import type { Config, CryptoCurrencyPrice } from '@0xtorch/core'
-import { getTransactionDetail } from '../getTransactionDetail'
-import { toLowerHex } from '../types'
-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,
-  }
-}