@0xtorch/evm 0.0.61 → 0.0.63

package/clients/definitions/viemClient.ts

@@ -1,101 +0,0 @@
-import type { Logger } from '@0xtorch/core'
-import type { AbiEvent } from 'abitype'
-import type {
-  Abi,
-  ContractFunctionName,
-  GetLogsReturnType,
-  MulticallParameters,
-  MulticallReturnType,
-  PublicClient,
-  ReadContractParameters,
-  ReadContractReturnType,
-  Chain as ViemChain,
-} from 'viem'
-import type { HttpRpc } from '../../chains'
-import type { LowerHex } from '../../types'
-import {
-  createViemInstance,
-  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,
-    call: async <T>(
-      caller: (client: PublicClient) => Promise<T>,
-      config:
-        | {
-            readonly timeout?: number
-            readonly logger?: Logger
-          }
-        | undefined,
-    ) =>
-      createViemInstance(chain, httpRpcs).call(
-        caller,
-        config?.timeout ?? 60_000,
-      ),
-    estimateFeesPerGas: async (type, config) =>
-      estimateFeesPerGas({ chain, httpRpcs, type }, 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/clients/externals/viem/createViemInstance.ts

@@ -1,208 +0,0 @@
-import type { AbiEvent } from 'abitype'
-import type { Chain, GetLogsReturnType, PublicClient } from 'viem'
-import {
-  http,
-  HttpRequestError,
-  InvalidInputRpcError,
-  TransactionReceiptNotFoundError,
-  createPublicClient,
-} from 'viem'
-import type { HttpRpc } from '../../../chains'
-import type { LowerHex } from '../../../types'
-import { bigIntMin } from '../../../utils'
-
-type RpcCondition = {
-  isArchive?: boolean
-  getLogsIsUsable?: boolean
-}
-
-export const createViemInstance = (() => {
-  const mut_endpoints: string[] = []
-  const endpointChainIds = new Map<string, number>()
-  const endpointIsArchives = new Map<string, boolean>()
-  const endpointGetLogsIsUsables = new Map<string, boolean>()
-  const endpointGetLogsMaxBlockRanges = new Map<string, bigint>()
-  const busyEndpoints = new Set<string>()
-  const cooldownEndpoints = new Map<string, number>()
-
-  const getAvailableEndpoint = async (
-    chainId: number,
-    timeout: number,
-    rpcCondition?: RpcCondition,
-  ): Promise<string> => {
-    const start = Date.now()
-    const repeat = true
-    while (repeat) {
-      const now = Date.now()
-      const availableEndpoint = mut_endpoints.find(
-        (endpoint) =>
-          endpointChainIds.get(endpoint) === chainId &&
-          !busyEndpoints.has(endpoint) &&
-          (!cooldownEndpoints.has(endpoint) ||
-            (cooldownEndpoints.get(endpoint) ?? 0) <= now) &&
-          (rpcCondition?.isArchive !== true ||
-            endpointIsArchives.get(endpoint) === true) &&
-          (rpcCondition?.getLogsIsUsable !== true ||
-            endpointGetLogsIsUsables.get(endpoint) === true),
-      )
-
-      if (availableEndpoint !== undefined) {
-        return availableEndpoint
-      }
-
-      if (Date.now() - start > timeout) {
-        throw new Error('Timeout')
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-    }
-    throw new Error('No available endpoint')
-  }
-
-  const cooldownEndpoint = (endpoint: string, time = 60_000): void => {
-    cooldownEndpoints.set(endpoint, Date.now() + time)
-  }
-
-  const call = async <T>(
-    chain: Chain,
-    caller: (client: PublicClient) => Promise<T>,
-    timeout: number,
-    rpcCondition?: RpcCondition,
-  ): Promise<T> => {
-    const start = Date.now()
-    const endpoint = await getAvailableEndpoint(chain.id, timeout, rpcCondition)
-    // TODO 後で消す
-    console.debug('Selected endpoint:', endpoint)
-    busyEndpoints.add(endpoint)
-
-    try {
-      const client = createPublicClient({
-        chain,
-        transport: http(endpoint),
-      })
-      return await caller(client)
-    } catch (error) {
-      if (
-        (error instanceof HttpRequestError && error.status === 429) ||
-        (error instanceof Error &&
-          error.message.includes('The request timed out.'))
-      ) {
-        // TODO 後で消す
-        console.debug(error)
-        cooldownEndpoint(endpoint)
-        return await call(chain, caller, timeout - (Date.now() - start))
-      }
-      if (
-        error instanceof TransactionReceiptNotFoundError ||
-        error instanceof HttpRequestError ||
-        error instanceof InvalidInputRpcError
-      ) {
-        // TODO 後で消す
-        console.debug(error)
-        cooldownEndpoint(endpoint, 5000)
-        return await call(chain, caller, timeout - (Date.now() - start))
-      }
-      throw error
-    } finally {
-      busyEndpoints.delete(endpoint)
-    }
-  }
-
-  const getLogs = async <T extends AbiEvent>(
-    chain: Chain,
-    {
-      address,
-      event,
-      fromBlock,
-      toBlock,
-    }: {
-      readonly address: LowerHex
-      readonly event: T
-      readonly fromBlock: bigint
-      readonly toBlock: bigint
-    },
-    timeout: number,
-  ) => {
-    const start = Date.now()
-
-    const mut_logs: GetLogsReturnType<T>[] = []
-    let mut_currentFromBlock = fromBlock
-    let mut_currentToBlock = 0n
-    while (mut_currentFromBlock <= toBlock) {
-      const remain = timeout - (Date.now() - start)
-      const endpoint = await getAvailableEndpoint(chain.id, remain, {
-        isArchive: true,
-        getLogsIsUsable: true,
-      })
-      busyEndpoints.add(endpoint)
-      const getLogsMaxBlockRange =
-        endpointGetLogsMaxBlockRanges.get(endpoint) ?? 1000n
-
-      try {
-        const client = createPublicClient({
-          chain,
-          transport: http(endpoint),
-        })
-        mut_currentToBlock = bigIntMin(
-          mut_currentFromBlock + getLogsMaxBlockRange - 1n,
-          toBlock,
-        )
-        const logs = await client.getLogs({
-          address,
-          event,
-          fromBlock: mut_currentFromBlock,
-          toBlock: mut_currentToBlock,
-        })
-        mut_logs.push(logs)
-        mut_currentFromBlock = mut_currentToBlock + 1n
-      } catch (error) {
-        if (error instanceof HttpRequestError && error.status === 429) {
-          cooldownEndpoint(endpoint)
-        } else {
-          throw error
-        }
-      } finally {
-        busyEndpoints.delete(endpoint)
-      }
-    }
-
-    const allLogs = mut_logs
-      .flat()
-      .toSorted((a, b) => Number(a.blockNumber - b.blockNumber))
-    return allLogs
-  }
-
-  return (chain: Chain, rpcs: readonly HttpRpc[]) => {
-    for (const {
-      url,
-      isArchive,
-      getLogsIsUsable,
-      getLogsMaxBlockRange,
-    } of rpcs) {
-      if (!mut_endpoints.includes(url)) {
-        mut_endpoints.push(url)
-        endpointChainIds.set(url, chain.id)
-        endpointIsArchives.set(url, isArchive)
-        endpointGetLogsIsUsables.set(url, getLogsIsUsable)
-        endpointGetLogsMaxBlockRanges.set(url, getLogsMaxBlockRange)
-      }
-    }
-
-    return {
-      call: <T>(
-        caller: (client: PublicClient) => Promise<T>,
-        timeout: number,
-        rpcCondition?: RpcCondition,
-      ) => call(chain, caller, timeout, rpcCondition),
-      getLogs: async <T extends AbiEvent>(
-        parameters: {
-          readonly address: LowerHex
-          readonly event: T
-          readonly fromBlock: bigint
-          readonly toBlock: bigint
-        },
-        timeout: number,
-      ): Promise<GetLogsReturnType<T>> => getLogs(chain, parameters, timeout),
-    }
-  }
-})()

package/clients/externals/viem/estimateFeesPerGas.ts

@@ -1,24 +0,0 @@
-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[]
-  readonly type?: 'legacy' | 'eip1559'
-}
-
-export const estimateFeesPerGas = async (
-  { chain, httpRpcs, type = 'eip1559' }: EstimateFeesPerGasParameters,
-  config?: {
-    readonly timeout?: number
-    readonly logger?: Logger
-  },
-): Promise<FeeValues> =>
-  createViemClient(chain, httpRpcs).wrapper(
-    async (client) => await client.estimateFeesPerGas({ chain, type }),
-    undefined,
-    config?.timeout,
-    config?.logger,
-  )

package/clients/externals/viem/getBalance.ts

@@ -1,25 +0,0 @@
-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/clients/externals/viem/getBlock.ts

@@ -1,29 +0,0 @@
-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/clients/externals/viem/getBlockNumber.ts

@@ -1,23 +0,0 @@
-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/clients/externals/viem/getEventLogs.ts

@@ -1,40 +0,0 @@
-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/clients/externals/viem/getTransaction.ts

@@ -1,25 +0,0 @@
-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/clients/externals/viem/getTransactionCount.ts

@@ -1,25 +0,0 @@
-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/clients/externals/viem/getTransactionReceipt.ts

@@ -1,25 +0,0 @@
-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/clients/externals/viem/index.ts

@@ -1,11 +0,0 @@
-export { createViemInstance } from './createViemInstance'
-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'