@aztec/ethereum 0.70.0 → 0.72.1

package/src/deploy_l1_contracts.ts

@@ -109,121 +109,67 @@ export interface ContractArtifacts {
   libraries?: Libraries;
 }
 
-/**
- * All L1 Contract Artifacts for deployment
- */
-export interface L1ContractArtifactsForDeployment {
-  /**
-   * Inbox contract artifacts
-   */
-  inbox: ContractArtifacts;
-  /**
-   * Outbox contract artifacts
-   */
-  outbox: ContractArtifacts;
-  /**
-   * Registry contract artifacts
-   */
-  registry: ContractArtifacts;
-  /**
-   * Rollup contract artifacts
-   */
-  rollup: ContractArtifacts;
-  /**
-   * The token to stake.
-   */
-  stakingAsset: ContractArtifacts;
-  /**
-   * The token to pay for gas. This will be bridged to L2 via the feeJuicePortal below
-   */
-  feeAsset: ContractArtifacts;
-  /**
-   * Fee juice portal contract artifacts. Optional for now as gas is not strictly enforced
-   */
-  feeJuicePortal: ContractArtifacts;
-  /**
-   * CoinIssuer contract artifacts.
-   */
-  coinIssuer: ContractArtifacts;
-  /**
-   * RewardDistributor contract artifacts.
-   */
-  rewardDistributor: ContractArtifacts;
-  /**
-   * GovernanceProposer contract artifacts.
-   */
-  governanceProposer: ContractArtifacts;
-  /**
-   * Governance contract artifacts.
-   */
-  governance: ContractArtifacts;
-  /**
-   * SlashFactory contract artifacts.
-   */
-  slashFactory: ContractArtifacts;
-}
-
-export const l1Artifacts: L1ContractArtifactsForDeployment = {
+export const l1Artifacts = {
   registry: {
     contractAbi: RegistryAbi,
-    contractBytecode: RegistryBytecode,
+    contractBytecode: RegistryBytecode as Hex,
   },
   inbox: {
     contractAbi: InboxAbi,
-    contractBytecode: InboxBytecode,
+    contractBytecode: InboxBytecode as Hex,
   },
   outbox: {
     contractAbi: OutboxAbi,
-    contractBytecode: OutboxBytecode,
+    contractBytecode: OutboxBytecode as Hex,
   },
   rollup: {
     contractAbi: RollupAbi,
-    contractBytecode: RollupBytecode,
+    contractBytecode: RollupBytecode as Hex,
     libraries: {
       linkReferences: RollupLinkReferences,
       libraryCode: {
         LeonidasLib: {
           contractAbi: LeonidasLibAbi,
-          contractBytecode: LeonidasLibBytecode,
+          contractBytecode: LeonidasLibBytecode as Hex,
         },
         ExtRollupLib: {
           contractAbi: ExtRollupLibAbi,
-          contractBytecode: ExtRollupLibBytecode,
+          contractBytecode: ExtRollupLibBytecode as Hex,
         },
       },
     },
   },
   stakingAsset: {
     contractAbi: TestERC20Abi,
-    contractBytecode: TestERC20Bytecode,
+    contractBytecode: TestERC20Bytecode as Hex,
   },
   feeAsset: {
     contractAbi: TestERC20Abi,
-    contractBytecode: TestERC20Bytecode,
+    contractBytecode: TestERC20Bytecode as Hex,
   },
   feeJuicePortal: {
     contractAbi: FeeJuicePortalAbi,
-    contractBytecode: FeeJuicePortalBytecode,
+    contractBytecode: FeeJuicePortalBytecode as Hex,
   },
   rewardDistributor: {
     contractAbi: RewardDistributorAbi,
-    contractBytecode: RewardDistributorBytecode,
+    contractBytecode: RewardDistributorBytecode as Hex,
   },
   coinIssuer: {
     contractAbi: CoinIssuerAbi,
-    contractBytecode: CoinIssuerBytecode,
+    contractBytecode: CoinIssuerBytecode as Hex,
   },
   governanceProposer: {
     contractAbi: GovernanceProposerAbi,
-    contractBytecode: GovernanceProposerBytecode,
+    contractBytecode: GovernanceProposerBytecode as Hex,
   },
   governance: {
     contractAbi: GovernanceAbi,
-    contractBytecode: GovernanceBytecode,
+    contractBytecode: GovernanceBytecode as Hex,
   },
   slashFactory: {
     contractAbi: SlashFactoryAbi,
-    contractBytecode: SlashFactoryBytecode,
+    contractBytecode: SlashFactoryBytecode as Hex,
   },
 };
 
@@ -400,6 +346,8 @@ export const deployL1Contracts = async (
     account.address.toString(),
     rollupConfigArgs,
   ];
+  await deployer.waitForDeployments();
+
   const rollupAddress = await deployer.deploy(l1Artifacts.rollup, rollupArgs);
   logger.verbose(`Deployed Rollup at ${rollupAddress}`, rollupConfigArgs);
 
@@ -443,32 +391,49 @@ export const deployL1Contracts = async (
   }
 
   if (args.initialValidators && args.initialValidators.length > 0) {
-    // Mint tokens, approve them, use cheat code to initialise validator set without setting up the epoch.
-    const stakeNeeded = args.minimumStake * BigInt(args.initialValidators.length);
-    await Promise.all(
-      [
-        await stakingAsset.write.mint([walletClient.account.address, stakeNeeded], {} as any),
-        await stakingAsset.write.approve([rollupAddress.toString(), stakeNeeded], {} as any),
-      ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
+    // Check if some of the initial validators are already registered, so we support idempotent deployments
+    const validatorsInfo = await Promise.all(
+      args.initialValidators.map(async address => ({ address, ...(await rollup.read.getInfo([address.toString()])) })),
     );
+    const existingValidators = validatorsInfo.filter(v => v.status !== 0);
+    if (existingValidators.length > 0) {
+      logger.warn(
+        `Validators ${existingValidators.map(v => v.address).join(', ')} already exist. Skipping from initialization.`,
+      );
+    }
+
+    const newValidatorsAddresses = validatorsInfo.filter(v => v.status === 0).map(v => v.address.toString());
 
-    const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([
-      args.initialValidators.map(v => ({
-        attester: v.toString(),
-        proposer: v.toString(),
-        withdrawer: v.toString(),
-        amount: args.minimumStake,
-      })),
-    ]);
-    txHashes.push(initiateValidatorSetTxHash);
-    logger.info(`Initialized validator set (${args.initialValidators.join(', ')}) in tx ${initiateValidatorSetTxHash}`);
+    if (newValidatorsAddresses.length > 0) {
+      // Mint tokens, approve them, use cheat code to initialise validator set without setting up the epoch.
+      const stakeNeeded = args.minimumStake * BigInt(newValidatorsAddresses.length);
+      await Promise.all(
+        [
+          await stakingAsset.write.mint([walletClient.account.address, stakeNeeded], {} as any),
+          await stakingAsset.write.approve([rollupAddress.toString(), stakeNeeded], {} as any),
+        ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
+      );
+
+      const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([
+        newValidatorsAddresses.map(v => ({
+          attester: v,
+          proposer: v,
+          withdrawer: v,
+          amount: args.minimumStake,
+        })),
+      ]);
+      txHashes.push(initiateValidatorSetTxHash);
+      logger.info(
+        `Initialized validator set (${newValidatorsAddresses.join(', ')}) in tx ${initiateValidatorSetTxHash}`,
+      );
+    }
   }
 
   // @note  This value MUST match what is in `constants.nr`. It is currently specified here instead of just importing
   //        because there is circular dependency hell. This is a temporary solution. #3342
   // @todo  #8084
   // fund the portal contract with Fee Juice
-  const FEE_JUICE_INITIAL_MINT = 200000000000000000000n;
+  const FEE_JUICE_INITIAL_MINT = 200000000000000000000000n;
   const mintTxHash = await feeAsset.write.mint([feeJuicePortalAddress.toString(), FEE_JUICE_INITIAL_MINT], {} as any);
 
   // @note  This is used to ensure we fully wait for the transaction when running against a real chain
@@ -476,8 +441,8 @@ export const deployL1Contracts = async (
   await publicClient.waitForTransactionReceipt({ hash: mintTxHash });
   logger.verbose(`Funding fee juice portal contract with fee juice in ${mintTxHash}`);
 
-  if (!(await feeJuicePortal.read.initialized([]))) {
-    const initPortalTxHash = await feeJuicePortal.write.initialize([]);
+  if (!(await feeJuicePortal.read.initialized())) {
+    const initPortalTxHash = await feeJuicePortal.write.initialize();
     txHashes.push(initPortalTxHash);
     logger.verbose(`Fee juice portal initializing in tx ${initPortalTxHash}`);
   } else {
@@ -493,13 +458,13 @@ export const deployL1Contracts = async (
     //        The edge case being that the genesis block is already occupying slot 0, so we cannot have another block.
     try {
       // Need to get the time
-      const currentSlot = (await rollup.read.getCurrentSlot([])) as bigint;
+      const currentSlot = (await rollup.read.getCurrentSlot()) as bigint;
 
       if (BigInt(currentSlot) === 0n) {
-        const ts = Number(await rollup.read.getTimestampForSlot([1]));
+        const ts = Number(await rollup.read.getTimestampForSlot([1n]));
         await rpcCall('evm_setNextBlockTimestamp', [ts]);
         await rpcCall('hardhat_mine', [1]);
-        const currentSlot = (await rollup.read.getCurrentSlot([])) as bigint;
+        const currentSlot = (await rollup.read.getCurrentSlot()) as bigint;
 
         if (BigInt(currentSlot) !== 1n) {
           throw new Error(`Error jumping time: current slot is ${currentSlot}`);
@@ -518,10 +483,10 @@ export const deployL1Contracts = async (
   }
 
   // Inbox and Outbox are immutable and are deployed from Rollup's constructor so we just fetch them from the contract.
-  const inboxAddress = EthAddress.fromString((await rollup.read.INBOX([])) as any);
+  const inboxAddress = EthAddress.fromString((await rollup.read.INBOX()) as any);
   logger.verbose(`Inbox available at ${inboxAddress}`);
 
-  const outboxAddress = EthAddress.fromString((await rollup.read.OUTBOX([])) as any);
+  const outboxAddress = EthAddress.fromString((await rollup.read.OUTBOX()) as any);
   logger.verbose(`Outbox available at ${outboxAddress}`);
 
   // We need to call a function on the registry to set the various contract addresses.
@@ -541,7 +506,7 @@ export const deployL1Contracts = async (
   }
 
   // If the owner is not the Governance contract, transfer ownership to the Governance contract
-  if ((await registryContract.read.owner([])) !== getAddress(governanceAddress.toString())) {
+  if ((await registryContract.read.owner()) !== getAddress(governanceAddress.toString())) {
     const transferOwnershipTxHash = await registryContract.write.transferOwnership(
       [getAddress(governanceAddress.toString())],
       {
@@ -616,50 +581,6 @@ class L1Deployer {
   }
 }
 
-/**
- * Compiles a contract source code using the provided solc compiler.
- * @param fileName - Contract file name (eg UltraHonkVerifier.sol)
- * @param contractName - Contract name within the file (eg HonkVerifier)
- * @param source - Source code to compile
- * @param solc - Solc instance
- * @returns ABI and bytecode of the compiled contract
- */
-export function compileContract(
-  fileName: string,
-  contractName: string,
-  source: string,
-  solc: { compile: (source: string) => string },
-): { abi: Narrow<Abi | readonly unknown[]>; bytecode: Hex } {
-  const input = {
-    language: 'Solidity',
-    sources: {
-      [fileName]: {
-        content: source,
-      },
-    },
-    settings: {
-      // we require the optimizer
-      optimizer: {
-        enabled: true,
-        runs: 200,
-      },
-      evmVersion: 'cancun',
-      outputSelection: {
-        '*': {
-          '*': ['evm.bytecode.object', 'abi'],
-        },
-      },
-    },
-  };
-
-  const output = JSON.parse(solc.compile(JSON.stringify(input)));
-
-  const abi = output.contracts[fileName][contractName].abi;
-  const bytecode: `0x${string}` = `0x${output.contracts[fileName][contractName].evm.bytecode.object}`;
-
-  return { abi, bytecode };
-}
-
 // docs:start:deployL1Contract
 /**
  * Helper function to deploy ETH contracts.

package/src/eth_cheat_codes.ts

@@ -126,7 +126,7 @@ export class EthCheatCodes {
    * Set the next block base fee per gas
    * @param baseFee - The base fee to set
    */
-  public async setNextBlockBaseFeePerGas(baseFee: bigint): Promise<void> {
+  public async setNextBlockBaseFeePerGas(baseFee: bigint | number): Promise<void> {
     const res = await this.rpcCall('anvil_setNextBlockBaseFeePerGas', [baseFee.toString()]);
     if (res.error) {
       throw new Error(`Error setting next block base fee per gas: ${res.error.message}`);

package/src/l1_tx_utils.ts

@@ -12,11 +12,15 @@ import { sleep } from '@aztec/foundation/sleep';
 import {
   type Account,
   type Address,
+  type BlockOverrides,
   type Chain,
   type GetTransactionReturnType,
   type Hex,
   type HttpTransport,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
   type PublicClient,
+  type StateOverride,
   type TransactionReceipt,
   type WalletClient,
   formatGwei,
@@ -95,9 +99,9 @@ export interface L1TxUtilsConfig {
 
 export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
   gasLimitBufferPercentage: {
-    description: 'How much to increase gas price by each attempt (percentage)',
+    description: 'How much to increase calculated gas limit by (percentage)',
     env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-    ...numberConfigHelper(10),
+    ...numberConfigHelper(20),
   },
   minGwei: {
     description: 'Minimum gas price in gwei',
@@ -199,7 +203,7 @@ export class L1TxUtils {
    */
   public async sendTransaction(
     request: L1TxRequest,
-    _gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint; txTimeoutAt?: Date },
+    _gasConfig?: Partial<L1TxUtilsConfig> & { gasLimit?: bigint; txTimeoutAt?: Date },
     blobInputs?: L1BlobInputs,
   ): Promise<{ txHash: Hex; gasLimit: bigint; gasPrice: GasPrice }> {
     try {
@@ -207,8 +211,8 @@ export class L1TxUtils {
       const account = this.walletClient.account;
       let gasLimit: bigint;
 
-      if (gasConfig.fixedGas) {
-        gasLimit = gasConfig.fixedGas;
+      if (gasConfig.gasLimit) {
+        gasLimit = gasConfig.gasLimit;
       } else {
         gasLimit = await this.estimateGas(account, request);
       }
@@ -246,9 +250,9 @@ export class L1TxUtils {
 
       return { txHash, gasLimit, gasPrice };
     } catch (err: any) {
-      const formattedErr = formatViemError(err);
-      this.logger?.error(`Failed to send transaction`, formattedErr);
-      throw formattedErr;
+      const viemError = formatViemError(err);
+      this.logger?.error(`Failed to send L1 transaction`, viemError.message, { metaMessages: viemError.metaMessages });
+      throw viemError;
     }
   }
 
@@ -306,15 +310,16 @@ export class L1TxUtils {
             try {
               const receipt = await this.publicClient.getTransactionReceipt({ hash });
               if (receipt) {
-                this.logger?.debug(`L1 transaction ${hash} mined`);
                 if (receipt.status === 'reverted') {
-                  this.logger?.error(`L1 transaction ${hash} reverted`);
+                  this.logger?.error(`L1 transaction ${hash} reverted`, receipt);
+                } else {
+                  this.logger?.debug(`L1 transaction ${hash} mined`);
                 }
                 return receipt;
               }
             } catch (err) {
               if (err instanceof Error && err.message.includes('reverted')) {
-                throw err;
+                throw formatViemError(err);
               }
             }
           }
@@ -382,16 +387,20 @@ export class L1TxUtils {
         }
         await sleep(gasConfig.checkIntervalMs!);
       } catch (err: any) {
-        const formattedErr = formatViemError(err);
-        this.logger?.warn(`Error monitoring tx ${currentTxHash}:`, formattedErr);
-        if (err.message?.includes('reverted')) {
-          throw formattedErr;
+        const viemError = formatViemError(err);
+        this.logger?.warn(`Error monitoring L1 transaction ${currentTxHash}:`, viemError.message);
+        if (viemError.message?.includes('reverted')) {
+          throw viemError;
         }
         await sleep(gasConfig.checkIntervalMs!);
       }
       // Check if tx has timed out.
       txTimedOut = isTimedOut();
     }
+    this.logger?.error(`L1 transaction ${currentTxHash} timed out`, {
+      txHash: currentTxHash,
+      ...tx,
+    });
     throw new Error(`L1 transaction ${currentTxHash} timed out`);
   }
 
@@ -403,7 +412,7 @@ export class L1TxUtils {
    */
   public async sendAndMonitorTransaction(
     request: L1TxRequest,
-    gasConfig?: Partial<L1TxUtilsConfig> & { fixedGas?: bigint; txTimeoutAt?: Date },
+    gasConfig?: Partial<L1TxUtilsConfig> & { gasLimit?: bigint; txTimeoutAt?: Date },
     blobInputs?: L1BlobInputs,
   ): Promise<{ receipt: TransactionReceipt; gasPrice: GasPrice }> {
     const { txHash, gasLimit, gasPrice } = await this.sendTransaction(request, gasConfig, blobInputs);
@@ -429,14 +438,14 @@ export class L1TxUtils {
     try {
       const blobBaseFeeHex = await this.publicClient.request({ method: 'eth_blobBaseFee' });
       blobBaseFee = BigInt(blobBaseFeeHex);
-      this.logger?.debug('Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
+      this.logger?.debug('L1 Blob base fee:', { blobBaseFee: formatGwei(blobBaseFee) });
     } catch {
-      this.logger?.warn('Failed to get blob base fee', attempt);
+      this.logger?.warn('Failed to get L1 blob base fee', attempt);
     }
 
     let priorityFee: bigint;
     if (gasConfig.fixedPriorityFeePerGas) {
-      this.logger?.debug('Using fixed priority fee per gas', {
+      this.logger?.debug('Using fixed priority fee per L1 gas', {
         fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas,
       });
       // try to maintain precision up to 1000000 wei
@@ -514,7 +523,7 @@ export class L1TxUtils {
       maxFeePerBlobGas = maxFeePerBlobGas > minBlobFee ? maxFeePerBlobGas : minBlobFee;
     }
 
-    this.logger?.debug(`Computed gas price`, {
+    this.logger?.debug(`Computed L1 gas price`, {
       attempt,
       baseFee: formatGwei(baseFee),
       maxFeePerGas: formatGwei(maxFeePerGas),
@@ -553,14 +562,74 @@ export class L1TxUtils {
           maxFeePerBlobGas: gasPrice.maxFeePerBlobGas!,
         })
       )?.gas;
+      this.logger?.debug('L1 gas used in estimateGas by blob tx', { gas: initialEstimate });
     } else {
       initialEstimate = await this.publicClient.estimateGas({ account, ...request });
+      this.logger?.debug('L1 gas used in estimateGas by non-blob tx', { gas: initialEstimate });
     }
 
     // Add buffer based on either fixed amount or percentage
-    const withBuffer =
-      initialEstimate + (initialEstimate * BigInt((gasConfig.gasLimitBufferPercentage || 0) * 1_00)) / 100_00n;
+    const withBuffer = this.bumpGasLimit(initialEstimate, gasConfig);
 
     return withBuffer;
   }
+
+  public async simulateGasUsed(
+    request: L1TxRequest & { gas?: bigint },
+    blockOverrides: BlockOverrides<bigint, number> = {},
+    stateOverrides: StateOverride = [],
+    _gasConfig?: L1TxUtilsConfig & { fallbackGasEstimate?: bigint },
+  ): Promise<bigint> {
+    const gasConfig = { ...this.config, ..._gasConfig };
+    const gasPrice = await this.getGasPrice(gasConfig, false);
+
+    const nonce = await this.publicClient.getTransactionCount({ address: this.walletClient.account.address });
+
+    try {
+      const result = await this.publicClient.simulate({
+        validation: true,
+        blocks: [
+          {
+            blockOverrides,
+            stateOverrides,
+            calls: [
+              {
+                from: this.walletClient.account.address,
+                to: request.to!,
+                data: request.data,
+                maxFeePerGas: gasPrice.maxFeePerGas,
+                maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
+                gas: request.gas ?? 10_000_000n,
+                nonce,
+              },
+            ],
+          },
+        ],
+      });
+      this.logger?.debug(`L1 gas used in simulation: ${result[0].calls[0].gasUsed}`, {
+        result,
+      });
+      if (result[0].calls[0].status === 'failure') {
+        this.logger?.error('L1 transaction Simulation failed', {
+          error: result[0].calls[0].error,
+        });
+        throw new Error(`L1 transaction simulation failed with error: ${result[0].calls[0].error.message}`);
+      }
+      return result[0].gasUsed;
+    } catch (err) {
+      if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
+        this.logger?.error('Node does not support eth_simulateV1 API');
+        if (gasConfig.fallbackGasEstimate) {
+          this.logger?.debug(`Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`);
+          return gasConfig.fallbackGasEstimate;
+        }
+      }
+      throw err;
+    }
+  }
+
+  public bumpGasLimit(gasLimit: bigint, _gasConfig?: L1TxUtilsConfig): bigint {
+    const gasConfig = { ...this.config, ..._gasConfig };
+    return gasLimit + (gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 1_00)) / 100_00n;
+  }
 }

package/src/utils.ts

@@ -1,5 +1,6 @@
 import { type Fr } from '@aztec/foundation/fields';
 import { type Logger } from '@aztec/foundation/log';
+import { ErrorsAbi } from '@aztec/l1-artifacts';
 
 import {
   type Abi,
@@ -9,6 +10,7 @@ import {
   type DecodeEventLogReturnType,
   type Hex,
   type Log,
+  decodeErrorResult,
   decodeEventLog,
 } from 'viem';
 
@@ -19,6 +21,16 @@ export interface L2Claim {
   messageLeafIndex: bigint;
 }
 
+export class FormattedViemError extends Error {
+  metaMessages?: any[];
+
+  constructor(message: string, metaMessages?: any[]) {
+    super(message);
+    this.name = 'FormattedViemError';
+    this.metaMessages = metaMessages;
+  }
+}
+
 export function extractEvent<
   const TAbi extends Abi | readonly unknown[],
   TEventName extends ContractEventName<TAbi>,
@@ -80,7 +92,56 @@ export function prettyLogViemErrorMsg(err: any) {
   return err?.message ?? err;
 }
 
-export function formatViemError(error: any): string {
+/**
+ * Formats a Viem error into a FormattedViemError instance.
+ * @param error - The error to format.
+ * @param abi - The ABI to use for decoding.
+ * @returns A FormattedViemError instance.
+ */
+export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViemError {
+  // If error is already a FormattedViemError, return it as is
+  if (error instanceof FormattedViemError) {
+    return error;
+  }
+
+  // First try to decode as a custom error using the ABI
+  try {
+    if (error?.data) {
+      // Try to decode the error data using the ABI
+      const decoded = decodeErrorResult({
+        abi,
+        data: error.data as Hex,
+      });
+      if (decoded) {
+        return new FormattedViemError(`${decoded.errorName}(${decoded.args?.join(', ') ?? ''})`, error?.metaMessages);
+      }
+    }
+
+    // If it's a BaseError, try to get the custom error through ContractFunctionRevertedError
+    if (error instanceof BaseError) {
+      const revertError = error.walk(err => err instanceof ContractFunctionRevertedError);
+      if (revertError instanceof ContractFunctionRevertedError) {
+        let errorName = revertError.data?.errorName;
+        if (!errorName) {
+          errorName = revertError.signature ?? '';
+        }
+        const args =
+          revertError.metaMessages && revertError.metaMessages?.length > 1
+            ? revertError.metaMessages[1].trimStart()
+            : '';
+        return new FormattedViemError(`${errorName}${args}`, error?.metaMessages);
+      }
+    }
+  } catch (decodeErr) {
+    // If decoding fails, we fall back to the original formatting
+  }
+
+  // If it's a regular Error instance, return it with its message
+  if (error instanceof Error) {
+    return new FormattedViemError(error.message);
+  }
+
+  // Original formatting logic for non-custom errors
   const truncateHex = (hex: string, length = 100) => {
     if (!hex || typeof hex !== 'string') {
       return hex;
@@ -168,8 +229,7 @@ export function formatViemError(error: any): string {
     return result;
   };
 
-  return JSON.stringify({ error: extractAndFormatRequestBody(error?.message || String(error)) }, null, 2).replace(
-    /\\n/g,
-    '\n',
-  );
+  const formattedRes = extractAndFormatRequestBody(error?.message || String(error));
+
+  return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
 }