@0xtorch/evm 0.0.1

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

@@ -0,0 +1,437 @@
+import type { Logger } from '@0xtorch/core'
+import type { AbiEvent } from 'abitype'
+import type {
+  GetLogsReturnType,
+  MulticallParameters,
+  MulticallReturnType,
+  Chain as ViemChain,
+} from 'viem'
+import { CallExecutionError, createPublicClient, http } from 'viem'
+import type { HttpRpc } from '../../../chains'
+import type { LowerHex } from '../../../types'
+import { bigIntMin } from '../../../utils'
+
+type RpcStatus = {
+  readonly rpc: HttpRpc
+  readonly isAvailable: 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,
+            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,
+  },
+})
+
+const unlockRpc = (rpcs: ChainRpcs, url: string): ChainRpcs => ({
+  ...rpcs,
+  [url]: {
+    ...rpcs[url],
+    isAvailable: true,
+    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.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,
+      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
+  } else if (onlyGetLogsIsUsable) {
+    return availableRpcs.toSorted((a, b) =>
+      Number(b.rpc.getLogsMaxBlockRange - a.rpc.getLogsMaxBlockRange),
+    )[0].rpc
+  } else {
+    return 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: undefined) => void, reject) =>
+          setTimeout(() => reject(new Error('Timeout')), 10_000),
+        ),
+      ])
+      if (result === undefined) {
+        throw new Error('Timeout')
+      }
+      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 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')
+        ) {
+          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/src/clients/externals/viem/multicall.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'bun:test'
+import { mainnet } from 'viem/chains'
+import { erc20Abi } from '../../../abis'
+import { ethereumHttpRpcs } from '../../../chains'
+import { multicall } from './multicall'
+
+describe('multicall', () => {
+  it('should work', async () => {
+    const result = await multicall({
+      chain: mainnet,
+      httpRpcs: ethereumHttpRpcs,
+      parameters: {
+        contracts: [
+          {
+            address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+            abi: erc20Abi,
+            functionName: 'balanceOf',
+            args: ['0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'],
+          },
+        ],
+      },
+    })
+    expect(result[0].status).toBe('success')
+    expect(result[0].result).toBeDefined()
+  })
+})

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

@@ -0,0 +1,27 @@
+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/src/clients/externals/viem/readContract.test.ts

@@ -0,0 +1,20 @@
+import { describe, it } from 'bun:test'
+import { mainnet } from 'viem/chains'
+import { erc20Abi } from '../../../abis'
+import { ethereumHttpRpcs } from '../../../chains'
+import { readContract } from './readContract'
+
+describe('readContract', () => {
+  it('ERC20.balanceOf', async () => {
+    await readContract({
+      chain: mainnet,
+      httpRpcs: ethereumHttpRpcs,
+      parameters: {
+        address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+        abi: erc20Abi,
+        functionName: 'balanceOf',
+        args: ['0xf9b5e1202ac637bcfed4eed026086531c5847d00'],
+      },
+    })
+  })
+})

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

@@ -0,0 +1,38 @@
+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,
+  )