@aztec/ethereum 0.0.0-test.0 → 0.0.1-commit.023c3e5

package/src/test/upgrade_utils.ts

@@ -1,36 +1,37 @@
 import type { Logger } from '@aztec/foundation/log';
-import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts';
+import { DateProvider } from '@aztec/foundation/timer';
 import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+import { TestERC20Abi as StakingAssetAbi } from '@aztec/l1-artifacts/TestERC20Abi';
 
 import { type GetContractReturnType, type PrivateKeyAccount, getContract } from 'viem';
 
-import { EthCheatCodes } from '../eth_cheat_codes.js';
+import { extractProposalIdFromLogs } from '../contracts/governance.js';
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
-import type { L1Clients } from '../types.js';
+import { createL1TxUtilsFromViemWallet } from '../l1_tx_utils/index.js';
+import type { ExtendedViemWalletClient, ViemPublicClient } from '../types.js';
+import { EthCheatCodes } from './eth_cheat_codes.js';
 
 export async function executeGovernanceProposal(
   proposalId: bigint,
-  governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>,
+  governance: GetContractReturnType<typeof GovernanceAbi, ViemPublicClient>,
   voteAmount: bigint,
   privateKey: PrivateKeyAccount,
-  publicClient: L1Clients['publicClient'],
-  walletClient: L1Clients['walletClient'],
+  l1Client: ExtendedViemWalletClient,
   rpcUrls: string[],
   logger: Logger,
 ) {
   const proposal = await governance.read.getProposal([proposalId]);
 
+  const l1TxUtils = createL1TxUtilsFromViemWallet(l1Client);
+
   const waitL1Block = async () => {
-    await publicClient.waitForTransactionReceipt({
-      hash: await walletClient.sendTransaction({
-        to: privateKey.address,
-        value: 1n,
-        account: privateKey,
-      }),
+    await l1TxUtils.sendAndMonitorTransaction({
+      to: l1Client.account.address,
+      value: 1n,
     });
   };
 
-  const cheatCodes = new EthCheatCodes(rpcUrls, logger);
+  const cheatCodes = new EthCheatCodes(rpcUrls, new DateProvider(), logger);
 
   const timeToActive = proposal.creation + proposal.config.votingDelay;
   logger.info(`Warping to ${timeToActive + 1n}`);
@@ -40,7 +41,7 @@ export async function executeGovernanceProposal(
 
   logger.info(`Voting`);
   const voteTx = await governance.write.vote([proposalId, voteAmount, true], { account: privateKey });
-  await publicClient.waitForTransactionReceipt({ hash: voteTx });
+  await l1Client.waitForTransactionReceipt({ hash: voteTx });
   logger.info(`Voted`);
 
   const timeToExecutable = timeToActive + proposal.config.votingDuration + proposal.config.executionDelay + 1n;
@@ -50,7 +51,7 @@ export async function executeGovernanceProposal(
   await waitL1Block();
 
   const executeTx = await governance.write.execute([proposalId], { account: privateKey });
-  await publicClient.waitForTransactionReceipt({ hash: executeTx });
+  await l1Client.waitForTransactionReceipt({ hash: executeTx });
   logger.info(`Executed proposal`);
 }
 
@@ -58,12 +59,16 @@ export async function createGovernanceProposal(
   payloadAddress: `0x${string}`,
   addresses: L1ContractAddresses,
   privateKey: PrivateKeyAccount,
-  publicClient: L1Clients['publicClient'],
+  publicClient: ViemPublicClient,
   logger: Logger,
-): Promise<{ governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>; voteAmount: bigint }> {
+): Promise<{
+  governance: GetContractReturnType<typeof GovernanceAbi, ViemPublicClient>;
+  voteAmount: bigint;
+  proposalId: bigint;
+}> {
   const token = getContract({
-    address: addresses.feeJuiceAddress.toString(),
-    abi: FeeJuiceAbi,
+    address: addresses.stakingAssetAddress.toString(),
+    abi: StakingAssetAbi,
     client: publicClient,
   });
 
@@ -92,9 +97,13 @@ export async function createGovernanceProposal(
   await publicClient.waitForTransactionReceipt({ hash: depositTx });
   logger.info(`Deposited tokens`);
 
-  await governance.write.proposeWithLock([payloadAddress, privateKey.address], {
+  const proposeTx = await governance.write.proposeWithLock([payloadAddress, privateKey.address], {
     account: privateKey,
   });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash: proposeTx });
+  logger.info(`Proposed upgrade`);
+
+  const proposalId = extractProposalIdFromLogs(receipt.logs);
 
-  return { governance, voteAmount };
+  return { governance, voteAmount, proposalId };
 }

package/src/types.ts

@@ -1,21 +1,82 @@
 import type {
+  Abi,
   Account,
   Chain,
   Client,
   FallbackTransport,
+  GetContractReturnType,
+  Hex,
   HttpTransport,
   PublicActions,
   PublicClient,
   PublicRpcSchema,
   WalletActions,
-  WalletClient,
   WalletRpcSchema,
 } from 'viem';
 
 /** Type for a viem public client */
 export type ViemPublicClient = PublicClient<FallbackTransport<HttpTransport[]>, Chain>;
 
-export type SimpleViemWalletClient = WalletClient<FallbackTransport<HttpTransport[]>, Chain, Account>;
+export type PublicRpcDebugSchema = [
+  {
+    Method: 'debug_traceTransaction';
+    Parameters: [txHash: `0x${string}`, options: { tracer: 'callTracer' }];
+    ReturnType: DebugCallTrace;
+  },
+  {
+    Method: 'trace_transaction';
+    Parameters: [txHash: `0x${string}`];
+    ReturnType: TraceTransactionResponse[];
+  },
+];
+
+/** Return type for a debug_traceTransaction call */
+export type DebugCallTrace = {
+  from: Hex;
+  to?: Hex;
+  type: string;
+  input?: Hex;
+  output?: Hex;
+  gas?: Hex;
+  gasUsed?: Hex;
+  value?: Hex;
+  error?: string;
+  calls?: DebugCallTrace[];
+};
+
+/** Action object for a trace_transaction call */
+export type TraceAction = {
+  from: Hex;
+  to?: Hex;
+  callType: string;
+  gas?: Hex;
+  input?: Hex;
+  value?: Hex;
+};
+
+/** Result object for a trace_transaction call */
+export type TraceResult = {
+  gasUsed?: Hex;
+  output?: Hex;
+};
+
+/** Return type for a single trace in trace_transaction response */
+export type TraceTransactionResponse = {
+  action: TraceAction;
+  result?: TraceResult;
+  error?: string;
+  subtraces: number;
+  traceAddress: number[];
+  type: string;
+};
+
+/** Type for a viem public client with support for debug methods */
+export type ViemPublicDebugClient = PublicClient<
+  FallbackTransport<HttpTransport[]>,
+  Chain,
+  undefined,
+  [...PublicRpcSchema, ...PublicRpcDebugSchema]
+>;
 
 export type ExtendedViemWalletClient = Client<
   FallbackTransport<readonly HttpTransport[]>,
@@ -25,9 +86,12 @@ export type ExtendedViemWalletClient = Client<
   PublicActions<FallbackTransport<readonly HttpTransport[]>, Chain> & WalletActions<Chain, Account>
 >;
 
-export type ViemWalletClient = SimpleViemWalletClient | ExtendedViemWalletClient;
+/** Type for a viem client that can be either public or extended with wallet capabilities */
+export type ViemClient = ViemPublicClient | ExtendedViemWalletClient;
 
-export type L1Clients = {
-  publicClient: ViemPublicClient;
-  walletClient: ExtendedViemWalletClient;
-};
+/** Type for a viem contract that can be used with an extended viem client */
+export type ViemContract<TAbi extends Abi> = GetContractReturnType<TAbi, ExtendedViemWalletClient>;
+
+export function isExtendedClient(client: ViemClient): client is ExtendedViemWalletClient {
+  return 'account' in client && client.account !== undefined;
+}

package/src/utils.ts

@@ -1,18 +1,21 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import type { Logger } from '@aztec/foundation/log';
-import { ErrorsAbi } from '@aztec/l1-artifacts';
+import { ErrorsAbi } from '@aztec/l1-artifacts/ErrorsAbi';
 
 import {
   type Abi,
+  type AbiItem,
   BaseError,
   type ContractEventName,
   ContractFunctionRevertedError,
   type DecodeEventLogReturnType,
+  type FormattedTransaction,
   type Hex,
   type Log,
   decodeErrorResult,
   decodeEventLog,
 } from 'viem';
+import { formatAbiItem, formatAbiParams } from 'viem/utils';
 
 export interface L2Claim {
   claimSecret: Fr;
@@ -50,7 +53,7 @@ export function extractEvent<
   return event;
 }
 
-function tryExtractEvent<
+export function tryExtractEvent<
   const TAbi extends Abi | readonly unknown[],
   TEventName extends ContractEventName<TAbi>,
   TEventType = DecodeEventLogReturnType<TAbi, TEventName, Hex[], undefined, true>,
@@ -92,6 +95,57 @@ export function prettyLogViemErrorMsg(err: any) {
   return err?.message ?? err;
 }
 
+export function mergeAbis(abis: Abi[]): Abi {
+  let merged: Abi = [];
+  const seen = new Set<string>();
+
+  for (const abi of abis) {
+    for (const item of abi) {
+      const key = getAbiItemKey(item);
+      if (!seen.has(key)) {
+        seen.add(key);
+        merged = [...merged, item];
+      }
+    }
+  }
+
+  return merged;
+}
+
+function getAbiItemKey(item: AbiItem): string {
+  if (item.type === 'function') {
+    const signature = formatAbiItem(item);
+    const outputs = formatAbiParams(item.outputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `function:${signature}:${outputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'event') {
+    const signature = formatAbiItem(item);
+    const indexed = (item.inputs ?? []).map(input => ((input as { indexed?: boolean }).indexed ? '1' : '0')).join('');
+    const anonymous = item.anonymous ? 'anonymous' : 'not-anonymous';
+    return `event:${signature}:${indexed}:${anonymous}`;
+  }
+
+  if (item.type === 'error') {
+    const signature = formatAbiItem(item);
+    return `error:${signature}`;
+  }
+
+  if (item.type === 'constructor') {
+    const inputs = formatAbiParams(item.inputs);
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `constructor::${inputs}:${stateMutability}`;
+  }
+
+  if (item.type === 'fallback' || item.type === 'receive') {
+    const stateMutability = typeof item.stateMutability === 'string' ? item.stateMutability : '';
+    return `${item.type}:::${stateMutability}`;
+  }
+
+  return 'unknown';
+}
+
 function getNestedErrorData(error: unknown): string | undefined {
   // If nothing, bail
   if (!error) {
@@ -158,106 +212,65 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
         return new FormattedViemError(`${errorName}${args}`, error?.metaMessages);
       }
     }
-  } catch (decodeErr) {
+  } catch {
     // If decoding fails, we fall back to the original formatting
   }
 
+  // Strip ABI from the error object before formatting
+  if (error && typeof error === 'object') {
+    // Create a clone to avoid modifying the original
+    const errorClone = structuredClone(error);
+
+    // Helper function to recursively remove ABI properties
+
+    // Strip ABIs from the clone
+    stripAbis(errorClone);
+
+    // Use the cleaned clone for further processing
+    error = errorClone;
+  }
+
   // If it's a regular Error instance, return it with its message
   if (error instanceof Error) {
-    return error;
+    return new FormattedViemError(error.message, (error as any)?.metaMessages);
   }
 
-  // Original formatting logic for non-custom errors
-  const truncateHex = (hex: string, length = 100) => {
-    if (!hex || typeof hex !== 'string') {
-      return hex;
-    }
-    if (!hex.startsWith('0x')) {
-      return hex;
-    }
-    if (hex.length <= length * 2) {
-      return hex;
-    }
-    return `${hex.slice(0, length)}...${hex.slice(-length)}`;
-  };
-
-  const formatRequestBody = (body: string) => {
-    try {
-      const parsed = JSON.parse(body);
+  const body = String(error);
+  const length = body.length;
+  // LogExplorer can only render up to 2500 characters in it's summary view. Try to keep the whole message below this number
+  // Limit the error to 2000 chacaters in order to allow code higher up to decorate this error with extra details (up to 500 characters)
+  if (length > 2000) {
+    const chunk = 950;
+    const truncated = length - 2 * chunk;
+    return new FormattedViemError(
+      body.slice(0, chunk) + `...${truncated} characters truncated...` + body.slice(-1 * chunk),
+    );
+  }
 
-      // Recursively process all parameters that might contain hex strings
-      const processParams = (obj: any): any => {
-        if (Array.isArray(obj)) {
-          return obj.map(item => processParams(item));
-        }
-        if (typeof obj === 'object' && obj !== null) {
-          const result: any = {};
-          for (const [key, value] of Object.entries(obj)) {
-            result[key] = processParams(value);
-          }
-          return result;
-        }
-        if (typeof obj === 'string') {
-          if (obj.startsWith('0x')) {
-            return truncateHex(obj);
-          }
-        }
-        return obj;
-      };
-
-      // Process the entire request body
-      const processed = processParams(parsed);
-      return JSON.stringify(processed, null, 2);
-    } catch {
-      return body;
-    }
-  };
-
-  const truncateHexStringsInText = (text: string): string => {
-    const hexRegex = /\b0x[a-fA-F0-9]{10,}/g;
-    return text.replace(hexRegex, hex => truncateHex(hex));
-  };
-
-  const extractAndFormatRequestBody = (message: string): string => {
-    // First handle Request body JSON
-    const requestBodyRegex = /Request body: ({[\s\S]*?})\n/g;
-    let result = message.replace(requestBodyRegex, (match, body) => {
-      return `Request body: ${formatRequestBody(body)}\n`;
-    });
-
-    // Then handle Arguments section
-    const argsRegex = /((?:Request |Estimate Gas )?Arguments:[\s\S]*?(?=\n\n|$))/g;
-    result = result.replace(argsRegex, section => {
-      const lines = section.split('\n');
-      const processedLines = lines.map(line => {
-        // Check if line contains a colon followed by content
-        const colonIndex = line.indexOf(':');
-        if (colonIndex !== -1) {
-          const [prefix, content] = [line.slice(0, colonIndex + 1), line.slice(colonIndex + 1).trim()];
-          // If content contains a hex string, truncate it
-          if (content.includes('0x')) {
-            const hexMatches = content.match(/0x[a-fA-F0-9]+/g) || [];
-            let processedContent = content;
-            hexMatches.forEach(hex => {
-              processedContent = processedContent.replace(hex, truncateHex(hex));
-            });
-            return `${prefix} ${processedContent}`;
-          }
-        }
-        return line;
-      });
-      return processedLines.join('\n');
-    });
+  return new FormattedViemError(body);
+}
 
-    // Finally, catch any remaining hex strings in the message
-    result = truncateHexStringsInText(result);
+function stripAbis(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return;
+  }
 
-    return result;
-  };
+  // Delete ABI property at current level
+  if ('abi' in obj) {
+    delete obj.abi;
+  }
 
-  const formattedRes = extractAndFormatRequestBody(error?.message || String(error));
+  // Process cause property
+  if (obj.cause) {
+    stripAbis(obj.cause);
+  }
 
-  return new FormattedViemError(formattedRes.replace(/\\n/g, '\n'), error?.metaMessages);
+  // Process arrays and objects
+  Object.values(obj).forEach(value => {
+    if (value && typeof value === 'object') {
+      stripAbis(value);
+    }
+  });
 }
 
 export function tryGetCustomErrorName(err: any) {
@@ -270,7 +283,35 @@ export function tryGetCustomErrorName(err: any) {
         return (revertError as ContractFunctionRevertedError).data?.errorName;
       }
     }
-  } catch (_e) {
+  } catch {
     return undefined;
   }
 }
+
+/**
+ * Type guard to check if a transaction is a blob transaction (EIP-4844).
+ * Blob transactions have maxFeePerBlobGas and blobVersionedHashes fields.
+ */
+export function isBlobTransaction(tx: FormattedTransaction): tx is FormattedTransaction & {
+  maxFeePerBlobGas: bigint;
+  blobVersionedHashes: readonly Hex[];
+} {
+  return (
+    'maxFeePerBlobGas' in tx &&
+    tx.maxFeePerBlobGas !== undefined &&
+    'blobVersionedHashes' in tx &&
+    tx.blobVersionedHashes !== undefined
+  );
+}
+
+/**
+ * Calculates a percentile from an array of bigints
+ */
+export function calculatePercentile(values: bigint[], percentile: number): bigint {
+  if (values.length === 0) {
+    return 0n;
+  }
+  const sorted = [...values].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  const index = Math.ceil((sorted.length - 1) * (percentile / 100));
+  return sorted[index];
+}

package/src/zkPassportVerifierAddress.ts

@@ -0,0 +1,15 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+/**
+ * The address of the zk passport verifier on sepolia
+ * get address from: ROOT/l1-contracts/lib/circuits/src/solidity/deployments/deployment-11155111.json
+ */
+export const ZK_PASSPORT_VERIFIER_ADDRESS = EthAddress.fromString('0x3101Bad9eA5fACadA5554844a1a88F7Fe48D4DE0');
+/**
+ * The default domain of the zk passport site
+ */
+export const ZK_PASSPORT_DOMAIN = 'testnet.aztec.network';
+/**
+ * The default scope of the zk passport proofs
+ */
+export const ZK_PASSPORT_SCOPE = 'personhood';

package/dest/contracts/forwarder.d.ts

@@ -1,24 +0,0 @@
-import type { Logger } from '@aztec/foundation/log';
-import { type Hex } from 'viem';
-import type { L1BlobInputs, L1GasConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
-import type { L1Clients, ViemPublicClient, ViemWalletClient } from '../types.js';
-export declare class ForwarderContract {
-    readonly client: L1Clients['publicClient'];
-    readonly rollupAddress: Hex;
-    private readonly forwarder;
-    constructor(client: L1Clients['publicClient'], address: Hex, rollupAddress: Hex);
-    static create(owner: Hex, walletClient: ViemWalletClient, publicClient: ViemPublicClient, logger: Logger, rollupAddress: Hex): Promise<ForwarderContract>;
-    getAddress(): `0x${string}`;
-    forward(requests: L1TxRequest[], l1TxUtils: L1TxUtils, gasConfig: L1GasConfig | undefined, blobConfig: L1BlobInputs | undefined, logger: Logger): Promise<{
-        receipt: import("viem").TransactionReceipt;
-        gasPrice: import("../l1_tx_utils.js").GasPrice;
-        stats: import("../l1_tx_utils.js").TransactionStats | undefined;
-        errorMsg?: undefined;
-    } | {
-        receipt: import("viem").TransactionReceipt;
-        gasPrice: import("../l1_tx_utils.js").GasPrice;
-        errorMsg: string | undefined;
-        stats?: undefined;
-    }>;
-}
-//# sourceMappingURL=forwarder.d.ts.map

package/dest/contracts/forwarder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"forwarder.d.ts","sourceRoot":"","sources":["../../src/contracts/forwarder.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EAGL,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAGd,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC3F,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGjF,qBAAa,iBAAiB;aAGA,MAAM,EAAE,SAAS,CAAC,cAAc,CAAC;aAAgC,aAAa,EAAE,GAAG;IAF/G,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA+D;gBAE7D,MAAM,EAAE,SAAS,CAAC,cAAc,CAAC,EAAE,OAAO,EAAE,GAAG,EAAkB,aAAa,EAAE,GAAG;WAIlG,MAAM,CACjB,KAAK,EAAE,GAAG,EACV,YAAY,EAAE,gBAAgB,EAC9B,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,GAAG;IAwBb,UAAU;IAIJ,OAAO,CAClB,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,WAAW,GAAG,SAAS,EAClC,UAAU,EAAE,YAAY,GAAG,SAAS,EACpC,MAAM,EAAE,MAAM;;;;;;;;;;;CAqEjB"}

package/dest/contracts/forwarder.js

@@ -1,101 +0,0 @@
-import { toHex } from '@aztec/foundation/bigint-buffer';
-import { ForwarderAbi, ForwarderBytecode } from '@aztec/l1-artifacts';
-import { encodeFunctionData, getContract } from 'viem';
-import { deployL1Contract } from '../deploy_l1_contracts.js';
-import { RollupContract } from './rollup.js';
-export class ForwarderContract {
-    client;
-    rollupAddress;
-    forwarder;
-    constructor(client, address, rollupAddress){
-        this.client = client;
-        this.rollupAddress = rollupAddress;
-        this.forwarder = getContract({
-            address,
-            abi: ForwarderAbi,
-            client
-        });
-    }
-    static async create(owner, walletClient, publicClient, logger, rollupAddress) {
-        logger.info('Deploying forwarder contract');
-        const { address, txHash } = await deployL1Contract(walletClient, publicClient, ForwarderAbi, ForwarderBytecode, [
-            owner
-        ], owner, undefined, logger);
-        if (txHash) {
-            await publicClient.waitForTransactionReceipt({
-                hash: txHash
-            });
-        }
-        logger.info(`Forwarder contract deployed at ${address} with owner ${owner}`);
-        return new ForwarderContract(publicClient, address.toString(), rollupAddress);
-    }
-    getAddress() {
-        return this.forwarder.address;
-    }
-    async forward(requests, l1TxUtils, gasConfig, blobConfig, logger) {
-        requests = requests.filter((request)=>request.to !== null);
-        const toArgs = requests.map((request)=>request.to);
-        const dataArgs = requests.map((request)=>request.data);
-        const forwarderFunctionData = {
-            abi: ForwarderAbi,
-            functionName: 'forward',
-            args: [
-                toArgs,
-                dataArgs
-            ]
-        };
-        const encodedForwarderData = encodeFunctionData(forwarderFunctionData);
-        const { receipt, gasPrice } = await l1TxUtils.sendAndMonitorTransaction({
-            to: this.forwarder.address,
-            data: encodedForwarderData
-        }, gasConfig, blobConfig);
-        if (receipt.status === 'success') {
-            const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
-            return {
-                receipt,
-                gasPrice,
-                stats
-            };
-        } else {
-            logger.error('Forwarder transaction failed', undefined, {
-                receipt
-            });
-            const args = {
-                ...forwarderFunctionData,
-                address: this.forwarder.address
-            };
-            let errorMsg;
-            if (blobConfig) {
-                const maxFeePerBlobGas = blobConfig.maxFeePerBlobGas ?? gasPrice.maxFeePerBlobGas;
-                if (maxFeePerBlobGas === undefined) {
-                    errorMsg = 'maxFeePerBlobGas is required to get the error message';
-                } else {
-                    logger.debug('Trying to get error from reverted tx with blob config');
-                    errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedForwarderData, args, {
-                        blobs: blobConfig.blobs,
-                        kzg: blobConfig.kzg,
-                        maxFeePerBlobGas
-                    }, [
-                        {
-                            address: this.rollupAddress,
-                            stateDiff: [
-                                {
-                                    slot: toHex(RollupContract.checkBlobStorageSlot, true),
-                                    value: toHex(0n, true)
-                                }
-                            ]
-                        }
-                    ]);
-                }
-            } else {
-                logger.debug('Trying to get error from reverted tx without blob config');
-                errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedForwarderData, args, undefined, []);
-            }
-            return {
-                receipt,
-                gasPrice,
-                errorMsg
-            };
-        }
-    }
-}

package/dest/contracts/slashing_proposer.d.ts

@@ -1,21 +0,0 @@
-import { EthAddress } from '@aztec/foundation/eth-address';
-import { type Hex } from 'viem';
-import type { L1TxRequest } from '../l1_tx_utils.js';
-import type { ViemPublicClient } from '../types.js';
-import { type IEmpireBase } from './empire_base.js';
-export declare class SlashingProposerContract implements IEmpireBase {
-    readonly client: ViemPublicClient;
-    private readonly proposer;
-    constructor(client: ViemPublicClient, address: Hex);
-    get address(): EthAddress;
-    getQuorumSize(): Promise<bigint>;
-    getRoundSize(): Promise<bigint>;
-    computeRound(slot: bigint): Promise<bigint>;
-    getRoundInfo(rollupAddress: Hex, round: bigint): Promise<{
-        lastVote: bigint;
-        leader: Hex;
-        executed: boolean;
-    }>;
-    createVoteRequest(payload: Hex): L1TxRequest;
-}
-//# sourceMappingURL=slashing_proposer.d.ts.map

package/dest/contracts/slashing_proposer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"slashing_proposer.d.ts","sourceRoot":"","sources":["../../src/contracts/slashing_proposer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAA8B,KAAK,GAAG,EAAe,MAAM,MAAM,CAAC;AAEzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,KAAK,WAAW,EAAc,MAAM,kBAAkB,CAAC;AAEhE,qBAAa,wBAAyB,YAAW,WAAW;aAG9B,MAAM,EAAE,gBAAgB;IAFpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsE;gBAEnE,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,GAAG;IAIlE,IAAW,OAAO,eAEjB;IAEM,aAAa;IAIb,YAAY;IAIZ,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAIrC,YAAY,CACvB,aAAa,EAAE,GAAG,EAClB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,GAAG,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IASzD,iBAAiB,CAAC,OAAO,EAAE,GAAG,GAAG,WAAW;CAMpD"}