viem 2.8.18 → 2.9.0

package/chains/opStack/actions/getTimeToNextGame.ts

@@ -0,0 +1,143 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import { type GetGamesErrorType, getGames } from './getGames.js'
+
+export type GetTimeToNextGameParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+  GetContractAddressParameter<
+    _derivedChain,
+    'portal' | 'disputeGameFactory'
+  > & {
+    /**
+     * The buffer to account for discrepencies between non-deterministic time intervals.
+     * @default 1.1
+     */
+    intervalBuffer?: number | undefined
+    /**
+     * The minimum L2 block number of the next game.
+     */
+    l2BlockNumber: bigint
+  }
+export type GetTimeToNextGameReturnType = {
+  /** The estimated interval (in seconds) between L2 dispute games. */
+  interval: number
+  /**
+   * Estimated seconds until the next L2 dispute game.
+   * `0` if the next L2 dispute game has already been submitted.
+   */
+  seconds: number
+  /**
+   * Estimated timestamp of the next L2 dispute game.
+   * `undefined` if the next L2 dispute game has already been submitted.
+   */
+  timestamp?: number | undefined
+}
+export type GetTimeToNextGameErrorType = GetGamesErrorType | ErrorType
+
+/**
+ * Returns the time until the next L2 dispute game (after the provided block number) is submitted.
+ * Used for the [Withdrawal](/op-stack/guides/withdrawals) flow.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/getTimeToNextGame
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetTimeToNextGameParameters}
+ * @returns The L2 transaction hash. {@link GetTimeToNextGameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { getBlockNumber } from 'viem/actions'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { getTimeToNextGame } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const { seconds } = await getTimeToNextGame(publicClientL1, {
+ *   l2BlockNumber: 113405763n,
+ *   targetChain: optimism
+ * })
+ */
+export async function getTimeToNextGame<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: GetTimeToNextGameParameters<chain, chainOverride>,
+): Promise<GetTimeToNextGameReturnType> {
+  const { intervalBuffer = 1.1, l2BlockNumber } = parameters
+
+  const games = await getGames(client, {
+    ...parameters,
+    l2BlockNumber: undefined,
+    limit: 10,
+  })
+
+  const deltas = games
+    .map(({ l2BlockNumber, timestamp }, index) => {
+      return index === games.length - 1
+        ? null
+        : [
+            games[index + 1].timestamp - timestamp,
+            games[index + 1].l2BlockNumber - l2BlockNumber,
+          ]
+    })
+    .filter(Boolean)
+  const interval = Math.ceil(
+    (deltas as [bigint, bigint][]).reduce(
+      (a, [b]) => Number(a) - Number(b),
+      0,
+    ) / deltas.length,
+  )
+  const blockInterval = Math.ceil(
+    (deltas as [bigint, bigint][]).reduce(
+      (a, [_, b]) => Number(a) - Number(b),
+      0,
+    ) / deltas.length,
+  )
+
+  const latestGame = games[0]
+  const latestGameTimestamp = Number(latestGame.timestamp) * 1000
+
+  const intervalWithBuffer = Math.ceil(interval * intervalBuffer)
+
+  const now = Date.now()
+
+  const seconds = (() => {
+    // If the current timestamp is lesser than the latest dispute game timestamp,
+    // then we assume that the dispute game has already been submitted.
+    if (now < latestGameTimestamp) return 0
+
+    // If the latest dispute game block is newer than the provided dispute game block number,
+    // then we assume that the dispute game has already been submitted.
+    if (latestGame.l2BlockNumber > l2BlockNumber) return 0
+
+    const elapsedBlocks = Number(l2BlockNumber - latestGame.l2BlockNumber)
+
+    const elapsed = Math.ceil((now - latestGameTimestamp) / 1000)
+    const secondsToNextOutput =
+      intervalWithBuffer - (elapsed % intervalWithBuffer)
+    return elapsedBlocks < blockInterval
+      ? secondsToNextOutput
+      : Math.floor(elapsedBlocks / Number(blockInterval)) * intervalWithBuffer +
+          secondsToNextOutput
+  })()
+
+  const timestamp = seconds > 0 ? now + seconds * 1000 : undefined
+
+  return { interval, seconds, timestamp }
+}

package/chains/opStack/actions/getTimeToProve.ts

@@ -8,7 +8,19 @@ import type {
   GetChainParameter,
 } from '../../../types/chain.js'
 import type { TransactionReceipt } from '../../../types/transaction.js'
+import type { OneOf } from '../../../types/utils.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
+import {
+  type GetPortalVersionErrorType,
+  type GetPortalVersionParameters,
+  getPortalVersion,
+} from './getPortalVersion.js'
+import {
+  type GetTimeToNextGameErrorType,
+  type GetTimeToNextGameParameters,
+  type GetTimeToNextGameReturnType,
+  getTimeToNextGame,
+} from './getTimeToNextGame.js'
 import {
   type GetTimeToNextL2OutputErrorType,
   type GetTimeToNextL2OutputParameters,
@@ -21,7 +33,13 @@ export type GetTimeToProveParameters<
   chainOverride extends Chain | undefined = Chain | undefined,
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = GetChainParameter<chain, chainOverride> &
-  GetContractAddressParameter<_derivedChain, 'l2OutputOracle'> & {
+  OneOf<
+    | GetContractAddressParameter<_derivedChain, 'l2OutputOracle'>
+    | GetContractAddressParameter<
+        _derivedChain,
+        'disputeGameFactory' | 'portal'
+      >
+  > & {
     /**
      * The buffer to account for discrepencies between non-deterministic time intervals.
      * @default 1.1
@@ -31,8 +49,16 @@ export type GetTimeToProveParameters<
       | undefined
     receipt: TransactionReceipt
   }
-export type GetTimeToProveReturnType = GetTimeToNextL2OutputReturnType
-export type GetTimeToProveErrorType = GetTimeToNextL2OutputErrorType | ErrorType
+
+export type GetTimeToProveReturnType =
+  | GetTimeToNextGameReturnType
+  | GetTimeToNextL2OutputReturnType
+
+export type GetTimeToProveErrorType =
+  | GetPortalVersionErrorType
+  | GetTimeToNextGameErrorType
+  | GetTimeToNextL2OutputErrorType
+  | ErrorType
 
 /**
  * Returns the time until the withdrawal transaction is ready to prove. Used for the [Withdrawal](/op-stack/guides/withdrawals) flow.
@@ -74,8 +100,20 @@ export async function getTimeToProve<
 ): Promise<GetTimeToProveReturnType> {
   const { receipt } = parameters
 
-  return getTimeToNextL2Output(client, {
+  const portalVersion = await getPortalVersion(
+    client,
+    parameters as GetPortalVersionParameters,
+  )
+
+  // Legacy
+  if (portalVersion.major < 3)
+    return getTimeToNextL2Output(client, {
+      ...parameters,
+      l2BlockNumber: receipt.blockNumber,
+    } as GetTimeToNextL2OutputParameters)
+
+  return getTimeToNextGame(client, {
     ...parameters,
     l2BlockNumber: receipt.blockNumber,
-  })
+  } as GetTimeToNextGameParameters)
 }

package/chains/opStack/actions/getWithdrawalStatus.ts

@@ -13,16 +13,32 @@ import type {
   GetChainParameter,
 } from '../../../types/chain.js'
 import type { TransactionReceipt } from '../../../types/transaction.js'
-import { portalAbi } from '../abis.js'
+import type { OneOf } from '../../../types/utils.js'
+import { portal2Abi, portalAbi } from '../abis.js'
 import { ReceiptContainsNoWithdrawalsError } from '../errors/withdrawal.js'
+import type { TargetChain } from '../types/chain.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
 import {
   type GetWithdrawalsErrorType,
   getWithdrawals,
 } from '../utils/getWithdrawals.js'
-import { type GetL2OutputErrorType, getL2Output } from './getL2Output.js'
+import {
+  type GetGameErrorType,
+  type GetGameParameters,
+  getGame,
+} from './getGame.js'
+import {
+  type GetL2OutputErrorType,
+  type GetL2OutputParameters,
+  getL2Output,
+} from './getL2Output.js'
+import {
+  type GetPortalVersionParameters,
+  getPortalVersion,
+} from './getPortalVersion.js'
 import {
   type GetTimeToFinalizeErrorType,
+  type GetTimeToFinalizeParameters,
   getTimeToFinalize,
 } from './getTimeToFinalize.js'
 
@@ -31,7 +47,18 @@ export type GetWithdrawalStatusParameters<
   chainOverride extends Chain | undefined = Chain | undefined,
   _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = GetChainParameter<chain, chainOverride> &
-  GetContractAddressParameter<_derivedChain, 'l2OutputOracle' | 'portal'> & {
+  OneOf<
+    | GetContractAddressParameter<_derivedChain, 'l2OutputOracle' | 'portal'>
+    | GetContractAddressParameter<
+        _derivedChain,
+        'disputeGameFactory' | 'portal'
+      >
+  > & {
+    /**
+     * Limit of games to extract to check withdrawal status.
+     * @default 100
+     */
+    gameLimit?: number
     receipt: TransactionReceipt
   }
 export type GetWithdrawalStatusReturnType =
@@ -85,12 +112,19 @@ export async function getWithdrawalStatus<
   client: Client<Transport, chain, account>,
   parameters: GetWithdrawalStatusParameters<chain, chainOverride>,
 ): Promise<GetWithdrawalStatusReturnType> {
-  const { chain = client.chain, receipt, targetChain } = parameters
+  const {
+    chain = client.chain,
+    gameLimit = 100,
+    receipt,
+    targetChain: targetChain_,
+  } = parameters
+
+  const targetChain = targetChain_ as unknown as TargetChain
 
   const portalAddress = (() => {
     if (parameters.portalAddress) return parameters.portalAddress
-    if (chain) return targetChain!.contracts.portal[chain.id].address
-    return Object.values(targetChain!.contracts.portal)[0].address
+    if (chain) return targetChain.contracts.portal[chain.id].address
+    return Object.values(targetChain.contracts.portal)[0].address
   })()
 
   const [withdrawal] = getWithdrawals(receipt)
@@ -100,53 +134,111 @@ export async function getWithdrawalStatus<
       hash: receipt.transactionHash,
     })
 
-  const [outputResult, proveResult, finalizedResult, timeToFinalizeResult] =
+  const portalVersion = await getPortalVersion(
+    client,
+    parameters as GetPortalVersionParameters,
+  )
+
+  // Legacy (Portal < v3)
+  if (portalVersion.major < 3) {
+    const [outputResult, proveResult, finalizedResult, timeToFinalizeResult] =
+      await Promise.allSettled([
+        getL2Output(client, {
+          ...parameters,
+          l2BlockNumber: receipt.blockNumber,
+        } as GetL2OutputParameters),
+        readContract(client, {
+          abi: portalAbi,
+          address: portalAddress,
+          functionName: 'provenWithdrawals',
+          args: [withdrawal.withdrawalHash],
+        }),
+        readContract(client, {
+          abi: portalAbi,
+          address: portalAddress,
+          functionName: 'finalizedWithdrawals',
+          args: [withdrawal.withdrawalHash],
+        }),
+        getTimeToFinalize(client, {
+          ...parameters,
+          withdrawalHash: withdrawal.withdrawalHash,
+        } as GetTimeToFinalizeParameters),
+      ])
+
+    // If the L2 Output is not processed yet (ie. the actions throws), this means
+    // that the withdrawal is not ready to prove.
+    if (outputResult.status === 'rejected') {
+      const error = outputResult.reason as GetL2OutputErrorType
+      if (
+        error.cause instanceof ContractFunctionRevertedError &&
+        error.cause.data?.args?.[0] ===
+          'L2OutputOracle: cannot get output for a block that has not been proposed'
+      )
+        return 'waiting-to-prove'
+      throw error
+    }
+    if (proveResult.status === 'rejected') throw proveResult.reason
+    if (finalizedResult.status === 'rejected') throw finalizedResult.reason
+    if (timeToFinalizeResult.status === 'rejected')
+      throw timeToFinalizeResult.reason
+
+    const [_, proveTimestamp] = proveResult.value
+    if (!proveTimestamp) return 'ready-to-prove'
+
+    const finalized = finalizedResult.value
+    if (finalized) return 'finalized'
+
+    const { seconds } = timeToFinalizeResult.value
+    return seconds > 0 ? 'waiting-to-finalize' : 'ready-to-finalize'
+  }
+
+  const [disputeGameResult, checkWithdrawalResult, finalizedResult] =
     await Promise.allSettled([
-      getL2Output(client, {
+      getGame(client, {
         ...parameters,
         l2BlockNumber: receipt.blockNumber,
-      }),
+        limit: gameLimit,
+      } as GetGameParameters),
       readContract(client, {
-        abi: portalAbi,
+        abi: portal2Abi,
         address: portalAddress,
-        functionName: 'provenWithdrawals',
+        functionName: 'checkWithdrawal',
         args: [withdrawal.withdrawalHash],
       }),
       readContract(client, {
-        abi: portalAbi,
+        abi: portal2Abi,
         address: portalAddress,
         functionName: 'finalizedWithdrawals',
         args: [withdrawal.withdrawalHash],
       }),
-      getTimeToFinalize(client, {
-        ...parameters,
-        withdrawalHash: withdrawal.withdrawalHash,
-      }),
     ])
 
-  // If the L2 Output is not processed yet (ie. the actions throws), this means
-  // that the withdrawal is not ready to prove.
-  if (outputResult.status === 'rejected') {
-    const error = outputResult.reason as GetL2OutputErrorType
-    if (
-      error.cause instanceof ContractFunctionRevertedError &&
-      error.cause.data?.args?.[0] ===
-        'L2OutputOracle: cannot get output for a block that has not been proposed'
-    )
-      return 'waiting-to-prove'
-    throw error
+  if (finalizedResult.status === 'fulfilled' && finalizedResult.value)
+    return 'finalized'
+
+  if (disputeGameResult.status === 'rejected') {
+    const error = disputeGameResult.reason as GetGameErrorType
+    if (error.name === 'GameNotFoundError') return 'waiting-to-prove'
+    throw disputeGameResult.reason
+  }
+  if (checkWithdrawalResult.status === 'rejected') {
+    const error = checkWithdrawalResult.reason as ReadContractErrorType
+    if (error.cause instanceof ContractFunctionRevertedError) {
+      const errorMessage = error.cause.data?.args?.[0]
+      if (errorMessage === 'OptimismPortal: withdrawal has not been proven yet')
+        return 'ready-to-prove'
+      if (
+        errorMessage ===
+          'OptimismPortal: proven withdrawal has not matured yet' ||
+        errorMessage ===
+          'OptimismPortal: output proposal has not been finalized yet' ||
+        errorMessage === 'OptimismPortal: output proposal in air-gap'
+      )
+        return 'waiting-to-finalize'
+    }
+    throw checkWithdrawalResult.reason
   }
-  if (proveResult.status === 'rejected') throw proveResult.reason
   if (finalizedResult.status === 'rejected') throw finalizedResult.reason
-  if (timeToFinalizeResult.status === 'rejected')
-    throw timeToFinalizeResult.reason
-
-  const [_, proveTimestamp] = proveResult.value
-  if (!proveTimestamp) return 'ready-to-prove'
-
-  const finalized = finalizedResult.value
-  if (finalized) return 'finalized'
 
-  const { seconds } = timeToFinalizeResult.value
-  return seconds > 0 ? 'waiting-to-finalize' : 'ready-to-finalize'
+  return 'ready-to-finalize'
 }

package/chains/opStack/actions/proveWithdrawal.ts

@@ -33,9 +33,11 @@ export type ProveWithdrawalParameters<
   UnionOmit<
     FormattedTransactionRequest<_derivedChain>,
     | 'accessList'
+    | 'blobs'
     | 'data'
     | 'from'
     | 'gas'
+    | 'maxFeePerBlobGas'
     | 'gasPrice'
     | 'to'
     | 'type'
@@ -130,7 +132,7 @@ export async function proveWithdrawal<
   })()
 
   const gas_ =
-    typeof gas !== 'number' && gas !== null
+    typeof gas !== 'bigint' && gas !== null
       ? await estimateProveWithdrawalGas(
           client,
           parameters as EstimateProveWithdrawalGasParameters,

package/chains/opStack/actions/waitForNextGame.ts

@@ -0,0 +1,122 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Account } from '../../../types/account.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import { poll } from '../../../utils/poll.js'
+import { GameNotFoundError } from '../errors/withdrawal.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import {
+  type GetGameErrorType,
+  type GetGameReturnType,
+  getGame,
+} from './getGame.js'
+import {
+  type GetTimeToNextGameErrorType,
+  type GetTimeToNextGameParameters,
+  getTimeToNextGame,
+} from './getTimeToNextGame.js'
+
+export type WaitForNextGameParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  chainOverride extends Chain | undefined = Chain | undefined,
+  _derivedChain extends Chain | undefined = DeriveChain<chain, chainOverride>,
+> = GetChainParameter<chain, chainOverride> &
+  GetContractAddressParameter<
+    _derivedChain,
+    'portal' | 'disputeGameFactory'
+  > & {
+    /**
+     * Limit of games to extract.
+     * @default 100
+     */
+    limit?: number | undefined
+    /**
+     * The buffer to account for discrepencies between non-deterministic time intervals.
+     * @default 1.1
+     */
+    intervalBuffer?: GetTimeToNextGameParameters['intervalBuffer'] | undefined
+    l2BlockNumber: bigint
+    /**
+     * Polling frequency (in ms). Defaults to Client's pollingInterval config.
+     * @default client.pollingInterval
+     */
+    pollingInterval?: number | undefined
+  }
+export type WaitForNextGameReturnType = GetGameReturnType
+export type WaitForNextGameErrorType =
+  | GetGameErrorType
+  | GetTimeToNextGameErrorType
+  | ErrorType
+
+/**
+ * Waits for the next dispute game (after the provided block number) to be submitted.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/waitForNextGame
+ *
+ * @param client - Client to use
+ * @param parameters - {@link WaitForNextGameParameters}
+ * @returns The L2 transaction hash. {@link WaitForNextGameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { getBlockNumber } from 'viem/actions'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { waitForNextGame } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const publicClientL2 = createPublicClient({
+ *   chain: optimism,
+ *   transport: http(),
+ * })
+ *
+ * const l2BlockNumber = await getBlockNumber(publicClientL2)
+ * await waitForNextGame(publicClientL1, {
+ *   l2BlockNumber,
+ *   targetChain: optimism
+ * })
+ */
+export async function waitForNextGame<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: WaitForNextGameParameters<chain, chainOverride>,
+): Promise<WaitForNextGameReturnType> {
+  const { pollingInterval = client.pollingInterval } = parameters
+
+  const { seconds } = await getTimeToNextGame(client, parameters)
+
+  return new Promise((resolve, reject) => {
+    poll(
+      async ({ unpoll }) => {
+        try {
+          const game = await getGame(client, {
+            ...parameters,
+            strategy: 'random',
+          })
+          unpoll()
+          resolve(game)
+        } catch (e) {
+          const error = e as GetGameErrorType
+          if (!(error instanceof GameNotFoundError)) {
+            unpoll()
+            reject(e)
+          }
+        }
+      },
+      {
+        interval: pollingInterval,
+        initialWaitTime: async () => seconds * 1000,
+      },
+    )
+  })
+}

package/chains/opStack/actions/waitForNextL2Output.ts

@@ -12,6 +12,7 @@ import { poll } from '../../../utils/poll.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
 import {
   type GetL2OutputErrorType,
+  type GetL2OutputParameters,
   type GetL2OutputReturnType,
   getL2Output,
 } from './getL2Output.js'
@@ -93,7 +94,10 @@ export async function waitForNextL2Output<
     poll(
       async ({ unpoll }) => {
         try {
-          const output = await getL2Output(client, parameters)
+          const output = await getL2Output(
+            client,
+            parameters as GetL2OutputParameters,
+          )
           unpoll()
           resolve(output)
         } catch (e) {