@0xtorch/evm 0.0.31 → 0.0.32

package/decoder/decode.ts

@@ -537,6 +537,7 @@ const getErc20Token = async (
         coingeckoId: coin?.id,
         marketCapUsd: undefined,
       },
+      priceDatasourceId: undefined,
       updatedAt: Date.now(),
     },
   }

package/index.ts

@@ -92,15 +92,7 @@ export {
   createRoninExplorer,
 } from './explorers'
 export type { Explorer } from './explorers'
-export {
-  getAccountsTransactionFulls,
-  getAccountsTransactionFullsCustom,
-} from './getAccountsTransactionFulls'
 export { getTransactionDetail } from './getTransactionDetail'
-export {
-  getTransactionFull,
-  getTransactionFullCustom,
-} from './getTransactionFull'
 export { isHex, parsedLogSchema, toLowerHex } from './types'
 export type {
   Erc1155NftId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xtorch/evm",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "description": "Cryptorch EVM extension",
   "keywords": [
     "cryptorch",
@@ -38,7 +38,7 @@
   ],
   "dependencies": {
     "@0xtorch/big-decimal": "^0.0.10",
-    "@0xtorch/core": "^0.0.28",
+    "@0xtorch/core": "^0.0.29",
     "@supercharge/promise-pool": "^3.1.1",
     "viem": "^2.9.16",
     "zod": "^3.22.4"

package/getAccountsTransactionFulls/getAccountsTransactionFulls.ts

@@ -1,46 +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 { LowerHex } from '../types'
-import { getAccountsTransactionFullsCustom } from './getAccountsTransactionFullsCustom'
-
-type GetAccountsTransactionFullsParameters = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly fiat?: FiatCurrency
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export const getAccountsTransactionFulls = async (
-  {
-    chain,
-    addresses,
-    fromBlock,
-    toBlock,
-    fiat = usd,
-    onFetchHashes,
-    onFetchTransaction,
-  }: GetAccountsTransactionFullsParameters,
-  config?: Config,
-) =>
-  await getAccountsTransactionFullsCustom(
-    {
-      chain,
-      addresses,
-      fromBlock,
-      toBlock,
-      appDataSource: undefined,
-      priceDataSource: coingeckoCryptoCurrencyDataSource,
-      fiat,
-      decoder,
-      analyzer,
-      onFetchHashes,
-      onFetchTransaction,
-    },
-    config,
-  )

package/getAccountsTransactionFulls/getAccountsTransactionFullsCustom.ts

@@ -1,106 +0,0 @@
-import type { Config } from '@0xtorch/core'
-import type {
-  GetAccountsTransactionFullsCustomParameters,
-  GetAccountsTransactionFullsCustomParametersAllUndefined,
-  GetAccountsTransactionFullsCustomParametersD,
-  GetAccountsTransactionFullsCustomParametersDA,
-  GetAccountsTransactionFullsCustomParametersP,
-  GetAccountsTransactionFullsCustomParametersPD,
-  GetAccountsTransactionFullsCustomParametersPDA,
-  GetAccountsTransactionFullsCustomReturnType,
-} from './types'
-import { getAccountsTransactionFullsCustomWithD } from './withD'
-import { getAccountsTransactionFullsCustomWithDA } from './withDA'
-import { getAccountsTransactionFullsCustomWithP } from './withP'
-import { getAccountsTransactionFullsCustomWithPD } from './withPD'
-import { getAccountsTransactionFullsCustomWithPDA } from './withPDA'
-import { getAccountsTransactionFullsCustomWithAllUndefined } from './withUndefined'
-
-export const getAccountsTransactionFullsCustom = async <
-  T extends GetAccountsTransactionFullsCustomParameters,
->(
-  parameters: T,
-  config?: Config,
-): Promise<GetAccountsTransactionFullsCustomReturnType<T>> => {
-  if (isParametersAllUndefined(parameters)) {
-    const data = await getAccountsTransactionFullsCustomWithAllUndefined(
-      parameters,
-      config,
-    )
-    return data as GetAccountsTransactionFullsCustomReturnType<T>
-  }
-  if (isParametersP(parameters)) {
-    const data = await getAccountsTransactionFullsCustomWithP(
-      parameters,
-      config,
-    )
-    return data as GetAccountsTransactionFullsCustomReturnType<T>
-  }
-  if (isParametersPD(parameters)) {
-    const data = await getAccountsTransactionFullsCustomWithPD(
-      parameters,
-      config,
-    )
-    return data as GetAccountsTransactionFullsCustomReturnType<T>
-  }
-  if (isParametersPDA(parameters)) {
-    const data = await getAccountsTransactionFullsCustomWithPDA(
-      parameters,
-      config,
-    )
-    return data as GetAccountsTransactionFullsCustomReturnType<T>
-  }
-  if (isParametersD(parameters)) {
-    const data = await getAccountsTransactionFullsCustomWithD(
-      parameters,
-      config,
-    )
-    return data as GetAccountsTransactionFullsCustomReturnType<T>
-  }
-  if (isParametersDA(parameters)) {
-    const data = await getAccountsTransactionFullsCustomWithDA(
-      parameters,
-      config,
-    )
-    return data as GetAccountsTransactionFullsCustomReturnType<T>
-  }
-  throw new Error('not implemented')
-}
-
-const isParametersAllUndefined = (
-  parameters: GetAccountsTransactionFullsCustomParameters,
-): parameters is GetAccountsTransactionFullsCustomParametersAllUndefined =>
-  parameters.priceDataSource === undefined && parameters.decoder === undefined
-
-const isParametersP = (
-  parameters: GetAccountsTransactionFullsCustomParameters,
-): parameters is GetAccountsTransactionFullsCustomParametersP =>
-  parameters.priceDataSource !== undefined && parameters.decoder === undefined
-
-const isParametersPD = (
-  parameters: GetAccountsTransactionFullsCustomParameters,
-): parameters is GetAccountsTransactionFullsCustomParametersPD =>
-  parameters.priceDataSource !== undefined &&
-  parameters.decoder !== undefined &&
-  parameters.analyzer === undefined
-
-const isParametersPDA = (
-  parameters: GetAccountsTransactionFullsCustomParameters,
-): parameters is GetAccountsTransactionFullsCustomParametersPDA =>
-  parameters.priceDataSource !== undefined &&
-  parameters.decoder !== undefined &&
-  parameters.analyzer !== undefined
-
-const isParametersD = (
-  parameters: GetAccountsTransactionFullsCustomParameters,
-): parameters is GetAccountsTransactionFullsCustomParametersD =>
-  parameters.priceDataSource === undefined &&
-  parameters.decoder !== undefined &&
-  parameters.analyzer === undefined
-
-const isParametersDA = (
-  parameters: GetAccountsTransactionFullsCustomParameters,
-): parameters is GetAccountsTransactionFullsCustomParametersDA =>
-  parameters.priceDataSource === undefined &&
-  parameters.decoder !== undefined &&
-  parameters.analyzer !== undefined

package/getAccountsTransactionFulls/getDecodedTransactionsPrices.ts

@@ -1,97 +0,0 @@
-import type {
-  Config,
-  CryptoCurrency,
-  CryptoCurrencyDataSource,
-  CryptoCurrencyPrice,
-  FiatCurrency,
-} from '@0xtorch/core'
-import type { Chain } from '../chains'
-import type { TransactionDecoded } from '../types'
-
-export const getDecodedTransactionsPrices = async (
-  chain: Chain,
-  priceDataSource: CryptoCurrencyDataSource,
-  fiat: FiatCurrency,
-  transactions: readonly TransactionDecoded<undefined>[],
-  config?: Config,
-): Promise<readonly CryptoCurrencyPrice[]> => {
-  const timeoutTimestamp =
-    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-
-  // create currency timestamp range
-  const mut_currencyTimestamps: {
-    readonly currency: CryptoCurrency
-    minTimestamp: number
-    maxTimestamp: number
-  }[] = []
-  for (const transaction of transactions) {
-    const timestampMs = Number(transaction.block.timestamp) * 1000
-
-    // native token currency
-    const mut_nativeCurrency = mut_currencyTimestamps.find(
-      ({ currency }) => currency.id === chain.nativeToken.currency.id,
-    )
-    if (mut_nativeCurrency === undefined) {
-      mut_currencyTimestamps.push({
-        currency: chain.nativeToken.currency,
-        minTimestamp: timestampMs,
-        maxTimestamp: timestampMs,
-      })
-    } else {
-      mut_nativeCurrency.minTimestamp = Math.min(
-        mut_nativeCurrency.minTimestamp,
-        timestampMs,
-      )
-      mut_nativeCurrency.maxTimestamp = Math.max(
-        mut_nativeCurrency.maxTimestamp,
-        timestampMs,
-      )
-    }
-
-    // erc20 token currency
-    for (const { token } of transaction.erc20Transfers) {
-      if (token.currency.market.coingeckoId === undefined) {
-        continue
-      }
-      const mut_currency = mut_currencyTimestamps.find(
-        ({ currency }) => currency.id === token.currency.id,
-      )
-      if (mut_currency === undefined) {
-        mut_currencyTimestamps.push({
-          currency: token.currency,
-          minTimestamp: timestampMs,
-          maxTimestamp: timestampMs,
-        })
-      } else {
-        mut_currency.minTimestamp = Math.min(
-          mut_currency.minTimestamp,
-          timestampMs,
-        )
-        mut_currency.maxTimestamp = Math.max(
-          mut_currency.maxTimestamp,
-          timestampMs,
-        )
-      }
-    }
-  }
-
-  // get token price
-  const mut_prices: CryptoCurrencyPrice[] = []
-  for (const currencyTimestamp of mut_currencyTimestamps) {
-    const prices = await priceDataSource.getHistoricalPrices(
-      {
-        targetCurrencies: [currencyTimestamp.currency],
-        vsCurrency: fiat,
-        from: currencyTimestamp.minTimestamp - 1000 * 60 * 60,
-        to: currencyTimestamp.maxTimestamp + 1000 * 60 * 60,
-      },
-      {
-        timeout: timeoutTimestamp - Date.now(),
-        logger: config?.logger,
-      },
-    )
-    mut_prices.push(...prices)
-  }
-
-  return mut_prices
-}

package/getAccountsTransactionFulls/getHashesAndInternalTxs.ts

@@ -1,65 +0,0 @@
-import type { Config } from '@0xtorch/core'
-import type { Chain } from '../chains'
-import type { Hex, InternalTransaction, LowerHex } from '../types'
-import { checkTimeout } from '../utils'
-
-export const getHashesAndInternalTxs = async (
-  chain: Chain,
-  addresses: readonly LowerHex[],
-  fromBlock: bigint,
-  toBlock: bigint,
-  config?: Config,
-): Promise<{
-  readonly hashes: readonly Hex[]
-  readonly internalTransactions: readonly InternalTransaction<undefined>[]
-}> => {
-  const timeoutTimestamp =
-    Date.now() + (config?.timeout === undefined ? 60_000 : config.timeout)
-
-  const mut_internalTransactions: InternalTransaction<undefined>[] = []
-  const hashSet = new Set<Hex>()
-  for (const address of addresses) {
-    const normalTxHashes = await chain.explorer.getAddressTransactionHashes({
-      address,
-      startBlock: fromBlock,
-      endBlock: toBlock,
-      logger: config?.logger,
-    })
-    checkTimeout(timeoutTimestamp)
-
-    for (const hash of normalTxHashes) {
-      hashSet.add(hash)
-    }
-    const transferTxHashes = await chain.explorer.getAddressTokenTransferHashes(
-      {
-        address,
-        startBlock: fromBlock,
-        endBlock: toBlock,
-        logger: config?.logger,
-      },
-    )
-    checkTimeout(timeoutTimestamp)
-
-    for (const hash of transferTxHashes) {
-      hashSet.add(hash)
-    }
-    const internalTransactions =
-      await chain.explorer.getAddressInternalTransactions({
-        address,
-        startBlock: fromBlock,
-        endBlock: toBlock,
-        nativeCurrency: chain.nativeToken.currency,
-        logger: config?.logger,
-      })
-    checkTimeout(timeoutTimestamp)
-
-    for (const internalTransaction of internalTransactions) {
-      mut_internalTransactions.push(internalTransaction)
-      hashSet.add(internalTransaction.transactionHash)
-    }
-  }
-  return {
-    hashes: [...hashSet],
-    internalTransactions: mut_internalTransactions,
-  }
-}

package/getAccountsTransactionFulls/getTransactionDetails.ts

@@ -1,41 +0,0 @@
-import type { Config } from '@0xtorch/core'
-import { PromisePool } from '@supercharge/promise-pool'
-import type { Chain } from '../chains'
-import { getTransactionDetail } from '../getTransactionDetail'
-import type { Hex, InternalTransaction, TransactionDetail } from '../types'
-import { toLowerHex } from '../types'
-
-export const getTransactionDetails = async (
-  chain: Chain,
-  hashes: readonly Hex[],
-  internalTransactions: readonly InternalTransaction<undefined>[],
-  onFetchTransaction: ((hash: `0x${Lowercase<string>}`) => void) | undefined,
-  config?: Config,
-): Promise<readonly TransactionDetail[]> => {
-  const mut_transactions: TransactionDetail[] = []
-
-  const { errors } = await PromisePool.for(hashes)
-    .withConcurrency(chain.client.httpRpcCount)
-    .process(async (hash) => {
-      const transactionDetail = await getTransactionDetail(
-        {
-          chain,
-          hash,
-          internalTransactions: internalTransactions.filter(
-            ({ transactionHash }) => transactionHash === hash,
-          ),
-        },
-        config,
-      )
-      if (onFetchTransaction !== undefined) {
-        onFetchTransaction(toLowerHex(hash))
-      }
-      mut_transactions.push(transactionDetail)
-    })
-
-  if (errors.length > 0) {
-    throw errors[0]
-  }
-
-  return mut_transactions
-}

package/getAccountsTransactionFulls/getTransactionsApps.ts

@@ -1,42 +0,0 @@
-import type { App, Config } from '@0xtorch/core'
-import type { AppDataSource } from '../apps'
-import type { LowerHex, TransactionDetail } from '../types'
-import { toLowerHex } from '../types'
-
-export const getTransactionsApps = async (
-  appDataSource: AppDataSource | undefined,
-  transactionos: readonly TransactionDetail[],
-  config?: Config,
-): Promise<
-  {
-    readonly address: LowerHex
-    readonly app: App | undefined
-  }[]
-> => {
-  if (transactionos.length === 0) {
-    return []
-  }
-  const { chainId } = transactionos[0]
-
-  // to addresses
-  const toAddresses = [
-    ...new Set(
-      transactionos
-        .map(({ to }) => (to === null ? undefined : toLowerHex(to)))
-        .filter((toAddress): toAddress is LowerHex => toAddress !== undefined),
-    ),
-  ]
-
-  const apps = await Promise.all(
-    toAddresses.map((toAddress) =>
-      appDataSource === undefined
-        ? undefined
-        : appDataSource.getApp(chainId, toAddress, config),
-    ),
-  )
-
-  return toAddresses.map((address, index) => ({
-    address,
-    app: apps[index],
-  }))
-}

package/getAccountsTransactionFulls/index.ts

@@ -1,2 +0,0 @@
-export { getAccountsTransactionFulls } from './getAccountsTransactionFulls'
-export { getAccountsTransactionFullsCustom } from './getAccountsTransactionFullsCustom'

package/getAccountsTransactionFulls/types.ts

@@ -1,122 +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 { LowerHex, TransactionFull } from '../types'
-
-export type GetAccountsTransactionFullsCustomParameters =
-  | GetAccountsTransactionFullsCustomParametersAllUndefined
-  | GetAccountsTransactionFullsCustomParametersP
-  | GetAccountsTransactionFullsCustomParametersPD
-  | GetAccountsTransactionFullsCustomParametersPDA
-  | GetAccountsTransactionFullsCustomParametersD
-  | GetAccountsTransactionFullsCustomParametersDA
-
-export type GetAccountsTransactionFullsCustomParametersAllUndefined = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly appDataSource: AppDataSource | undefined
-  readonly priceDataSource: undefined
-  readonly fiat: undefined
-  readonly decoder: undefined
-  readonly analyzer: undefined
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export type GetAccountsTransactionFullsCustomParametersP = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly appDataSource: AppDataSource | undefined
-  readonly priceDataSource: CryptoCurrencyDataSource
-  readonly fiat: FiatCurrency
-  readonly decoder: undefined
-  readonly analyzer: undefined
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export type GetAccountsTransactionFullsCustomParametersPD = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly appDataSource: AppDataSource | undefined
-  readonly priceDataSource: CryptoCurrencyDataSource
-  readonly fiat: FiatCurrency
-  readonly decoder: Decoder
-  readonly analyzer: undefined
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export type GetAccountsTransactionFullsCustomParametersPDA = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly appDataSource: AppDataSource | undefined
-  readonly priceDataSource: CryptoCurrencyDataSource
-  readonly fiat: FiatCurrency
-  readonly decoder: Decoder
-  readonly analyzer: Analyzer<CryptoCurrencyPrice | undefined>
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export type GetAccountsTransactionFullsCustomParametersD = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly appDataSource: AppDataSource | undefined
-  readonly priceDataSource: undefined
-  readonly fiat: undefined
-  readonly decoder: Decoder
-  readonly analyzer: undefined
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export type GetAccountsTransactionFullsCustomParametersDA = {
-  readonly chain: Chain
-  readonly addresses: readonly LowerHex[]
-  readonly fromBlock: bigint
-  readonly toBlock: bigint
-  readonly appDataSource: AppDataSource | undefined
-  readonly priceDataSource: undefined
-  readonly fiat: undefined
-  readonly decoder: Decoder
-  readonly analyzer: Analyzer<undefined>
-  readonly onFetchHashes?: (hashes: readonly LowerHex[]) => void
-  readonly onFetchTransaction?: (hash: LowerHex) => void
-}
-
-export type GetAccountsTransactionFullsCustomReturnType<
-  T extends GetAccountsTransactionFullsCustomParameters,
-> = T extends GetAccountsTransactionFullsCustomParametersAllUndefined
-  ? readonly TransactionFull<undefined, false, false>[]
-  : T extends GetAccountsTransactionFullsCustomParametersP
-    ? readonly TransactionFull<CryptoCurrencyPrice | undefined, false, false>[]
-    : T extends GetAccountsTransactionFullsCustomParametersPD
-      ? readonly TransactionFull<CryptoCurrencyPrice | undefined, true, false>[]
-      : T extends GetAccountsTransactionFullsCustomParametersPDA
-        ? readonly TransactionFull<
-            CryptoCurrencyPrice | undefined,
-            true,
-            true
-          >[]
-        : T extends GetAccountsTransactionFullsCustomParametersD
-          ? readonly TransactionFull<undefined, true, false>[]
-          : T extends GetAccountsTransactionFullsCustomParametersDA
-            ? readonly TransactionFull<undefined, true, true>[]
-            : never

package/getAccountsTransactionFulls/withD.ts

@@ -1,80 +0,0 @@
-import type { Config } from '@0xtorch/core'
-import { toLowerHex } from '../types'
-import { getHashesAndInternalTxs } from './getHashesAndInternalTxs'
-import { getTransactionDetails } from './getTransactionDetails'
-import { getTransactionsApps } from './getTransactionsApps'
-import type {
-  GetAccountsTransactionFullsCustomParametersD,
-  GetAccountsTransactionFullsCustomReturnType,
-} from './types'
-
-export const getAccountsTransactionFullsCustomWithD = async (
-  {
-    chain,
-    addresses,
-    fromBlock,
-    toBlock,
-    appDataSource,
-    decoder,
-    onFetchHashes,
-    onFetchTransaction,
-  }: GetAccountsTransactionFullsCustomParametersD,
-  config?: Config,
-): Promise<
-  GetAccountsTransactionFullsCustomReturnType<GetAccountsTransactionFullsCustomParametersD>
-> => {
-  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,
-  })
-
-  // get apps
-  const apps = await getTransactionsApps(appDataSource, transactionDetails, {
-    timeout: timeoutTimestamp - Date.now(),
-    logger: config?.logger,
-  })
-
-  return transactionsDecoded.map((transaction) => {
-    const lowerTo =
-      transaction.to === null ? undefined : toLowerHex(transaction.to)
-    const app = apps.find(({ address }) => address === lowerTo)?.app
-
-    return {
-      ...transaction,
-      app,
-      nativeTokenPrice: undefined,
-    }
-  })
-}