viem 2.8.18 → 2.9.1

package/chains/opStack/actions/buildProveWithdrawal.ts

@@ -21,7 +21,7 @@ import type {
   GetChainParameter,
 } from '../../../types/chain.js'
 import { type Hex } from '../../../types/misc.js'
-import type { Prettify } from '../../../types/utils.js'
+import type { OneOf, Prettify } from '../../../types/utils.js'
 import { fromRlp } from '../../../utils/encoding/fromRlp.js'
 import { toRlp } from '../../../utils/encoding/toRlp.js'
 import { keccak256 } from '../../../utils/hash/keccak256.js'
@@ -31,6 +31,7 @@ import {
   type GetWithdrawalHashStorageSlotErrorType,
   getWithdrawalHashStorageSlot,
 } from '../utils/getWithdrawalHashStorageSlot.js'
+import { type GetGameReturnType } from './getGame.js'
 import type { GetL2OutputReturnType } from './getL2Output.js'
 import type { ProveWithdrawalParameters } from './proveWithdrawal.js'
 
@@ -49,8 +50,7 @@ export type BuildProveWithdrawalParameters<
 > = GetAccountParameter<account, accountOverride, false> &
   GetChainParameter<chain, chainOverride> & {
     withdrawal: Withdrawal
-    output: GetL2OutputReturnType
-  }
+  } & OneOf<{ output: GetL2OutputReturnType } | { game: GetGameReturnType }>
 
 export type BuildProveWithdrawalReturnType<
   chain extends Chain | undefined = Chain | undefined,
@@ -116,9 +116,10 @@ export async function buildProveWithdrawal<
 ): Promise<
   BuildProveWithdrawalReturnType<chain, account, chainOverride, accountOverride>
 > {
-  const { account, chain = client.chain, output, withdrawal } = args
+  const { account, chain = client.chain, game, output, withdrawal } = args
+
   const { withdrawalHash } = withdrawal
-  const { l2BlockNumber } = output
+  const { l2BlockNumber } = game ?? output
 
   const slot = getWithdrawalHashStorageSlot({ withdrawalHash })
   const [proof, block] = await Promise.all([
@@ -134,7 +135,7 @@ export async function buildProveWithdrawal<
 
   return {
     account,
-    l2OutputIndex: output.outputIndex,
+    l2OutputIndex: game?.index ?? output?.outputIndex,
     outputRootProof: {
       latestBlockhash: block.hash,
       messagePasserStorageRoot: proof.storageHash,

package/chains/opStack/actions/getGame.ts

@@ -0,0 +1,99 @@
+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 {
+  GameNotFoundError,
+  type GameNotFoundErrorType,
+} from '../errors/withdrawal.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import type { Game } from '../types/withdrawal.js'
+import { type GetGamesErrorType, getGames } from './getGames.js'
+
+export type GetGameParameters<
+  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 minimum block number of the dispute game.
+     */
+    l2BlockNumber: bigint
+    /**
+     * Limit of games to extract.
+     * @default 100
+     */
+    limit?: number | undefined
+    /**
+     * Strategy for extracting a dispute game.
+     *
+     * - `latest` - Returns the latest dispute game.
+     * - `random` - Returns a random dispute game.
+     */
+    strategy?: 'latest' | 'random'
+  }
+export type GetGameReturnType = Game & {
+  l2BlockNumber: bigint
+}
+
+export type GetGameErrorType =
+  | GetGamesErrorType
+  | GameNotFoundErrorType
+  | ErrorType
+
+/**
+ * Retrieves a valid dispute game on an L2 that occurred after a provided L2 block number.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/getGame
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetGameParameters}
+ * @returns A valid dispute game. {@link GetGameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { getGame } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const game = await getGame(publicClientL1, {
+ *   l2BlockNumber: 69420n,
+ *   targetChain: optimism
+ * })
+ */
+export async function getGame<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: GetGameParameters<chain, chainOverride>,
+): Promise<GetGameReturnType> {
+  const { l2BlockNumber, strategy = 'latest' } = parameters
+
+  const latestGames = await getGames(client, parameters)
+
+  const games = latestGames.filter((game) => game.l2BlockNumber > l2BlockNumber)
+
+  const game = (() => {
+    if (strategy === 'random')
+      return games[Math.floor(Math.random() * games.length)]
+    return games[0]
+  })()
+
+  if (!game) throw new GameNotFoundError()
+  return game
+}

package/chains/opStack/actions/getGames.ts

@@ -0,0 +1,133 @@
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../../actions/public/readContract.js'
+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 { decodeAbiParameters } from '../../../utils/abi/decodeAbiParameters.js'
+import { disputeGameFactoryAbi, portal2Abi } from '../abis.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+import type { Game } from '../types/withdrawal.js'
+
+export type GetGamesParameters<
+  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'
+  > & {
+    /**
+     * Filter by minimum block number of the dispute games.
+     */
+    l2BlockNumber?: bigint | undefined
+    /**
+     * Limit of games to extract.
+     * @default 100
+     */
+    limit?: number | undefined
+  }
+export type GetGamesReturnType = (Game & {
+  l2BlockNumber: bigint
+})[]
+export type GetGamesErrorType = ReadContractErrorType | ErrorType
+
+/**
+ * Retrieves dispute games for an L2.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/getGame
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetGameParameters}
+ * @returns Dispute games. {@link GetGameReturnType}
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet, optimism } from 'viem/chains'
+ * import { getGames } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const games = await getGames(publicClientL1, {
+ *   targetChain: optimism
+ * })
+ */
+export async function getGames<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: GetGamesParameters<chain, chainOverride>,
+): Promise<GetGamesReturnType> {
+  const {
+    chain = client.chain,
+    l2BlockNumber,
+    limit = 100,
+    targetChain,
+  } = parameters
+
+  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
+  })()
+
+  const disputeGameFactoryAddress = (() => {
+    if (parameters.disputeGameFactoryAddress)
+      return parameters.disputeGameFactoryAddress
+    if (chain)
+      return targetChain!.contracts.disputeGameFactory[chain.id].address
+    return Object.values(targetChain!.contracts.disputeGameFactory)[0].address
+  })()
+
+  const [gameCount, gameType] = await Promise.all([
+    readContract(client, {
+      abi: disputeGameFactoryAbi,
+      functionName: 'gameCount',
+      args: [],
+      address: disputeGameFactoryAddress,
+    }),
+    readContract(client, {
+      abi: portal2Abi,
+      functionName: 'respectedGameType',
+      address: portalAddress,
+    }),
+  ])
+
+  const games = (
+    (await readContract(client, {
+      abi: disputeGameFactoryAbi,
+      functionName: 'findLatestGames',
+      address: disputeGameFactoryAddress,
+      args: [
+        gameType,
+        BigInt(Math.max(0, Number(gameCount - 1n))),
+        BigInt(Math.min(limit, Number(gameCount))),
+      ],
+    })) as Game[]
+  )
+    .map((game) => {
+      const [blockNumber] = decodeAbiParameters(
+        [{ type: 'uint256' }],
+        game.extraData,
+      )
+      return !l2BlockNumber || blockNumber > l2BlockNumber
+        ? { ...game, l2BlockNumber: blockNumber }
+        : null
+    })
+    .filter(Boolean) as GetGamesReturnType
+
+  return games
+}

package/chains/opStack/actions/getL2Output.ts

@@ -12,15 +12,34 @@ import type {
   GetChainParameter,
 } from '../../../types/chain.js'
 import type { Hex } from '../../../types/misc.js'
+import type { OneOf } from '../../../types/utils.js'
 import { l2OutputOracleAbi } from '../abis.js'
+import type { TargetChain } from '../types/chain.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
+import { type GetGameParameters, getGame } from './getGame.js'
+import {
+  type GetPortalVersionParameters,
+  getPortalVersion,
+} from './getPortalVersion.js'
 
 export type GetL2OutputParameters<
   chain extends Chain | undefined = Chain | undefined,
   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,
+        'portal' | 'disputeGameFactory'
+      > & {
+        /**
+         * Limit of games to extract.
+         * @default 100
+         */
+        limit?: number | undefined
+      })
+  > & {
     l2BlockNumber: bigint
   }
 export type GetL2OutputReturnType = {
@@ -65,11 +84,33 @@ export async function getL2Output<
 ): Promise<GetL2OutputReturnType> {
   const { chain = client.chain, l2BlockNumber, targetChain } = parameters
 
+  const version = await getPortalVersion(
+    client,
+    parameters as GetPortalVersionParameters,
+  )
+
+  if (version.major >= 3) {
+    const game = await getGame(client, parameters as GetGameParameters)
+    return {
+      l2BlockNumber: game.l2BlockNumber,
+      outputIndex: game.index,
+      outputRoot: game.rootClaim,
+      timestamp: game.timestamp,
+    }
+  }
+
   const l2OutputOracleAddress = (() => {
     if (parameters.l2OutputOracleAddress)
       return parameters.l2OutputOracleAddress
-    if (chain) return targetChain!.contracts.l2OutputOracle[chain.id].address
-    return Object.values(targetChain!.contracts.l2OutputOracle)[0].address
+    if (chain)
+      return (targetChain as unknown as TargetChain)!.contracts.l2OutputOracle[
+        chain.id
+      ].address
+    return (
+      Object.values(
+        (targetChain as unknown as TargetChain)!.contracts.l2OutputOracle,
+      ) as any
+    )[0].address
   })()
 
   const outputIndex = await readContract(client, {

package/chains/opStack/actions/getPortalVersion.ts

@@ -0,0 +1,87 @@
+import {
+  type ReadContractErrorType,
+  readContract,
+} from '../../../actions/public/readContract.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type {
+  Chain,
+  DeriveChain,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import { withCache } from '../../../utils/promise/withCache.js'
+import { portal2Abi } from '../abis.js'
+import type { GetContractAddressParameter } from '../types/contract.js'
+
+export type GetPortalVersionParameters<
+  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'>
+
+export type GetPortalVersionReturnType = {
+  major: number
+  minor: number
+  patch: number
+}
+
+export type GetPortalVersionErrorType = ReadContractErrorType | ErrorType
+
+/**
+ * Retrieves the current version of the Portal contract.
+ *
+ * - Docs: https://viem.sh/op-stack/actions/getPortalVersion
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetPortalVersionParameters}
+ * @returns The version object.
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { getPortalVersion } from 'viem/op-stack'
+ *
+ * const publicClientL1 = createPublicClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const version = await getPortalVersion(publicClientL1, {
+ *   targetChain: optimism,
+ * })
+ *
+ * if (version.major > 3)
+ *   console.log('Fault proofs are enabled on this version of optimism')
+ * console.log('Fault proofs are not enabled on this version of optimism')
+ */
+export async function getPortalVersion<
+  chain extends Chain | undefined,
+  chainOverride extends Chain | undefined = undefined,
+>(
+  client: Client<Transport, chain>,
+  parameters: GetPortalVersionParameters<chain, chainOverride>,
+) {
+  const { chain = client.chain, targetChain } = parameters
+
+  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
+  })()
+
+  const version = await withCache(
+    () =>
+      readContract(client, {
+        abi: portal2Abi,
+        address: portalAddress,
+        functionName: 'version',
+      }),
+    { cacheKey: ['portalVersion', portalAddress].join('.'), cacheTime: 300 },
+  )
+
+  const [major, minor, patch] = version.split('.').map(Number)
+
+  return { major, minor, patch }
+}

package/chains/opStack/actions/getTimeToFinalize.ts

@@ -2,8 +2,10 @@ import {
   type MulticallErrorType,
   multicall,
 } from '../../../actions/public/multicall.js'
+import { readContract } from '../../../actions/public/readContract.js'
 import type { Client } from '../../../clients/createClient.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
+import { BaseError } from '../../../errors/base.js'
 import type { ErrorType } from '../../../errors/utils.js'
 import type { Account } from '../../../types/account.js'
 import type {
@@ -12,8 +14,9 @@ import type {
   GetChainParameter,
 } from '../../../types/chain.js'
 import type { Hash } from '../../../types/misc.js'
-import { l2OutputOracleAbi, portalAbi } from '../abis.js'
+import { l2OutputOracleAbi, portal2Abi, portalAbi } from '../abis.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
+import { getPortalVersion } from './getPortalVersion.js'
 
 export type GetTimeToFinalizeParameters<
   chain extends Chain | undefined = Chain | undefined,
@@ -80,43 +83,77 @@ export async function getTimeToFinalize<
 ): Promise<GetTimeToFinalizeReturnType> {
   const { chain = client.chain, withdrawalHash, targetChain } = parameters
 
-  const l2OutputOracleAddress = (() => {
-    if (parameters.l2OutputOracleAddress)
-      return parameters.l2OutputOracleAddress
-    if (chain) return targetChain!.contracts.l2OutputOracle[chain.id].address
-    return Object.values(targetChain!.contracts.l2OutputOracle)[0].address
-  })()
   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
   })()
 
-  const [[_outputRoot, proveTimestamp, _l2OutputIndex], period] =
-    await multicall(client, {
-      allowFailure: false,
-      contracts: [
-        {
-          abi: portalAbi,
-          address: portalAddress,
-          functionName: 'provenWithdrawals',
-          args: [withdrawalHash],
-        },
-        {
-          abi: l2OutputOracleAbi,
-          address: l2OutputOracleAddress,
-          functionName: 'FINALIZATION_PERIOD_SECONDS',
-        },
-      ],
-    })
+  const portalVersion = await getPortalVersion(client, { portalAddress })
+
+  // Legacy
+  if (portalVersion.major < 3) {
+    const l2OutputOracleAddress = (() => {
+      if (parameters.l2OutputOracleAddress)
+        return parameters.l2OutputOracleAddress
+      if (chain) return targetChain!.contracts.l2OutputOracle[chain.id].address
+      return Object.values(targetChain!.contracts.l2OutputOracle)[0].address
+    })()
+    const [[_outputRoot, proveTimestamp, _l2OutputIndex], period] =
+      await multicall(client, {
+        allowFailure: false,
+        contracts: [
+          {
+            abi: portalAbi,
+            address: portalAddress,
+            functionName: 'provenWithdrawals',
+            args: [withdrawalHash],
+          },
+          {
+            abi: l2OutputOracleAbi,
+            address: l2OutputOracleAddress,
+            functionName: 'FINALIZATION_PERIOD_SECONDS',
+          },
+        ],
+      })
+
+    const secondsSinceProven = Date.now() / 1000 - Number(proveTimestamp)
+    const secondsToFinalize = Number(period) - secondsSinceProven
+
+    const seconds = Math.floor(
+      secondsToFinalize < 0 ? 0 : secondsToFinalize + buffer,
+    )
+    const timestamp = Date.now() + seconds * 1000
+
+    return { period: Number(period), seconds, timestamp }
+  }
+
+  const [[_disputeGameProxy, proveTimestamp], proofMaturityDelaySeconds] =
+    await Promise.all([
+      readContract(client, {
+        abi: portal2Abi,
+        address: portalAddress,
+        functionName: 'provenWithdrawals',
+        args: [withdrawalHash],
+      }),
+      readContract(client, {
+        abi: portal2Abi,
+        address: portalAddress,
+        functionName: 'proofMaturityDelaySeconds',
+      }),
+    ])
+
+  if (proveTimestamp === 0n)
+    throw new BaseError('Withdrawal has not been proven on L1.')
 
   const secondsSinceProven = Date.now() / 1000 - Number(proveTimestamp)
-  const secondsToFinalize = Number(period) - secondsSinceProven
+  const secondsToFinalize =
+    Number(proofMaturityDelaySeconds) - secondsSinceProven
 
   const seconds = Math.floor(
-    secondsToFinalize < 0 ? 0 : secondsToFinalize + buffer,
+    secondsToFinalize < 0n ? 0 : secondsToFinalize + buffer,
   )
   const timestamp = Date.now() + seconds * 1000
 
-  return { period: Number(period), seconds, timestamp }
+  return { period: Number(proofMaturityDelaySeconds), seconds, timestamp }
 }