viem 2.32.1 → 2.33.1

package/op-stack/abis.ts

@@ -1488,6 +1488,19 @@ export const portal2Abi = [
     stateMutability: 'view',
     type: 'function',
   },
+  {
+    inputs: [],
+    name: 'anchorStateRegistry',
+    outputs: [
+      {
+        internalType: 'contract IAnchorStateRegistry',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
   {
     inputs: [],
     name: 'version',
@@ -1755,6 +1768,31 @@ export const portal2Abi = [
     name: 'Unproven',
     type: 'error',
   },
+  {
+    inputs: [],
+    name: 'OptimismPortal_AlreadyFinalized',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'OptimismPortal_Unproven',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'OptimismPortal_InvalidProofTimestamp',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'OptimismPortal_ProofNotOldEnough',
+    type: 'error',
+  },
+  {
+    inputs: [],
+    name: 'OptimismPortal_InvalidRootClaim',
+    type: 'error',
+  },
 ] as const
 
 export const portalAbi = [
@@ -2074,3 +2112,27 @@ export const portalAbi = [
   },
   { stateMutability: 'payable', type: 'receive' },
 ] as const
+
+export const anchorStateRegistryAbi = [
+  {
+    stateMutability: 'view',
+    type: 'function',
+    inputs: [{ name: '_game', internalType: 'address', type: 'address' }],
+    name: 'isGameProper',
+    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
+  },
+  {
+    stateMutability: 'view',
+    type: 'function',
+    inputs: [{ name: '_game', internalType: 'address', type: 'address' }],
+    name: 'isGameRespected',
+    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
+  },
+  {
+    stateMutability: 'view',
+    type: 'function',
+    inputs: [{ name: '_game', internalType: 'address', type: 'address' }],
+    name: 'isGameFinalized',
+    outputs: [{ name: '', internalType: 'bool', type: 'bool' }],
+  },
+]

package/op-stack/actions/getWithdrawalStatus.ts

@@ -16,7 +16,7 @@ import type {
 import type { Hash } from '../../types/misc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import type { OneOf } from '../../types/utils.js'
-import { portal2Abi, portalAbi } from '../abis.js'
+import { anchorStateRegistryAbi, portal2Abi, portalAbi } from '../abis.js'
 import {
   ReceiptContainsNoWithdrawalsError,
   type ReceiptContainsNoWithdrawalsErrorType,
@@ -249,35 +249,49 @@ export async function getWithdrawalStatus<
     args: [withdrawal.withdrawalHash, numProofSubmitters - 1n],
   }).catch(() => withdrawal.sender)
 
-  const [disputeGameResult, checkWithdrawalResult, finalizedResult] =
-    await Promise.allSettled([
-      getGame(client, {
-        ...parameters,
-        l2BlockNumber,
-        limit: gameLimit,
-      } as GetGameParameters),
-      readContract(client, {
-        abi: portal2Abi,
-        address: portalAddress,
-        functionName: 'checkWithdrawal',
-        args: [withdrawal.withdrawalHash, proofSubmitter],
-      }),
-      readContract(client, {
-        abi: portal2Abi,
-        address: portalAddress,
-        functionName: 'finalizedWithdrawals',
-        args: [withdrawal.withdrawalHash],
-      }),
-    ])
+  const [
+    disputeGameResult,
+    provenWithdrawalsResult,
+    checkWithdrawalResult,
+    finalizedResult,
+  ] = await Promise.allSettled([
+    getGame(client, {
+      ...parameters,
+      l2BlockNumber,
+      limit: gameLimit,
+    } as GetGameParameters),
+    readContract(client, {
+      abi: portal2Abi,
+      address: portalAddress,
+      functionName: 'provenWithdrawals',
+      args: [withdrawal.withdrawalHash, proofSubmitter],
+    }),
+    readContract(client, {
+      abi: portal2Abi,
+      address: portalAddress,
+      functionName: 'checkWithdrawal',
+      args: [withdrawal.withdrawalHash, proofSubmitter],
+    }),
+    readContract(client, {
+      abi: portal2Abi,
+      address: portalAddress,
+      functionName: 'finalizedWithdrawals',
+      args: [withdrawal.withdrawalHash],
+    }),
+  ])
 
   if (finalizedResult.status === 'fulfilled' && finalizedResult.value)
     return 'finalized'
 
+  if (provenWithdrawalsResult.status === 'rejected')
+    throw provenWithdrawalsResult.reason
+
   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) {
@@ -292,6 +306,9 @@ export async function getWithdrawalStatus<
           'InvalidGameType',
           'LegacyGame',
           'Unproven',
+          // After U16
+          'OptimismPortal_Unproven',
+          'OptimismPortal_InvalidProofTimestamp',
         ],
         'waiting-to-finalize': [
           'OptimismPortal: proven withdrawal has not matured yet',
@@ -306,6 +323,85 @@ export async function getWithdrawalStatus<
         error.cause.data?.errorName,
         error.cause.data?.args?.[0] as string,
       ]
+
+      // After U16 we get a generic error message (OptimismPortal_InvalidRootClaim) because the
+      // OptimismPortal will call AnchorStateRegistry.isGameClaimValid which simply returns
+      // true/false. If we get this generic error, we need to figure out why the function returned
+      // false and return a proper status accordingly. We can also check these conditions when we
+      // get ProofNotOldEnough so users can be notified when their pending proof becomes invalid
+      // before it can be finalized.
+      if (
+        errors.includes('OptimismPortal_InvalidRootClaim') ||
+        errors.includes('OptimismPortal_ProofNotOldEnough')
+      ) {
+        // Get the dispute game address from the proven withdrawal.
+        const disputeGameAddress = provenWithdrawalsResult.value[0] as Address
+
+        // Get the AnchorStateRegistry address from the portal.
+        const anchorStateRegistry = await readContract(client, {
+          abi: portal2Abi,
+          address: portalAddress,
+          functionName: 'anchorStateRegistry',
+        })
+
+        // Check if the game is proper, respected, and finalized.
+        const [
+          isGameProperResult,
+          isGameRespectedResult,
+          isGameFinalizedResult,
+        ] = await Promise.allSettled([
+          readContract(client, {
+            abi: anchorStateRegistryAbi,
+            address: anchorStateRegistry,
+            functionName: 'isGameProper',
+            args: [disputeGameAddress],
+          }),
+          readContract(client, {
+            abi: anchorStateRegistryAbi,
+            address: anchorStateRegistry,
+            functionName: 'isGameRespected',
+            args: [disputeGameAddress],
+          }),
+          readContract(client, {
+            abi: anchorStateRegistryAbi,
+            address: anchorStateRegistry,
+            functionName: 'isGameFinalized',
+            args: [disputeGameAddress],
+          }),
+        ])
+
+        // If any of the calls failed, throw the error.
+        if (isGameProperResult.status === 'rejected')
+          throw isGameProperResult.reason
+        if (isGameRespectedResult.status === 'rejected')
+          throw isGameRespectedResult.reason
+        if (isGameFinalizedResult.status === 'rejected')
+          throw isGameFinalizedResult.reason
+
+        // If the game isn't proper, the user needs to re-prove.
+        if (!isGameProperResult.value) {
+          return 'ready-to-prove'
+        }
+
+        // If the game isn't respected, the user needs to re-prove.
+        if (!isGameRespectedResult.value) {
+          return 'ready-to-prove'
+        }
+
+        // If the game isn't finalized, the user needs to wait to finalize.
+        if (!isGameFinalizedResult.value) {
+          return 'waiting-to-finalize'
+        }
+
+        // If the actual error was ProofNotOldEnough, then at this point the game is probably
+        // completely fine but the proof hasn't passed the waiting period. Otherwise, the only
+        // reason we'd be here is if the game resolved in favor of the challenger, which means the
+        // user needs to re-prove the withdrawal.
+        if (errors.includes('OptimismPortal_ProofNotOldEnough')) {
+          return 'waiting-to-finalize'
+        }
+        return 'ready-to-prove'
+      }
       if (errorCauses['ready-to-prove'].some((cause) => errors.includes(cause)))
         return 'ready-to-prove'
       if (

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.32.1",
+  "version": "2.33.1",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -201,7 +201,13 @@
   },
   "license": "MIT",
   "homepage": "https://viem.sh",
-  "repository": "wevm/viem",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wevm/viem.git"
+  },
+  "bugs": {
+    "url": "https://github.com/wevm/viem/issues"
+  },
   "authors": [
     "awkweb.eth",
     "jxom.eth"

package/types/chain.ts

@@ -54,6 +54,8 @@ export type Chain<
   name: string
   /** Currency used by chain */
   nativeCurrency: ChainNativeCurrency
+  /** Preconfirmation time in milliseconds. */
+  experimental_preconfirmationTime?: number | undefined
   /** Collection of RPC endpoints */
   rpcUrls: {
     [key: string]: ChainRpcUrls