viem 2.8.18 → 2.9.1

package/chains/opStack/actions/waitToProve.ts

@@ -8,6 +8,7 @@ import type {
   GetChainParameter,
 } from '../../../types/chain.js'
 import type { TransactionReceipt } from '../../../types/transaction.js'
+import type { OneOf } from '../../../types/utils.js'
 import { ReceiptContainsNoWithdrawalsError } from '../errors/withdrawal.js'
 import type { GetContractAddressParameter } from '../types/contract.js'
 import type { Withdrawal } from '../types/withdrawal.js'
@@ -15,8 +16,18 @@ import {
   type GetWithdrawalsErrorType,
   getWithdrawals,
 } from '../utils/getWithdrawals.js'
+import {
+  type GetPortalVersionParameters,
+  getPortalVersion,
+} from './getPortalVersion.js'
+import {
+  type WaitForNextGameParameters,
+  type WaitForNextGameReturnType,
+  waitForNextGame,
+} from './waitForNextGame.js'
 import {
   type WaitForNextL2OutputErrorType,
+  type WaitForNextL2OutputParameters,
   type WaitForNextL2OutputReturnType,
   waitForNextL2Output,
 } from './waitForNextL2Output.js'
@@ -26,7 +37,18 @@ export type WaitToProveParameters<
   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'
+      >
+  > & {
+    /**
+     * Limit of games to extract.
+     * @default 100
+     */
+    gameLimit?: number | undefined
     receipt: TransactionReceipt
     /**
      * Polling frequency (in ms). Defaults to Client's pollingInterval config.
@@ -35,9 +57,11 @@ export type WaitToProveParameters<
     pollingInterval?: number | undefined
   }
 export type WaitToProveReturnType = {
-  withdrawal: Withdrawal
+  game: WaitForNextGameReturnType
   output: WaitForNextL2OutputReturnType
+  withdrawal: Withdrawal
 }
+
 export type WaitToProveErrorType =
   | GetWithdrawalsErrorType
   | WaitForNextL2OutputErrorType
@@ -81,7 +105,7 @@ export async function waitToProve<
   client: Client<Transport, chain, account>,
   parameters: WaitToProveParameters<chain, chainOverride>,
 ): Promise<WaitToProveReturnType> {
-  const { receipt } = parameters
+  const { gameLimit, receipt } = parameters
 
   const [withdrawal] = getWithdrawals(receipt)
 
@@ -90,10 +114,44 @@ export async function waitToProve<
       hash: receipt.transactionHash,
     })
 
-  const output = await waitForNextL2Output(client, {
+  const portalVersion = await getPortalVersion(
+    client,
+    parameters as GetPortalVersionParameters,
+  )
+
+  // Legacy (Portal < v3)
+  if (portalVersion.major < 3) {
+    const output = await waitForNextL2Output(client, {
+      ...parameters,
+      l2BlockNumber: receipt.blockNumber,
+    } as WaitForNextL2OutputParameters)
+    return {
+      game: {
+        extraData: '0x',
+        index: output.outputIndex,
+        l2BlockNumber: output.l2BlockNumber,
+        metadata: '0x',
+        rootClaim: output.outputRoot,
+        timestamp: output.timestamp,
+      },
+      output,
+      withdrawal,
+    }
+  }
+
+  const game = await waitForNextGame(client, {
     ...parameters,
+    limit: gameLimit,
     l2BlockNumber: receipt.blockNumber,
-  })
-
-  return { output, withdrawal }
+  } as WaitForNextGameParameters)
+  return {
+    game,
+    output: {
+      l2BlockNumber: game.l2BlockNumber,
+      outputIndex: game.index,
+      outputRoot: game.rootClaim,
+      timestamp: game.timestamp,
+    },
+    withdrawal,
+  }
 }

package/chains/opStack/decorators/publicL1.ts

@@ -23,16 +23,36 @@ import {
   type EstimateProveWithdrawalGasReturnType,
   estimateProveWithdrawalGas,
 } from '../actions/estimateProveWithdrawalGas.js'
+import {
+  type GetGameParameters,
+  type GetGameReturnType,
+  getGame,
+} from '../actions/getGame.js'
+import {
+  type GetGamesParameters,
+  type GetGamesReturnType,
+  getGames,
+} from '../actions/getGames.js'
 import {
   type GetL2OutputParameters,
   type GetL2OutputReturnType,
   getL2Output,
 } from '../actions/getL2Output.js'
+import {
+  type GetPortalVersionParameters,
+  type GetPortalVersionReturnType,
+  getPortalVersion,
+} from '../actions/getPortalVersion.js'
 import {
   type GetTimeToFinalizeParameters,
   type GetTimeToFinalizeReturnType,
   getTimeToFinalize,
 } from '../actions/getTimeToFinalize.js'
+import {
+  type GetTimeToNextGameParameters,
+  type GetTimeToNextGameReturnType,
+  getTimeToNextGame,
+} from '../actions/getTimeToNextGame.js'
 import {
   type GetTimeToNextL2OutputParameters,
   type GetTimeToNextL2OutputReturnType,
@@ -48,6 +68,11 @@ import {
   type GetWithdrawalStatusReturnType,
   getWithdrawalStatus,
 } from '../actions/getWithdrawalStatus.js'
+import {
+  type WaitForNextGameParameters,
+  type WaitForNextGameReturnType,
+  waitForNextGame,
+} from '../actions/waitForNextGame.js'
 import {
   type WaitForNextL2OutputParameters,
   type WaitForNextL2OutputReturnType,
@@ -213,6 +238,57 @@ export type PublicActionsL1<
       chainOverride
     >,
   ) => Promise<EstimateFinalizeWithdrawalGasReturnType>
+  /**
+   * 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'
+   *
+   * const publicClientL1 = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * const game = await publicClientL1.getGame({
+   *   l2BlockNumber: 69420n,
+   *   targetChain: optimism
+   * })
+   */
+  getGame: <chainOverride extends Chain | undefined = undefined>(
+    parameters: GetGameParameters<chain, chainOverride>,
+  ) => Promise<GetGameReturnType>
+  /**
+   * 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'
+   *
+   * const publicClientL1 = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * const games = await publicClientL1.getGames({
+   *   targetChain: optimism
+   * })
+   */
+  getGames: <chainOverride extends Chain | undefined = undefined>(
+    parameters: GetGamesParameters<chain, chainOverride>,
+  ) => Promise<GetGamesReturnType>
   /**
    * Retrieves the first L2 output proposal that occurred after a provided block number. Used for the [Withdrawal](/op-stack/guides/withdrawals) flow.
    *
@@ -240,6 +316,35 @@ export type PublicActionsL1<
   getL2Output: <chainOverride extends Chain | undefined = undefined>(
     parameters: GetL2OutputParameters<chain, chainOverride>,
   ) => Promise<GetL2OutputReturnType>
+  /**
+   * 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'
+   *
+   * const publicClientL1 = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * const version = await publicClientL1.getPortalVersion({
+   *   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')
+   */
+  getPortalVersion: <chainOverride extends Chain | undefined = undefined>(
+    parameters: GetPortalVersionParameters<chain, chainOverride>,
+  ) => Promise<GetPortalVersionReturnType>
   /**
    * Returns the time until the withdrawal transaction can be finalized. Used for the [Withdrawal](/op-stack/guides/withdrawals) flow.
    *
@@ -278,6 +383,34 @@ export type PublicActionsL1<
   getTimeToFinalize: <chainOverride extends Chain | undefined = undefined>(
     parameters: GetTimeToFinalizeParameters<chain, chainOverride>,
   ) => Promise<GetTimeToFinalizeReturnType>
+  /**
+   * 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'
+   *
+   * const publicClientL1 = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * const { seconds } = await publicClientL1.getTimeToNextGame({
+   *   l2BlockNumber: 113405763n,
+   *   targetChain: optimism
+   * })
+   */
+  getTimeToNextGame: <chainOverride extends Chain | undefined = undefined>(
+    parameters: GetTimeToNextGameParameters<chain, chainOverride>,
+  ) => Promise<GetTimeToNextGameReturnType>
   /**
    * Returns the time until the next L2 output (after a provided block number) is submitted. Used for the [Withdrawal](/op-stack/guides/withdrawals) flow.
    *
@@ -381,6 +514,32 @@ export type PublicActionsL1<
   getWithdrawalStatus: <chainOverride extends Chain | undefined = undefined>(
     parameters: GetWithdrawalStatusParameters<chain, chainOverride>,
   ) => Promise<GetWithdrawalStatusReturnType>
+  /**
+   * Waits for the next L2 output (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 { optimism } from 'viem/chains'
+   *
+   * const publicClientL1 = createPublicClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   *
+   * await publicClientL1.waitForNextGame({
+   *   l2BlockNumber: 69420n,
+   *   targetChain: optimism
+   * })
+   */
+  waitForNextGame: <chainOverride extends Chain | undefined = undefined>(
+    parameters: WaitForNextGameParameters<chain, chainOverride>,
+  ) => Promise<WaitForNextGameReturnType>
   /**
    * Waits for the next L2 output (after the provided block number) to be submitted.
    *
@@ -516,11 +675,16 @@ export function publicActionsL1() {
         estimateFinalizeWithdrawalGas(client, args),
       estimateProveWithdrawalGas: (args) =>
         estimateProveWithdrawalGas(client, args),
+      getGame: (args) => getGame(client, args),
+      getGames: (args) => getGames(client, args),
       getL2Output: (args) => getL2Output(client, args),
+      getPortalVersion: (args) => getPortalVersion(client, args),
       getTimeToFinalize: (args) => getTimeToFinalize(client, args),
+      getTimeToNextGame: (args) => getTimeToNextGame(client, args),
       getTimeToNextL2Output: (args) => getTimeToNextL2Output(client, args),
       getTimeToProve: (args) => getTimeToProve(client, args),
       getWithdrawalStatus: (args) => getWithdrawalStatus(client, args),
+      waitForNextGame: (args) => waitForNextGame(client, args),
       waitForNextL2Output: (args) => waitForNextL2Output(client, args),
       waitToFinalize: (args) => waitToFinalize(client, args),
       waitToProve: (args) => waitToProve(client, args),

package/chains/opStack/errors/withdrawal.ts

@@ -1,6 +1,16 @@
 import { BaseError } from '../../../errors/base.js'
 import type { Hex } from '../../../types/misc.js'
 
+export type GameNotFoundErrorType = GameNotFoundError & {
+  name: 'GameNotFoundError'
+}
+export class GameNotFoundError extends BaseError {
+  override name = 'GameNotFoundError'
+  constructor() {
+    super('Dispute game not found.')
+  }
+}
+
 export type ReceiptContainsNoWithdrawalsErrorType =
   ReceiptContainsNoWithdrawalsError & {
     name: 'ReceiptContainsNoWithdrawalsError'

package/chains/opStack/index.ts

@@ -52,6 +52,18 @@ export {
   type EstimateL1FeeParameters,
   type EstimateL1FeeReturnType,
 } from './actions/estimateL1Fee.js'
+export {
+  getGame,
+  type GetGameErrorType,
+  type GetGameParameters,
+  type GetGameReturnType,
+} from './actions/getGame.js'
+export {
+  getGames,
+  type GetGamesErrorType,
+  type GetGamesParameters,
+  type GetGamesReturnType,
+} from './actions/getGames.js'
 export {
   getL1BaseFee,
   type GetL1BaseFeeErrorType,
@@ -88,6 +100,18 @@ export {
   type GetL2OutputParameters,
   type GetL2OutputReturnType,
 } from './actions/getL2Output.js'
+export {
+  getPortalVersion,
+  type GetPortalVersionErrorType,
+  type GetPortalVersionParameters,
+  type GetPortalVersionReturnType,
+} from './actions/getPortalVersion.js'
+export {
+  getTimeToNextGame,
+  type GetTimeToNextGameErrorType,
+  type GetTimeToNextGameParameters,
+  type GetTimeToNextGameReturnType,
+} from './actions/getTimeToNextGame.js'
 export {
   getTimeToFinalize,
   type GetTimeToFinalizeErrorType,
@@ -124,6 +148,12 @@ export {
   type ProveWithdrawalParameters,
   type ProveWithdrawalReturnType,
 } from './actions/proveWithdrawal.js'
+export {
+  waitForNextGame,
+  type WaitForNextGameErrorType,
+  type WaitForNextGameParameters,
+  type WaitForNextGameReturnType,
+} from './actions/waitForNextGame.js'
 export {
   waitForNextL2Output,
   type WaitForNextL2OutputErrorType,

package/chains/opStack/types/chain.ts

@@ -1,6 +1,9 @@
 import type { Chain, ChainContract } from '../../../types/chain.js'
 
-export type TargetChain<chain extends Chain, contractName extends string> = {
+export type TargetChain<
+  chain extends Chain = Chain,
+  contractName extends string = string,
+> = {
   contracts: {
     [_ in contractName]: { [_ in chain['id']]: ChainContract }
   }

package/chains/opStack/types/withdrawal.ts

@@ -1,6 +1,14 @@
 import type { Address } from 'abitype'
 import type { Hex } from '../../../types/misc.js'
 
+export type Game = {
+  index: bigint
+  metadata: Hex
+  timestamp: bigint
+  rootClaim: Hex
+  extraData: Hex
+}
+
 export type WithdrawalRequest = {
   /** Encoded contract method & arguments. */
   data?: Hex | undefined

package/chains/zksync/actions/deployContract.ts

@@ -0,0 +1,100 @@
+import type { Abi } from 'abitype'
+
+import type { Account } from '../../../accounts/types.js'
+import type { DeployContractParameters as DeployContractParameters_ } from '../../../actions/wallet/deployContract.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 { ContractConstructorArgs } from '../../../types/contract.js'
+import type { Hash, Hex } from '../../../types/misc.js'
+import { contractDeployerAddress } from '../constants/address.js'
+import type { ChainEIP712 } from '../types/chain.js'
+import type { ContractDeploymentType } from '../types/contract.js'
+import { encodeDeployData } from '../utils/abi/encodeDeployData.js'
+import {
+  type SendEip712TransactionErrorType,
+  type SendEip712TransactionParameters,
+  type SendEip712TransactionReturnType,
+  sendEip712Transaction,
+} from './sendEip712Transaction.js'
+
+export type DeployContractParameters<
+  abi extends Abi | readonly unknown[] = Abi,
+  chain extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+  account extends Account | undefined = Account | undefined,
+  chainOverride extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+  allArgs = ContractConstructorArgs<abi>,
+> = DeployContractParameters_<abi, chain, account, chainOverride, allArgs> & {
+  deploymentType?: ContractDeploymentType
+  factoryDeps?: Hex[]
+  salt?: Hash
+}
+
+export type DeployContractReturnType = SendEip712TransactionReturnType
+
+export type DeployContractErrorType = SendEip712TransactionErrorType | ErrorType
+
+/**
+ * Deploys a contract to the network, given bytecode and constructor arguments using EIP712 transaction.
+ *
+ * - Docs: https://viem.sh/docs/contract/deployContract
+ *
+ * @param client - Client to use
+ * @param parameters - {@link DeployContractParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link DeployContractReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { zkSync } from 'viem/chains'
+ * import { deployContract } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: zksync,
+ *   transport: custom(provider),
+ * })
+ * const hash = await deployContract(client, {
+ *   abi: [],
+ *   account: '0x…,
+ *   deploymentType: 'create',
+ *   bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
+ *   factoryDeps: ['0x608060405260405161083e38038061083e833981016040819052610...'],
+ *   gasPerPubdata: 50000n
+ * })
+ */
+export function deployContract<
+  const abi extends Abi | readonly unknown[],
+  chain extends ChainEIP712 | undefined,
+  account extends Account | undefined,
+  chainOverride extends ChainEIP712 | undefined,
+>(
+  walletClient: Client<Transport, chain, account>,
+  parameters: DeployContractParameters<abi, chain, account, chainOverride>,
+): Promise<DeployContractReturnType> {
+  const { abi, args, bytecode, deploymentType, salt, ...request } =
+    parameters as DeployContractParameters
+
+  const data = encodeDeployData({
+    abi,
+    args,
+    bytecode,
+    deploymentType,
+    salt,
+  })
+
+  // Add the bytecode to the factoryDeps if it's not already there
+  request.factoryDeps = request.factoryDeps || []
+  if (!request.factoryDeps.includes(bytecode))
+    request.factoryDeps.push(bytecode)
+
+  return sendEip712Transaction(walletClient, {
+    ...request,
+    data,
+    to: contractDeployerAddress,
+  } as unknown as SendEip712TransactionParameters<
+    chain,
+    account,
+    chainOverride
+  >)
+}