@0xtorch/evm 0.0.1

package/src/chains/externals/defillama/constants.ts

@@ -0,0 +1 @@
+export const baseCoinsUrl = 'https://coins.llama.fi' as const

package/src/chains/externals/defillama/getBlockOfTimestamp.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'bun:test'
+import { getBlockOfTimestamp } from './getBlockOfTimestamp'
+
+describe('getBlockOfTimestamp', () => {
+  it('should return the block number', async () => {
+    const blockNumber = await getBlockOfTimestamp({
+      chain: 'ethereum',
+      timestamp: Math.floor(Date.now() / 1000),
+    })
+    expect(blockNumber).toBeGreaterThan(0n)
+  })
+})

package/src/chains/externals/defillama/getBlockOfTimestamp.ts

@@ -0,0 +1,26 @@
+import type { Logger } from '@0xtorch/core'
+import { rest } from '@0xtorch/core'
+import { z } from 'zod'
+import { baseCoinsUrl } from './constants'
+
+type GetBlockOfTimestampParameters = {
+  readonly chain: string
+  /** UNIX timestamp */
+  readonly timestamp: number
+  readonly logger?: Logger
+}
+
+export const getBlockOfTimestamp = async ({
+  chain,
+  timestamp,
+  logger,
+}: GetBlockOfTimestampParameters): Promise<bigint> => {
+  const { height } = await rest(`${baseCoinsUrl}/block/${chain}/${timestamp}`, {
+    schema: z.object({
+      height: z.number().int().positive().transform(BigInt),
+      timestamp: z.number().int().positive(),
+    }),
+    logger,
+  })
+  return height
+}

package/src/chains/externals/defillama/index.ts

@@ -0,0 +1 @@
+export { getBlockOfTimestamp } from './getBlockOfTimestamp'

package/src/chains/externals/index.ts

@@ -0,0 +1 @@
+export { getBlockOfTimestamp as getBlockOfTimestampByDefillama } from './defillama'

package/src/chains/index.ts

@@ -0,0 +1,62 @@
+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,
+  lineaHttpRpcs,
+  lineaWebsocketRpcUrls,
+  mantleHttpRpcs,
+  mantleWebsocketRpcUrls,
+  metisHttpRpcs,
+  metisWebsocketRpcUrls,
+  moonbeamHttpRpcs,
+  moonbeamWebsocketRpcUrls,
+  moonriverHttpRpcs,
+  moonriverWebsocketRpcUrls,
+  optimismHttpRpcs,
+  optimismWebsocketRpcUrls,
+  polygonPosHttpRpcs,
+  polygonPosWebsocketRpcUrls,
+  roninHttpRpcs,
+  roninWebsocketRpcUrls,
+} from './definitions'
+export { getBlockOfTimestampByDefillama } from './externals'
+export type { Chain, HttpRpc } from './types'

package/src/chains/types/chain.ts

@@ -0,0 +1,22 @@
+import type { CryptoCurrency } from '@0xtorch/core'
+import type { Client } from '../../clients'
+import type { Explorer } from '../../explorers'
+
+export type Chain = {
+  readonly id: number
+  readonly network: string
+  readonly name: string
+  readonly nativeToken: ChainNativeToken
+  readonly explorer: Explorer
+  readonly client: Client
+  readonly blockTime: number | undefined
+  readonly coingeckoId: string | undefined
+  readonly defillamaId: string | undefined
+}
+
+type ChainNativeToken = {
+  readonly name: string
+  readonly symbol: string
+  readonly decimals: number
+  readonly currency: CryptoCurrency
+}

package/src/chains/types/index.ts

@@ -0,0 +1,2 @@
+export type { Chain } from './chain'
+export type { HttpRpc } from './rpc'

package/src/chains/types/rpc.ts

@@ -0,0 +1,6 @@
+export type HttpRpc = {
+  readonly url: string
+  readonly isArchive: boolean
+  readonly getLogsIsUsable: boolean
+  readonly getLogsMaxBlockRange: bigint
+}

package/src/clients/definitions/defineClient.ts

@@ -0,0 +1,7 @@
+import type { Client } from '../types'
+
+export const defineClient = <const TClient extends Client>(
+  client: TClient,
+): TClient => ({
+  ...client,
+})

package/src/clients/definitions/index.ts

@@ -0,0 +1 @@
+export { createViemClient } from './viemClient'

package/src/clients/definitions/viemClient.ts

@@ -0,0 +1,86 @@
+import type { Logger } from '@0xtorch/core'
+import type { AbiEvent } from 'abitype'
+import type {
+  Abi,
+  ContractFunctionName,
+  GetLogsReturnType,
+  MulticallParameters,
+  MulticallReturnType,
+  ReadContractParameters,
+  ReadContractReturnType,
+  Chain as ViemChain,
+} from 'viem'
+import type { HttpRpc } from '../../chains'
+import type { LowerHex } from '../../types'
+import {
+  estimateFeesPerGas,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getEventLogs,
+  getTransaction,
+  getTransactionCount,
+  getTransactionReceipt,
+  multicall,
+  readContract,
+} from '../externals/viem'
+import { defineClient } from './defineClient'
+
+type CreateViemClientParameters<TChain extends ViemChain> = {
+  readonly chain: TChain
+  readonly httpRpcs: readonly HttpRpc[]
+}
+
+export const createViemClient = <TChain extends ViemChain>({
+  chain,
+  httpRpcs,
+}: CreateViemClientParameters<TChain>) =>
+  defineClient({
+    httpRpcCount: httpRpcs.length,
+    estimateFeesPerGas: async (config) =>
+      estimateFeesPerGas({ chain, httpRpcs }, config),
+    getBalance: async (address, config) =>
+      getBalance({ chain, httpRpcs, address }, config),
+    getBlock: async (blockNumber, config) =>
+      getBlock({ chain, httpRpcs, blockNumber }, config),
+    getBlockNumber: async (config) =>
+      getBlockNumber({ chain, httpRpcs }, config),
+    getEventLogs: async <const TAbiEvent extends AbiEvent>(
+      parameters: {
+        readonly contractAddress: LowerHex
+        readonly event: TAbiEvent
+        readonly fromBlock: bigint
+        readonly toBlock: bigint
+      },
+      config?: {
+        readonly timeout?: number
+        readonly logger?: Logger
+      },
+    ): Promise<GetLogsReturnType<TAbiEvent>> =>
+      getEventLogs({ ...parameters, chain, httpRpcs }, config),
+    getTransaction: (hash, config) =>
+      getTransaction({ chain, httpRpcs, hash }, config),
+    getTransactionCount: async (address, config) =>
+      getTransactionCount({ chain, httpRpcs, address }, config),
+    getTransactionReceipt: async (hash, config) =>
+      getTransactionReceipt({ chain, httpRpcs, hash }, config),
+    multicall: async <const TContracts extends readonly unknown[]>(
+      parameters: MulticallParameters<TContracts>,
+      config?: {
+        readonly timeout?: number
+        readonly logger?: Logger
+      },
+    ): Promise<MulticallReturnType<TContracts>> =>
+      multicall({ chain, httpRpcs, parameters }, config),
+    readContract: async <
+      const TAbi extends Abi | readonly unknown[],
+      const TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>,
+    >(
+      parameters: ReadContractParameters<TAbi, TFunctionName>,
+      config?: {
+        readonly timeout?: number
+        readonly logger?: Logger
+      },
+    ): Promise<ReadContractReturnType<TAbi, TFunctionName>> =>
+      readContract({ chain, httpRpcs, parameters }, config),
+  })

package/src/clients/externals/viem/estimateFeesPerGas.ts

@@ -0,0 +1,23 @@
+import type { Logger } from '@0xtorch/core'
+import type { FeeValues, Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import { createViemClient } from './middleware'
+
+type EstimateFeesPerGasParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+}
+
+export const estimateFeesPerGas = async (
+  { chain, httpRpcs }: EstimateFeesPerGasParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<FeeValues> =>
+  createViemClient(chain, httpRpcs).wrapper(
+    async (client) => await client.estimateFeesPerGas(),
+    undefined,
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getBalance.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '@0xtorch/core'
+import type { Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import type { LowerHex } from '../../../types'
+import { createViemClient } from './middleware'
+
+type GetBalanceParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+  readonly address: LowerHex
+}
+
+export const getBalance = async (
+  { chain, httpRpcs, address }: GetBalanceParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<bigint> =>
+  createViemClient(chain, httpRpcs).wrapper<bigint>(
+    async (client) => await client.getBalance({ address }),
+    undefined,
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getBlock.ts

@@ -0,0 +1,29 @@
+import type { Logger } from '@0xtorch/core'
+import type { Block, Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import { createViemClient } from './middleware'
+
+type GetBlockParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+  readonly blockNumber: bigint
+}
+
+export const getBlock = async (
+  { chain, httpRpcs, blockNumber }: GetBlockParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<Block<bigint, false, 'latest'>> =>
+  createViemClient(chain, httpRpcs).wrapper(
+    async (client) =>
+      (await client.getBlock({ blockNumber })) as Block<
+        bigint,
+        false,
+        'latest'
+      >,
+    { onlyArchive: true },
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getBlockNumber.ts

@@ -0,0 +1,23 @@
+import type { Logger } from '@0xtorch/core'
+import type { Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import { createViemClient } from './middleware'
+
+type GetBlockNumberParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+}
+
+export const getBlockNumber = async (
+  { chain, httpRpcs }: GetBlockNumberParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<bigint> =>
+  createViemClient(chain, httpRpcs).wrapper<bigint>(
+    async (client) => await client.getBlockNumber(),
+    undefined,
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getEventLogs.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'bun:test'
+import { polygon } from 'viem/chains'
+import { polygonPosHttpRpcs } from '../../../chains'
+import { getEventLogs } from './getEventLogs'
+import { relayEvent } from './tests'
+
+describe('getEventLogs', () => {
+  it('test', async () => {
+    const toBlock = 50_000_000n
+    const fromBlock = toBlock - 5000n + 1n
+    const logs = await getEventLogs({
+      chain: polygon,
+      httpRpcs: polygonPosHttpRpcs,
+      contractAddress: '0x88dcdc47d2f83a99cf0000fdf667a468bb958a78',
+      event: relayEvent,
+      fromBlock,
+      toBlock,
+    })
+    console.debug(logs)
+    expect(logs).toBeDefined()
+  })
+})

package/src/clients/externals/viem/getEventLogs.ts

@@ -0,0 +1,40 @@
+import type { Logger } from '@0xtorch/core'
+import type { AbiEvent } from 'abitype'
+import type { GetLogsReturnType, Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import type { LowerHex } from '../../../types'
+import { createViemClient } from './middleware'
+
+type GetEventLogsParameters<TAbiEvent extends AbiEvent> = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+  readonly contractAddress: LowerHex
+  readonly event: TAbiEvent
+  readonly fromBlock: bigint
+  readonly toBlock: bigint
+}
+
+export const getEventLogs = async <const TAbiEvent extends AbiEvent>(
+  {
+    chain,
+    httpRpcs,
+    contractAddress,
+    event,
+    fromBlock,
+    toBlock,
+  }: GetEventLogsParameters<TAbiEvent>,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<GetLogsReturnType<TAbiEvent>> =>
+  createViemClient(chain, httpRpcs).getLogs(
+    {
+      address: contractAddress,
+      event,
+      fromBlock,
+      toBlock,
+    },
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getTransaction.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '@0xtorch/core'
+import type { Transaction, Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import type { Hex } from '../../../types'
+import { createViemClient } from './middleware'
+
+type GetTransactionParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+  readonly hash: Hex
+}
+
+export const getTransaction = async (
+  { chain, httpRpcs, hash }: GetTransactionParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<Transaction> =>
+  createViemClient(chain, httpRpcs).wrapper(
+    async (client) => (await client.getTransaction({ hash })) as Transaction,
+    { onlyArchive: true },
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getTransactionCount.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '@0xtorch/core'
+import type { Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import type { Hex } from '../../../types'
+import { createViemClient } from './middleware'
+
+type GetTransactionCountParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+  readonly address: Hex
+}
+
+export const getTransactionCount = async (
+  { chain, httpRpcs, address }: GetTransactionCountParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<number> =>
+  createViemClient(chain, httpRpcs).wrapper(
+    async (client) => await client.getTransactionCount({ address }),
+    undefined,
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/getTransactionReceipt.ts

@@ -0,0 +1,25 @@
+import type { Logger } from '@0xtorch/core'
+import type { TransactionReceipt, Chain as ViemChain } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import type { Hex } from '../../../types'
+import { createViemClient } from './middleware'
+
+type GetTransactionReceiptParameters = {
+  readonly chain: ViemChain
+  readonly httpRpcs: readonly HttpRpc[]
+  readonly hash: Hex
+}
+
+export const getTransactionReceipt = async (
+  { chain, httpRpcs, hash }: GetTransactionReceiptParameters,
+  config?: {
+    readonly timeout?: number
+    readonly logger?: Logger
+  },
+): Promise<TransactionReceipt> =>
+  createViemClient(chain, httpRpcs).wrapper<TransactionReceipt>(
+    async (client) => await client.getTransactionReceipt({ hash }),
+    { onlyArchive: true },
+    config?.timeout,
+    config?.logger,
+  )

package/src/clients/externals/viem/index.ts

@@ -0,0 +1,10 @@
+export { estimateFeesPerGas } from './estimateFeesPerGas'
+export { getBalance } from './getBalance'
+export { getBlock } from './getBlock'
+export { getBlockNumber } from './getBlockNumber'
+export { getEventLogs } from './getEventLogs'
+export { getTransaction } from './getTransaction'
+export { getTransactionCount } from './getTransactionCount'
+export { getTransactionReceipt } from './getTransactionReceipt'
+export { multicall } from './multicall'
+export { readContract } from './readContract'