@0xtorch/evm 0.0.1

package/src/getAccountsTransactionFulls/withDA.ts

@@ -0,0 +1,112 @@
+/* eslint-disable unicorn/filename-case */
+import type { Config } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getHashesAndInternalTxs } from './getHashesAndInternalTxs'
+import { getTransactionDetails } from './getTransactionDetails'
+import { getTransactionsApps } from './getTransactionsApps'
+import type {
+  GetAccountsTransactionFullsCustomParametersDA,
+  GetAccountsTransactionFullsCustomReturnType,
+} from './types'
+
+export const getAccountsTransactionFullsCustomWithDA = async (
+  {
+    chain,
+    addresses,
+    fromBlock,
+    toBlock,
+    appDataSource,
+    decoder,
+    analyzer,
+    onFetchHashes,
+    onFetchTransaction,
+  }: GetAccountsTransactionFullsCustomParametersDA,
+  config?: Config,
+): Promise<
+  GetAccountsTransactionFullsCustomReturnType<GetAccountsTransactionFullsCustomParametersDA>
+> => {
+  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,
+    },
+  )
+
+  // get apps
+  const apps = await getTransactionsApps(appDataSource, transactionDetails, {
+    timeout: timeoutTimestamp - Date.now(),
+    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
+    return {
+      ...transaction,
+      app,
+      nativeTokenPrice: undefined,
+    }
+  })
+
+  // analyze
+  const timeoutForAnalyze = timeoutTimestamp - Date.now()
+  const analyzedDatas = await Promise.all(
+    transactionsForAnalyzer.map((transactionForAnalyzer) =>
+      analyzer.analyze(
+        {
+          chain,
+          transaction: transactionForAnalyzer,
+          accountAddresses: addresses,
+        },
+        {
+          timeout: timeoutForAnalyze,
+          logger: config?.logger,
+        },
+      ),
+    ),
+  )
+
+  return transactionsForAnalyzer.map((transactionForAnalyzer, index) => ({
+    ...transactionForAnalyzer,
+    accountAddresses: addresses,
+    actions: analyzedDatas[index].actions,
+    accountActions: analyzedDatas[index].accountActions,
+  }))
+}

package/src/getAccountsTransactionFulls/withP.ts

@@ -0,0 +1,120 @@
+import type { Config, CryptoCurrencyPrice } from '@0xtorch/core'
+import { toLowerHex } from '../types'
+import { getHashesAndInternalTxs } from './getHashesAndInternalTxs'
+import { getTransactionDetails } from './getTransactionDetails'
+import { getTransactionsApps } from './getTransactionsApps'
+import type {
+  GetAccountsTransactionFullsCustomParametersP,
+  GetAccountsTransactionFullsCustomReturnType,
+} from './types'
+
+export const getAccountsTransactionFullsCustomWithP = async (
+  {
+    chain,
+    addresses,
+    fromBlock,
+    toBlock,
+    appDataSource,
+    priceDataSource,
+    fiat,
+    onFetchHashes,
+    onFetchTransaction,
+  }: GetAccountsTransactionFullsCustomParametersP,
+  config?: Config,
+): Promise<
+  GetAccountsTransactionFullsCustomReturnType<GetAccountsTransactionFullsCustomParametersP>
+> => {
+  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,
+    },
+  )
+
+  // native token price timestamp range
+  const minTimestamp = transactionDetails.reduce(
+    (minTimestamp, { block }) =>
+      Math.min(minTimestamp, Number(block.timestamp)),
+    Number.MAX_SAFE_INTEGER,
+  )
+  const maxTimestamp = transactionDetails.reduce(
+    (maxTimestamp, { block }) =>
+      Math.max(maxTimestamp, Number(block.timestamp)),
+    0,
+  )
+  const from = minTimestamp * 1000 - 1000 * 60 * 60
+  const to = maxTimestamp * 1000 + 1000 * 60 * 60
+
+  const timeoutForDataSource = timeoutTimestamp - Date.now()
+  const [apps, prices] = await Promise.all([
+    // get apps
+    getTransactionsApps(appDataSource, transactionDetails, {
+      timeout: timeoutForDataSource,
+      logger: config?.logger,
+    }),
+    // get native token prices
+    priceDataSource.getHistoricalPrices(
+      {
+        targetCurrencies: [chain.nativeToken.currency],
+        vsCurrency: fiat,
+        from,
+        to,
+      },
+      {
+        timeout: timeoutForDataSource,
+        logger: config?.logger,
+      },
+    ),
+  ])
+
+  return transactionDetails.map((transactionDetail) => {
+    const lowerTo =
+      transactionDetail.to === null
+        ? undefined
+        : toLowerHex(transactionDetail.to)
+    const app = apps.find(({ address }) => address === lowerTo)?.app
+    const price = prices.reduce(
+      (closestPrice: CryptoCurrencyPrice | undefined, price) =>
+        closestPrice === undefined ||
+        Math.abs(
+          price.timestamp - Number(transactionDetail.block.timestamp) * 1000,
+        ) <
+          Math.abs(
+            closestPrice.timestamp -
+              Number(transactionDetail.block.timestamp) * 1000,
+          )
+          ? price
+          : closestPrice,
+      undefined,
+    )
+    return {
+      ...transactionDetail,
+      app,
+      nativeTokenPrice: price,
+    }
+  })
+}

package/src/getAccountsTransactionFulls/withPD.ts

@@ -0,0 +1,141 @@
+/* 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 {
+  GetAccountsTransactionFullsCustomParametersPD,
+  GetAccountsTransactionFullsCustomReturnType,
+} from './types'
+
+export const getAccountsTransactionFullsCustomWithPD = async (
+  {
+    chain,
+    addresses,
+    fromBlock,
+    toBlock,
+    appDataSource,
+    priceDataSource,
+    fiat,
+    decoder,
+    onFetchHashes,
+    onFetchTransaction,
+  }: GetAccountsTransactionFullsCustomParametersPD,
+  config?: Config,
+): Promise<
+  GetAccountsTransactionFullsCustomReturnType<GetAccountsTransactionFullsCustomParametersPD>
+> => {
+  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,
+      },
+    ),
+  ])
+
+  return 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, price) =>
+        Math.abs(price.timestamp - timestampMs) <
+        Math.abs(closestPrice.timestamp - timestampMs)
+          ? price
+          : closestPrice,
+      )
+
+    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,
+          ),
+      })),
+    }
+  })
+}

package/src/getAccountsTransactionFulls/withPDA.ts

@@ -0,0 +1,167 @@
+/* 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/src/getAccountsTransactionFulls/withUndefined.ts

@@ -0,0 +1,88 @@
+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/src/getContractAbi.ts

@@ -0,0 +1,15 @@
+import type { Chain } from './chains'
+import type { Hex } from './types'
+
+type GetContractAbiParameters<TChain extends Chain> = {
+  readonly chain: TChain
+  readonly address: Hex
+}
+
+export const getContractAbi = <TChain extends Chain>(
+  parameters: GetContractAbiParameters<TChain>,
+): Promise<string> => {
+  // TODO implement
+  console.debug(parameters)
+  throw new Error('Not implemented')
+}

package/src/getTransactionFull/getTransactionDetail.ts

@@ -0,0 +1,47 @@
+import type { Config } from '@0xtorch/core'
+import type { Chain } from '../chains'
+import type { Hex, TransactionDetail } from '../types'
+
+export const getTransactionDetail = async (
+  chain: Chain,
+  hash: Hex,
+  config?: Config,
+): Promise<TransactionDetail | undefined> => {
+  // transaction 取得
+  const [transaction, receipt, internalTransactions] = await Promise.all([
+    chain.client.getTransaction(hash, config),
+    chain.client.getTransactionReceipt(hash, config),
+    chain.explorer.getInternalTransactionOfTransaction({
+      hash,
+      nativeCurrency: chain.nativeToken.currency,
+      logger: config?.logger,
+    }),
+  ])
+  if (transaction.blockNumber === null) {
+    throw new Error('Transaction is not mined yet')
+  }
+  const block = await chain.client.getBlock(transaction.blockNumber)
+  if (
+    block.hash === null ||
+    block.logsBloom === null ||
+    block.nonce === null ||
+    block.number === null
+  ) {
+    throw new Error('Block is not mined yet')
+  }
+  return {
+    ...transaction,
+    ...receipt,
+    type: transaction.type,
+    chainId: chain.id,
+    block: {
+      ...block,
+      hash: block.hash,
+      logsBloom: block.logsBloom,
+      nonce: block.nonce,
+      number: block.number,
+      transactions: [],
+    },
+    internalTransactions,
+  }
+}