@0xtorch/evm 0.0.61 → 0.0.63

package/clients/externals/viem/middleware.ts

@@ -1,451 +0,0 @@
-import type { Logger } from '@0xtorch/core'
-import type { AbiEvent } from 'abitype'
-import type {
-  GetLogsReturnType,
-  MulticallParameters,
-  MulticallReturnType,
-  Chain as ViemChain,
-} from 'viem'
-import {
-  http,
-  CallExecutionError,
-  ContractFunctionExecutionError,
-  createPublicClient,
-} from 'viem'
-import type { HttpRpc } from '../../../chains'
-import type { LowerHex } from '../../../types'
-import { bigIntMin } from '../../../utils'
-
-type RpcStatus = {
-  readonly rpc: HttpRpc
-  readonly isAvailable: boolean
-  readonly isUsing: boolean
-  error:
-    | {
-        timestamp: number
-        unlockTimestamp: number
-        error: Error
-      }
-    | undefined
-}
-type MutableChainRpcs = {
-  [url: string]: RpcStatus
-}
-type ChainRpcs = Readonly<MutableChainRpcs>
-type Rpcs = {
-  [id: number]: ChainRpcs
-}
-
-const updateRpcs = (
-  currentRpcs: ChainRpcs,
-  httpRpcs: readonly HttpRpc[],
-): ChainRpcs => {
-  const mut_chainRpcs: MutableChainRpcs = {}
-  // httpRpcs の内、 currentRpcs に含まれるものは引き継ぐ
-  // currentRpcs に含まれないものは新規に追加
-  for (const rpc of httpRpcs) {
-    const { url } = rpc
-    mut_chainRpcs[url] =
-      currentRpcs[url] === undefined
-        ? {
-            rpc,
-            isAvailable: true,
-            isUsing: false,
-            error: undefined,
-          }
-        : currentRpcs[url]
-  }
-  return mut_chainRpcs
-}
-
-type RpcCondition = {
-  readonly onlyArchive?: boolean
-  readonly onlyGetLogsIsUsable?: boolean
-}
-
-const selectHttpRpc = async (
-  mut_rpcs: Rpcs,
-  chainId: number,
-  { onlyArchive = false, onlyGetLogsIsUsable = false }: RpcCondition,
-  timeout = 10_000,
-): Promise<HttpRpc> => {
-  // 利用可能な RPC を選択して返す
-  const defaultRpc = selectAvailableRpc(mut_rpcs[chainId], {
-    onlyArchive,
-    onlyGetLogsIsUsable,
-  })
-  if (defaultRpc !== undefined) {
-    mut_rpcs[chainId] = lockRpc(mut_rpcs[chainId], defaultRpc.url)
-    return defaultRpc
-  }
-
-  // 利用可能な RPC が空くまで待つ
-  const rpc = await new Promise((resolve: (value: HttpRpc) => void, reject) => {
-    const intervalId = setInterval(() => {
-      // unlockTimestamp が現在時刻前のrpcを利用可能にする
-      mut_rpcs[chainId] = unlockErrorRpcs(mut_rpcs[chainId])
-      // 利用可能な RPC を選択して返す
-      const availableRpc = selectAvailableRpc(mut_rpcs[chainId], {
-        onlyArchive,
-        onlyGetLogsIsUsable,
-      })
-      if (availableRpc !== undefined) {
-        mut_rpcs[chainId] = lockRpc(mut_rpcs[chainId], availableRpc.url)
-        clearInterval(intervalId)
-        clearTimeout(timeoutId)
-        resolve(availableRpc)
-      }
-    }, 100)
-    const timeoutId = setTimeout(() => {
-      clearInterval(intervalId)
-      reject(new Error('Timeout'))
-    }, timeout)
-  })
-
-  return rpc
-}
-
-const lockRpc = (rpcs: ChainRpcs, url: string): ChainRpcs => ({
-  ...rpcs,
-  [url]: {
-    ...rpcs[url],
-    isAvailable: false,
-    isUsing: true,
-  },
-})
-
-const unlockRpc = (rpcs: ChainRpcs, url: string): ChainRpcs => ({
-  ...rpcs,
-  [url]: {
-    ...rpcs[url],
-    isAvailable: true,
-    isUsing: false,
-    error: undefined,
-  },
-})
-
-const unlockErrorRpcs = (rpcs: ChainRpcs): ChainRpcs => {
-  const now = Date.now()
-  const mut_rpcs: MutableChainRpcs = {}
-  for (const [url, rpc] of Object.entries(rpcs)) {
-    mut_rpcs[url] =
-      !rpc.isAvailable &&
-      !rpc.isUsing &&
-      rpc.error !== undefined &&
-      rpc.error.unlockTimestamp < now
-        ? {
-            ...rpc,
-            isAvailable: true,
-          }
-        : rpc
-  }
-  return mut_rpcs
-}
-
-const saveRpcError = (
-  rpcs: ChainRpcs,
-  url: string,
-  error: Error,
-): ChainRpcs => {
-  const currentStatus = rpcs[url]
-  const now = Date.now()
-  return {
-    ...rpcs,
-    [url]: {
-      ...rpcs[url],
-      isAvailable: false,
-      isUsing: false,
-      error: {
-        timestamp: now,
-        unlockTimestamp:
-          currentStatus.error !== undefined &&
-          currentStatus.error.error.message === error.message
-            ? now +
-              (currentStatus.error.unlockTimestamp -
-                currentStatus.error.timestamp) *
-                2
-            : now + 60_000,
-        error,
-      },
-    },
-  }
-}
-
-const selectAvailableRpc = (
-  chainRpcs: ChainRpcs,
-  { onlyArchive = false, onlyGetLogsIsUsable = false },
-): HttpRpc | undefined => {
-  const availableRpcs = Object.values(chainRpcs).filter(
-    ({ isAvailable, rpc }) => {
-      if (!isAvailable) {
-        return false
-      }
-      if (onlyArchive && !rpc.isArchive) {
-        return false
-      }
-      if (onlyGetLogsIsUsable && !rpc.getLogsIsUsable) {
-        return false
-      }
-      return true
-    },
-  )
-  if (availableRpcs.length === 0) {
-    return undefined
-  }
-  return onlyGetLogsIsUsable
-    ? availableRpcs.toSorted((a, b) =>
-        Number(b.rpc.getLogsMaxBlockRange - a.rpc.getLogsMaxBlockRange),
-      )[0].rpc
-    : availableRpcs[0].rpc
-}
-
-type PublicClient = ReturnType<typeof createPublicClient>
-
-export const createViemClient = (() => {
-  const mut_rpcs: {
-    [id: number]: ChainRpcs
-  } = {}
-
-  const clientWrapper = async <
-    TReturnType,
-    TFunction extends (client: PublicClient) => Promise<TReturnType> = (
-      client: PublicClient,
-    ) => Promise<TReturnType>,
-  >(
-    chain: ViemChain,
-    function_: TFunction,
-    rpcCondition?: RpcCondition,
-    timeout = 10_000,
-    logger?: Logger,
-  ): Promise<TReturnType> => {
-    if (timeout <= 0) {
-      throw new Error('Timeout')
-    }
-    const startTime = Date.now()
-    const { url } = await selectHttpRpc(
-      mut_rpcs,
-      chain.id,
-      rpcCondition ?? {},
-      timeout,
-    )
-    const client = createPublicClient({
-      chain,
-      transport: http(url),
-    })
-    try {
-      if (logger !== undefined) {
-        logger.info(`[EVM Method Call] ${url}`)
-      }
-      const result = await Promise.race([
-        function_(client),
-        new Promise((_resolve: (value: Error) => void, reject) =>
-          setTimeout(() => reject(new Error('Timeout')), 10_000),
-        ),
-      ])
-      if (result instanceof Error) {
-        throw result
-      }
-      mut_rpcs[chain.id] = unlockRpc(mut_rpcs[chain.id], url)
-      return result
-    } catch (error) {
-      if (error instanceof ContractFunctionExecutionError) {
-        throw error
-      }
-      if (error instanceof Error) {
-        mut_rpcs[chain.id] = saveRpcError(mut_rpcs[chain.id], url, error)
-        if (logger !== undefined) {
-          logger.info(error)
-        }
-        const remainTime = timeout - (Date.now() - startTime)
-        return await clientWrapper(
-          chain,
-          function_,
-          rpcCondition,
-          remainTime,
-          logger,
-        )
-      }
-      throw error
-    }
-  }
-
-  const getLogs = async <TAbiEvent extends AbiEvent>(
-    chain: ViemChain,
-    {
-      address,
-      event,
-      fromBlock,
-      toBlock,
-    }: {
-      readonly address: LowerHex
-      readonly event: TAbiEvent
-      readonly fromBlock: bigint
-      readonly toBlock: bigint
-    },
-    timeout = 10_000,
-    logger?: Logger,
-  ): Promise<GetLogsReturnType<TAbiEvent>> => {
-    const startTime = Date.now()
-
-    const mut_logsList: GetLogsReturnType<TAbiEvent>[] = []
-
-    let mut_currentFromBlock = fromBlock
-    let mut_currentToBlock = 0n
-    while (mut_currentFromBlock <= toBlock) {
-      const reiaminTime = timeout - (Date.now() - startTime)
-      if (reiaminTime <= 0) {
-        throw new Error('Timeout')
-      }
-      const { url, getLogsMaxBlockRange } = await selectHttpRpc(
-        mut_rpcs,
-        chain.id,
-        { onlyGetLogsIsUsable: true },
-        timeout,
-      )
-      const client = createPublicClient({
-        chain,
-        transport: http(url),
-      })
-      mut_currentToBlock = bigIntMin(
-        mut_currentFromBlock + getLogsMaxBlockRange - 1n,
-        toBlock,
-      )
-      try {
-        if (logger !== undefined) {
-          logger.info(`[EVM Method Call] ${url}`)
-        }
-        const logs = await Promise.race([
-          client.getLogs({
-            address,
-            event,
-            fromBlock: mut_currentFromBlock,
-            toBlock: mut_currentToBlock,
-          }),
-          new Promise((_resolve: (value: undefined) => void, reject) =>
-            setTimeout(() => reject(new Error('Timeout')), 10_000),
-          ),
-        ])
-        if (logs === undefined) {
-          throw new Error('Timeout')
-        }
-        mut_rpcs[chain.id] = unlockRpc(mut_rpcs[chain.id], url)
-        mut_logsList.push(logs)
-        mut_currentFromBlock = mut_currentToBlock + 1n
-      } catch (error) {
-        if (error instanceof Error) {
-          mut_rpcs[chain.id] = saveRpcError(mut_rpcs[chain.id], url, error)
-          if (logger !== undefined) {
-            logger.info(error)
-          }
-        } else {
-          throw error
-        }
-      }
-    }
-
-    const allLogs = mut_logsList
-      .flat()
-      .toSorted((a, b) => Number(a.blockNumber - b.blockNumber))
-    return allLogs
-  }
-
-  const multicall = async <contracts extends readonly unknown[]>(
-    chain: ViemChain,
-    parameters: MulticallParameters<contracts>,
-    timeout = 10_000,
-    logger?: Logger,
-  ): Promise<MulticallReturnType<contracts>> => {
-    if (timeout <= 0) {
-      throw new Error('Timeout')
-    }
-
-    const startTime = Date.now()
-    const { url } = await selectHttpRpc(mut_rpcs, chain.id, {}, timeout)
-    const client = createPublicClient({
-      chain,
-      transport: http(url),
-    })
-    try {
-      if (logger !== undefined) {
-        logger.info(`[EVM: multicall] ${url}`)
-      }
-      const result = await Promise.race([
-        client.multicall(parameters),
-        new Promise((_resolve: (value: undefined) => void, reject) =>
-          setTimeout(() => reject(new Error('Timeout')), 10_000),
-        ),
-      ])
-      if (result === undefined) {
-        throw new Error('Timeout')
-      }
-
-      for (const item of result) {
-        if (item.status === 'success') {
-          continue
-        }
-        if (
-          item.error instanceof CallExecutionError ||
-          item.error.message.includes('Status: 429') ||
-          item.error.message.includes('Status: 404') ||
-          item.error.message.includes('HTTP request failed')
-        ) {
-          throw item.error
-        }
-      }
-
-      mut_rpcs[chain.id] = unlockRpc(mut_rpcs[chain.id], url)
-      return result
-    } catch (error) {
-      if (error instanceof Error) {
-        mut_rpcs[chain.id] = saveRpcError(mut_rpcs[chain.id], url, error)
-        if (logger !== undefined) {
-          logger.info(error)
-        }
-        const remainTime = timeout - (Date.now() - startTime)
-        return await multicall(chain, parameters, remainTime, logger)
-      }
-      throw error
-    }
-  }
-
-  return (chain: ViemChain, httpRpcs: readonly HttpRpc[]) => {
-    mut_rpcs[chain.id] = updateRpcs(mut_rpcs[chain.id] ?? {}, httpRpcs)
-
-    return {
-      getLogs: async <TAbiEvent extends AbiEvent>(
-        parameters: {
-          readonly address: LowerHex
-          readonly event: TAbiEvent
-          readonly fromBlock: bigint
-          readonly toBlock: bigint
-        },
-        timeout = 60_000,
-        logger?: Logger,
-      ): Promise<GetLogsReturnType<TAbiEvent>> =>
-        await getLogs(chain, parameters, timeout, logger),
-      multicall: async <contracts extends readonly unknown[]>(
-        parameters: MulticallParameters<contracts>,
-        timeout = 60_000,
-        logger?: Logger,
-      ) => multicall(chain, parameters, timeout, logger),
-      wrapper: async <
-        const TReturnType,
-        TFunction extends (client: PublicClient) => Promise<TReturnType> = (
-          client: PublicClient,
-        ) => Promise<TReturnType>,
-      >(
-        function_: TFunction,
-        rpcCondition?: RpcCondition,
-        timeout = 60_000,
-        logger?: Logger,
-      ) =>
-        clientWrapper<TReturnType, TFunction>(
-          chain,
-          function_,
-          rpcCondition,
-          timeout,
-          logger,
-        ),
-    }
-  }
-})()

package/clients/externals/viem/multicall.ts

@@ -1,27 +0,0 @@
-import type { Logger } from '@0xtorch/core'
-import type {
-  MulticallReturnType,
-  Chain as ViemChain,
-  MulticallParameters as ViemMulticallParameters,
-} from 'viem'
-import type { HttpRpc } from '../../../chains'
-import { createViemClient } from './middleware'
-
-type MulticallParameters<contracts extends readonly unknown[]> = {
-  readonly chain: ViemChain
-  readonly httpRpcs: readonly HttpRpc[]
-  readonly parameters: ViemMulticallParameters<contracts>
-}
-
-export const multicall = async <contracts extends readonly unknown[]>(
-  { chain, httpRpcs, parameters }: MulticallParameters<contracts>,
-  config?: {
-    readonly timeout?: number
-    readonly logger?: Logger
-  },
-): Promise<MulticallReturnType<contracts>> =>
-  createViemClient(chain, httpRpcs).multicall(
-    parameters,
-    config?.timeout,
-    config?.logger,
-  )

package/clients/externals/viem/readContract.ts

@@ -1,38 +0,0 @@
-import type { Logger } from '@0xtorch/core'
-import type {
-  Abi,
-  ContractFunctionName,
-  ReadContractReturnType,
-  Chain as ViemChain,
-  ReadContractParameters as ViemReadContractParameters,
-} from 'viem'
-import type { HttpRpc } from '../../../chains'
-import { createViemClient } from './middleware'
-
-type ReadContractParameters<
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>,
-> = {
-  readonly chain: ViemChain
-  readonly httpRpcs: readonly HttpRpc[]
-  readonly parameters: ViemReadContractParameters<TAbi, TFunctionName>
-}
-
-export const readContract = async <
-  TAbi extends Abi | readonly unknown[],
-  TFunctionName extends ContractFunctionName<TAbi, 'pure' | 'view'>,
->(
-  { chain, httpRpcs, parameters }: ReadContractParameters<TAbi, TFunctionName>,
-  config?: {
-    readonly timeout?: number
-    readonly logger?: Logger
-  },
-): Promise<ReadContractReturnType<TAbi, TFunctionName>> =>
-  createViemClient(chain, httpRpcs).wrapper<
-    ReadContractReturnType<TAbi, TFunctionName>
-  >(
-    async (client) => await client.readContract(parameters),
-    undefined,
-    config?.timeout,
-    config?.logger,
-  )