@aztec/ethereum 0.0.0-test.0

package/dest/l1_tx_utils_with_blobs.js

@@ -0,0 +1,64 @@
+import { Blob } from '@aztec/blob-lib';
+import { formatGwei } from 'viem';
+import { L1TxUtils } from './l1_tx_utils.js';
+export class L1TxUtilsWithBlobs extends L1TxUtils {
+    /**
+   * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
+   * @param nonce - The nonce of the transaction to cancel
+   * @param previousGasPrice - The gas price of the previous transaction
+   * @param attempts - The number of attempts to cancel the transaction
+   * @returns The hash of the cancellation transaction
+   */ async attemptTxCancellation(nonce, isBlobTx = false, previousGasPrice, attempts = 0) {
+        const account = this.walletClient.account;
+        // Get gas price with higher priority fee for cancellation
+        const cancelGasPrice = await this.getGasPrice({
+            ...this.config,
+            // Use high bump for cancellation to ensure it replaces the original tx
+            priorityFeeRetryBumpPercentage: 150
+        }, isBlobTx, attempts + 1, previousGasPrice);
+        this.logger?.debug(`Attempting to cancel transaction with nonce ${nonce}`, {
+            maxFeePerGas: formatGwei(cancelGasPrice.maxFeePerGas),
+            maxPriorityFeePerGas: formatGwei(cancelGasPrice.maxPriorityFeePerGas)
+        });
+        const request = {
+            to: account.address,
+            value: 0n
+        };
+        // Send 0-value tx to self with higher gas price
+        if (!isBlobTx) {
+            const cancelTxHash = await this.walletClient.sendTransaction({
+                ...request,
+                nonce,
+                gas: 21_000n,
+                maxFeePerGas: cancelGasPrice.maxFeePerGas,
+                maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas
+            });
+            const receipt = await this.monitorTransaction(request, cancelTxHash, {
+                gasLimit: 21_000n
+            }, undefined, undefined, true);
+            return receipt.transactionHash;
+        } else {
+            const blobData = new Uint8Array(131072).fill(0);
+            const kzg = Blob.getViemKzgInstance();
+            const blobInputs = {
+                blobs: [
+                    blobData
+                ],
+                kzg,
+                maxFeePerBlobGas: cancelGasPrice.maxFeePerBlobGas
+            };
+            const cancelTxHash = await this.walletClient.sendTransaction({
+                ...request,
+                ...blobInputs,
+                nonce,
+                gas: 21_000n,
+                maxFeePerGas: cancelGasPrice.maxFeePerGas,
+                maxPriorityFeePerGas: cancelGasPrice.maxPriorityFeePerGas
+            });
+            const receipt = await this.monitorTransaction(request, cancelTxHash, {
+                gasLimit: 21_000n
+            }, undefined, blobInputs, true);
+            return receipt.transactionHash;
+        }
+    }
+}

package/dest/queries.d.ts

@@ -0,0 +1,12 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { L1ContractsConfig } from './config.js';
+import type { ViemPublicClient } from './types.js';
+/** Reads the L1ContractsConfig from L1 contracts. */
+export declare function getL1ContractsConfig(publicClient: ViemPublicClient, addresses: {
+    governanceAddress: EthAddress;
+    rollupAddress?: EthAddress;
+}): Promise<Omit<L1ContractsConfig, 'ethereumSlotDuration'> & {
+    l1StartBlock: bigint;
+    l1GenesisTime: bigint;
+}>;
+//# sourceMappingURL=queries.d.ts.map

package/dest/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qDAAqD;AACrD,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE;IAAE,iBAAiB,EAAE,UAAU,CAAC;IAAC,aAAa,CAAC,EAAE,UAAU,CAAA;CAAE,GACvE,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,GAAG;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CA8C5G"}

package/dest/queries.js

@@ -0,0 +1,35 @@
+import { GovernanceContract } from './contracts/governance.js';
+import { RollupContract } from './contracts/rollup.js';
+/** Reads the L1ContractsConfig from L1 contracts. */ export async function getL1ContractsConfig(publicClient, addresses) {
+    const governance = new GovernanceContract(addresses.governanceAddress.toString(), publicClient, undefined);
+    const governanceProposer = await governance.getProposer();
+    const rollupAddress = addresses.rollupAddress ?? (await governance.getGovernanceAddresses()).rollupAddress;
+    const rollup = new RollupContract(publicClient, rollupAddress.toString());
+    const slasherProposer = await rollup.getSlashingProposer();
+    const [l1StartBlock, l1GenesisTime, aztecEpochDuration, aztecProofSubmissionWindow, aztecSlotDuration, aztecTargetCommitteeSize, minimumStake, governanceProposerQuorum, governanceProposerRoundSize, slashingQuorum, slashingRoundSize] = await Promise.all([
+        rollup.getL1StartBlock(),
+        rollup.getL1GenesisTime(),
+        rollup.getEpochDuration(),
+        rollup.getProofSubmissionWindow(),
+        rollup.getSlotDuration(),
+        rollup.getTargetCommitteeSize(),
+        rollup.getMinimumStake(),
+        governanceProposer.getQuorumSize(),
+        governanceProposer.getRoundSize(),
+        slasherProposer.getQuorumSize(),
+        slasherProposer.getRoundSize()
+    ]);
+    return {
+        l1StartBlock,
+        l1GenesisTime,
+        aztecEpochDuration: Number(aztecEpochDuration),
+        aztecProofSubmissionWindow: Number(aztecProofSubmissionWindow),
+        aztecSlotDuration: Number(aztecSlotDuration),
+        aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+        governanceProposerQuorum: Number(governanceProposerQuorum),
+        governanceProposerRoundSize: Number(governanceProposerRoundSize),
+        minimumStake,
+        slashingQuorum: Number(slashingQuorum),
+        slashingRoundSize: Number(slashingRoundSize)
+    };
+}

package/dest/test/delayed_tx_utils.d.ts

@@ -0,0 +1,8 @@
+import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
+import { type Delayer } from './tx_delayer.js';
+export declare class DelayedTxUtils extends L1TxUtilsWithBlobs {
+    delayer: Delayer | undefined;
+    static fromL1TxUtils(l1TxUtils: L1TxUtilsWithBlobs, ethereumSlotDuration: number): DelayedTxUtils;
+    enableDelayer(ethereumSlotDuration: number): void;
+}
+//# sourceMappingURL=delayed_tx_utils.d.ts.map

package/dest/test/delayed_tx_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayed_tx_utils.d.ts","sourceRoot":"","sources":["../../src/test/delayed_tx_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,KAAK,OAAO,EAAe,MAAM,iBAAiB,CAAC;AAE5D,qBAAa,cAAe,SAAQ,kBAAkB;IAC7C,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;WAEtB,aAAa,CAAC,SAAS,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM;IAUhF,aAAa,CAAC,oBAAoB,EAAE,MAAM;CAOlD"}

package/dest/test/delayed_tx_utils.js

@@ -0,0 +1,21 @@
+import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
+import { withDelayer } from './tx_delayer.js';
+export class DelayedTxUtils extends L1TxUtilsWithBlobs {
+    delayer;
+    static fromL1TxUtils(l1TxUtils, ethereumSlotDuration) {
+        const { client, delayer } = withDelayer(l1TxUtils.walletClient, {
+            ethereumSlotDuration
+        });
+        const casted = l1TxUtils;
+        casted.delayer = delayer;
+        casted.walletClient = client;
+        return casted;
+    }
+    enableDelayer(ethereumSlotDuration) {
+        const { client, delayer } = withDelayer(this.walletClient, {
+            ethereumSlotDuration
+        });
+        this.delayer = delayer;
+        this.walletClient = client;
+    }
+}

package/dest/test/eth_cheat_codes_with_state.d.ts

@@ -0,0 +1,18 @@
+import { EthCheatCodes } from '../eth_cheat_codes.js';
+/**
+ * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.
+ * It is separated to avoid importing fs in the main EthCheatCodes class, which might be used in the browser.
+ */
+export declare class EthCheatCodesWithState extends EthCheatCodes {
+    /**
+     * Dumps the current chain state to a file.
+     * @param fileName - The file name to dump state into
+     */
+    dumpChainState(fileName: string): Promise<void>;
+    /**
+     * Loads the chain state from a file.
+     * @param fileName - The file name to load state from
+     */
+    loadChainState(fileName: string): Promise<void>;
+}
+//# sourceMappingURL=eth_cheat_codes_with_state.d.ts.map

package/dest/test/eth_cheat_codes_with_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth_cheat_codes_with_state.d.ts","sourceRoot":"","sources":["../../src/test/eth_cheat_codes_with_state.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtD;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAW5D;;;OAGG;IACU,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAS7D"}

package/dest/test/eth_cheat_codes_with_state.js

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import { EthCheatCodes } from '../eth_cheat_codes.js';
+/**
+ * A class that provides utility functions for interacting with ethereum (L1) dumping/loading state to/from a file.
+ * It is separated to avoid importing fs in the main EthCheatCodes class, which might be used in the browser.
+ */ export class EthCheatCodesWithState extends EthCheatCodes {
+    /**
+   * Dumps the current chain state to a file.
+   * @param fileName - The file name to dump state into
+   */ async dumpChainState(fileName) {
+        let res;
+        try {
+            res = await this.rpcCall('hardhat_dumpState', []);
+        } catch (e) {
+            throw new Error(`Error dumping state: ${e}`);
+        }
+        fs.writeFileSync(`${fileName}.json`, res, 'utf8');
+        this.logger.verbose(`Dumped state to ${fileName}`);
+    }
+    /**
+   * Loads the chain state from a file.
+   * @param fileName - The file name to load state from
+   */ async loadChainState(fileName) {
+        const data = JSON.parse(fs.readFileSync(`${fileName}.json`, 'utf8'));
+        try {
+            await this.rpcCall('hardhat_loadState', [
+                data
+            ]);
+        } catch (e) {
+            throw new Error(`Error loading state: ${e}`);
+        }
+        this.logger.verbose(`Loaded state from ${fileName}`);
+    }
+}

package/dest/test/index.d.ts

@@ -0,0 +1,6 @@
+export * from './delayed_tx_utils.js';
+export * from './eth_cheat_codes_with_state.js';
+export * from './start_anvil.js';
+export * from './tx_delayer.js';
+export * from './upgrade_utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC"}

package/dest/test/index.js

@@ -0,0 +1,5 @@
+export * from './delayed_tx_utils.js';
+export * from './eth_cheat_codes_with_state.js';
+export * from './start_anvil.js';
+export * from './tx_delayer.js';
+export * from './upgrade_utils.js';

package/dest/test/start_anvil.d.ts

@@ -0,0 +1,12 @@
+import { type Anvil } from '@viem/anvil';
+/**
+ * Ensures there's a running Anvil instance and returns the RPC URL.
+ */
+export declare function startAnvil(opts?: {
+    l1BlockTime?: number;
+}): Promise<{
+    anvil: Anvil;
+    rpcUrl: string;
+    stop: () => Promise<void>;
+}>;
+//# sourceMappingURL=start_anvil.d.ts.map

package/dest/test/start_anvil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start_anvil.d.ts","sourceRoot":"","sources":["../../src/test/start_anvil.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,KAAK,EAAe,MAAM,aAAa,CAAC;AAGtD;;GAEG;AACH,wBAAsB,UAAU,CAC9B,IAAI,GAAE;IACJ,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,GACL,OAAO,CAAC;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAAC,CAsCtE"}

package/dest/test/start_anvil.js

@@ -0,0 +1,46 @@
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { fileURLToPath } from '@aztec/foundation/url';
+import { createAnvil } from '@viem/anvil';
+import { dirname, resolve } from 'path';
+/**
+ * Ensures there's a running Anvil instance and returns the RPC URL.
+ */ export async function startAnvil(opts = {}) {
+    const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
+    let port;
+    // Start anvil.
+    // We go via a wrapper script to ensure if the parent dies, anvil dies.
+    const anvil = await retry(async ()=>{
+        const anvil = createAnvil({
+            anvilBinary,
+            port: 0,
+            blockTime: opts.l1BlockTime,
+            stopTimeout: 1000
+        });
+        // Listen to the anvil output to get the port.
+        const removeHandler = anvil.on('message', (message)=>{
+            if (port === undefined && message.includes('Listening on')) {
+                port = parseInt(message.match(/Listening on ([^:]+):(\d+)/)[2]);
+            }
+        });
+        await anvil.start();
+        removeHandler();
+        return anvil;
+    }, 'Start anvil', makeBackoff([
+        5,
+        5,
+        5
+    ]));
+    if (!port) {
+        throw new Error('Failed to start anvil');
+    }
+    // Monkeypatch the anvil instance to include the actually assigned port
+    Object.defineProperty(anvil, 'port', {
+        value: port,
+        writable: false
+    });
+    return {
+        anvil,
+        stop: ()=>anvil.stop(),
+        rpcUrl: `http://127.0.0.1:${port}`
+    };
+}

package/dest/test/tx_delayer.d.ts

@@ -0,0 +1,25 @@
+import { type Logger } from '@aztec/foundation/log';
+import { type Client, type Hex } from 'viem';
+import type { ViemWalletClient } from '../types.js';
+export declare function waitUntilBlock<T extends Client>(client: T, blockNumber: number | bigint, logger?: Logger): Promise<boolean>;
+export declare function waitUntilL1Timestamp<T extends Client>(client: T, timestamp: number | bigint, logger?: Logger): Promise<boolean>;
+export interface Delayer {
+    /** Returns the list of all txs (not just the delayed ones) sent through the attached client. */
+    getTxs(): Hex[];
+    /** Delays the next tx to be sent so it lands on the given L1 block number. */
+    pauseNextTxUntilBlock(l1BlockNumber: number | bigint | undefined): void;
+    /** Delays the next tx to be sent so it lands on the given timestamp. */
+    pauseNextTxUntilTimestamp(l1Timestamp: number | bigint | undefined): void;
+}
+/**
+ * Returns a new client (without modifying the one passed in) with an injected tx delayer.
+ * The delayer can be used to hold off the next tx to be sent until a given block number.
+ * TODO(#10824): This doesn't play along well with blob txs for some reason.
+ */
+export declare function withDelayer<T extends ViemWalletClient>(client: T, opts: {
+    ethereumSlotDuration: bigint | number;
+}): {
+    client: T;
+    delayer: Delayer;
+};
+//# sourceMappingURL=tx_delayer.d.ts.map

package/dest/test/tx_delayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_delayer.d.ts","sourceRoot":"","sources":["../../src/test/tx_delayer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAIlE,OAAO,EACL,KAAK,MAAM,EACX,KAAK,GAAG,EAMT,MAAM,MAAM,CAAC;AAEd,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpD,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,oBAgBxG;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,oBAuB5G;AAED,MAAM,WAAW,OAAO;IACtB,gGAAgG;IAChG,MAAM,IAAI,GAAG,EAAE,CAAC;IAChB,8EAA8E;IAC9E,qBAAqB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IACxE,wEAAwE;IACxE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CAC3E;AAwBD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,gBAAgB,EACpD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE;IAAE,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAC9C;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA+DjC"}

package/dest/test/tx_delayer.js

@@ -0,0 +1,116 @@
+import { omit } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { inspect } from 'util';
+import { keccak256, parseTransaction, publicActions, walletActions } from 'viem';
+export function waitUntilBlock(client, blockNumber, logger) {
+    const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
+    return retryUntil(async ()=>{
+        const currentBlockNumber = await publicClient.getBlockNumber({
+            cacheTime: 0
+        });
+        logger?.debug(`Block number is ${currentBlockNumber} (waiting until ${blockNumber})`);
+        return currentBlockNumber >= BigInt(blockNumber);
+    }, `Wait until L1 block ${blockNumber}`, 120, 0.1);
+}
+export function waitUntilL1Timestamp(client, timestamp, logger) {
+    const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
+    let lastBlock = undefined;
+    return retryUntil(async ()=>{
+        const currentBlockNumber = await publicClient.getBlockNumber({
+            cacheTime: 0
+        });
+        if (currentBlockNumber === lastBlock) {
+            return false;
+        }
+        lastBlock = currentBlockNumber;
+        const currentBlock = await publicClient.getBlock({
+            includeTransactions: false,
+            blockNumber: currentBlockNumber
+        });
+        const currentTs = currentBlock.timestamp;
+        logger?.debug(`Block timstamp is ${currentTs} (waiting until ${timestamp})`);
+        return currentTs >= BigInt(timestamp);
+    }, `Wait until L1 timestamp ${timestamp}`, 120, 0.1);
+}
+class DelayerImpl {
+    constructor(opts){
+        this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
+    }
+    ethereumSlotDuration;
+    nextWait = undefined;
+    txs = [];
+    getTxs() {
+        return this.txs;
+    }
+    pauseNextTxUntilBlock(l1BlockNumber) {
+        this.nextWait = {
+            l1BlockNumber: BigInt(l1BlockNumber)
+        };
+    }
+    pauseNextTxUntilTimestamp(l1Timestamp) {
+        this.nextWait = {
+            l1Timestamp: BigInt(l1Timestamp)
+        };
+    }
+}
+/**
+ * Returns a new client (without modifying the one passed in) with an injected tx delayer.
+ * The delayer can be used to hold off the next tx to be sent until a given block number.
+ * TODO(#10824): This doesn't play along well with blob txs for some reason.
+ */ export function withDelayer(client, opts) {
+    const logger = createLogger('ethereum:tx_delayer');
+    const delayer = new DelayerImpl(opts);
+    const extended = client// Tweak sendRawTransaction so it uses the delay defined in the delayer.
+    // Note that this will only work with local accounts (ie accounts for which we have the private key).
+    // Transactions signed by the node will not be delayed since they use sendTransaction directly,
+    // but we do not use them in our codebase at all.
+    .extend((client)=>({
+            async sendRawTransaction (...args) {
+                if (delayer.nextWait !== undefined) {
+                    const waitUntil = delayer.nextWait;
+                    delayer.nextWait = undefined;
+                    const publicClient = client;
+                    const wait = 'l1BlockNumber' in waitUntil ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger) : waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger);
+                    // Compute the tx hash manually so we emulate sendRawTransaction response
+                    const { serializedTransaction } = args[0];
+                    const txHash = keccak256(serializedTransaction);
+                    logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+                        argsLen: args.length,
+                        ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars')
+                    });
+                    // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
+                    // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
+                    // mine it immediately.
+                    void wait.then(async ()=>{
+                        const clientTxHash = await client.sendRawTransaction(...args);
+                        if (clientTxHash !== txHash) {
+                            logger.error(`Tx hash returned by the client does not match computed one`, {
+                                clientTxHash,
+                                computedTxHash: txHash
+                            });
+                        }
+                        logger.info(`Sent previously delayed tx ${clientTxHash} to land on ${inspect(waitUntil)}`);
+                        delayer.txs.push(clientTxHash);
+                    }).catch((err)=>logger.error(`Error sending tx after delay`, err));
+                    return Promise.resolve(txHash);
+                } else {
+                    const txHash = await client.sendRawTransaction(...args);
+                    logger.verbose(`Sent tx immediately ${txHash}`);
+                    delayer.txs.push(txHash);
+                    return txHash;
+                }
+            }
+        }))// Re-extend with sendTransaction so it uses the modified sendRawTransaction.
+    .extend((client)=>({
+            sendTransaction: walletActions(client).sendTransaction
+        }))// And with the actions that depend on the modified sendTransaction
+    .extend((client)=>({
+            writeContract: walletActions(client).writeContract,
+            deployContract: walletActions(client).deployContract
+        }));
+    return {
+        client: extended,
+        delayer
+    };
+}

package/dest/test/upgrade_utils.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '@aztec/foundation/log';
+import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+import { type GetContractReturnType, type PrivateKeyAccount } from 'viem';
+import type { L1ContractAddresses } from '../l1_contract_addresses.js';
+import type { L1Clients } from '../types.js';
+export declare function executeGovernanceProposal(proposalId: bigint, governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>, voteAmount: bigint, privateKey: PrivateKeyAccount, publicClient: L1Clients['publicClient'], walletClient: L1Clients['walletClient'], rpcUrls: string[], logger: Logger): Promise<void>;
+export declare function createGovernanceProposal(payloadAddress: `0x${string}`, addresses: L1ContractAddresses, privateKey: PrivateKeyAccount, publicClient: L1Clients['publicClient'], logger: Logger): Promise<{
+    governance: GetContractReturnType<typeof GovernanceAbi, L1Clients['publicClient']>;
+    voteAmount: bigint;
+}>;
+//# sourceMappingURL=upgrade_utils.d.ts.map

package/dest/test/upgrade_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade_utils.d.ts","sourceRoot":"","sources":["../../src/test/upgrade_utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,iBAAiB,EAAe,MAAM,MAAM,CAAC;AAGvF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,qBAAqB,CAAC,OAAO,aAAa,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC,EAClF,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,iBAAiB,EAC7B,YAAY,EAAE,SAAS,CAAC,cAAc,CAAC,EACvC,YAAY,EAAE,SAAS,CAAC,cAAc,CAAC,EACvC,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,MAAM,iBAoCf;AAED,wBAAsB,wBAAwB,CAC5C,cAAc,EAAE,KAAK,MAAM,EAAE,EAC7B,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,iBAAiB,EAC7B,YAAY,EAAE,SAAS,CAAC,cAAc,CAAC,EACvC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC;IAAE,UAAU,EAAE,qBAAqB,CAAC,OAAO,aAAa,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAqCrH"}

package/dest/test/upgrade_utils.js

@@ -0,0 +1,104 @@
+import { TestERC20Abi as FeeJuiceAbi } from '@aztec/l1-artifacts';
+import { GovernanceAbi } from '@aztec/l1-artifacts/GovernanceAbi';
+import { getContract } from 'viem';
+import { EthCheatCodes } from '../eth_cheat_codes.js';
+export async function executeGovernanceProposal(proposalId, governance, voteAmount, privateKey, publicClient, walletClient, rpcUrls, logger) {
+    const proposal = await governance.read.getProposal([
+        proposalId
+    ]);
+    const waitL1Block = async ()=>{
+        await publicClient.waitForTransactionReceipt({
+            hash: await walletClient.sendTransaction({
+                to: privateKey.address,
+                value: 1n,
+                account: privateKey
+            })
+        });
+    };
+    const cheatCodes = new EthCheatCodes(rpcUrls, logger);
+    const timeToActive = proposal.creation + proposal.config.votingDelay;
+    logger.info(`Warping to ${timeToActive + 1n}`);
+    await cheatCodes.warp(Number(timeToActive + 1n));
+    logger.info(`Warped to ${timeToActive + 1n}`);
+    await waitL1Block();
+    logger.info(`Voting`);
+    const voteTx = await governance.write.vote([
+        proposalId,
+        voteAmount,
+        true
+    ], {
+        account: privateKey
+    });
+    await publicClient.waitForTransactionReceipt({
+        hash: voteTx
+    });
+    logger.info(`Voted`);
+    const timeToExecutable = timeToActive + proposal.config.votingDuration + proposal.config.executionDelay + 1n;
+    logger.info(`Warping to ${timeToExecutable}`);
+    await cheatCodes.warp(Number(timeToExecutable));
+    logger.info(`Warped to ${timeToExecutable}`);
+    await waitL1Block();
+    const executeTx = await governance.write.execute([
+        proposalId
+    ], {
+        account: privateKey
+    });
+    await publicClient.waitForTransactionReceipt({
+        hash: executeTx
+    });
+    logger.info(`Executed proposal`);
+}
+export async function createGovernanceProposal(payloadAddress, addresses, privateKey, publicClient, logger) {
+    const token = getContract({
+        address: addresses.feeJuiceAddress.toString(),
+        abi: FeeJuiceAbi,
+        client: publicClient
+    });
+    const governance = getContract({
+        address: addresses.governanceAddress.toString(),
+        abi: GovernanceAbi,
+        client: publicClient
+    });
+    const lockAmount = 10000n * 10n ** 18n;
+    const voteAmount = 10000n * 10n ** 18n;
+    const mintTx = await token.write.mint([
+        privateKey.address,
+        lockAmount + voteAmount
+    ], {
+        account: privateKey
+    });
+    await publicClient.waitForTransactionReceipt({
+        hash: mintTx
+    });
+    logger.info(`Minted tokens`);
+    const approveTx = await token.write.approve([
+        addresses.governanceAddress.toString(),
+        lockAmount + voteAmount
+    ], {
+        account: privateKey
+    });
+    await publicClient.waitForTransactionReceipt({
+        hash: approveTx
+    });
+    logger.info(`Approved tokens`);
+    const depositTx = await governance.write.deposit([
+        privateKey.address,
+        lockAmount + voteAmount
+    ], {
+        account: privateKey
+    });
+    await publicClient.waitForTransactionReceipt({
+        hash: depositTx
+    });
+    logger.info(`Deposited tokens`);
+    await governance.write.proposeWithLock([
+        payloadAddress,
+        privateKey.address
+    ], {
+        account: privateKey
+    });
+    return {
+        governance,
+        voteAmount
+    };
+}

package/dest/types.d.ts

@@ -0,0 +1,14 @@
+import type { Account, Chain, Client, FallbackTransport, 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 ExtendedViemWalletClient = Client<FallbackTransport<readonly HttpTransport[]>, Chain, Account, [
+    ...PublicRpcSchema,
+    ...WalletRpcSchema
+], PublicActions<FallbackTransport<readonly HttpTransport[]>, Chain> & WalletActions<Chain, Account>>;
+export type ViemWalletClient = SimpleViemWalletClient | ExtendedViemWalletClient;
+export type L1Clients = {
+    publicClient: ViemPublicClient;
+    walletClient: ExtendedViemWalletClient;
+};
+//# sourceMappingURL=types.d.ts.map

package/dest/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,eAAe,EAChB,MAAM,MAAM,CAAC;AAEd,oCAAoC;AACpC,MAAM,MAAM,gBAAgB,GAAG,YAAY,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;AAEvF,MAAM,MAAM,sBAAsB,GAAG,YAAY,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;AAEtG,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAC3C,iBAAiB,CAAC,SAAS,aAAa,EAAE,CAAC,EAC3C,KAAK,EACL,OAAO,EACP;IAAC,GAAG,eAAe;IAAE,GAAG,eAAe;CAAC,EACxC,aAAa,CAAC,iBAAiB,CAAC,SAAS,aAAa,EAAE,CAAC,EAAE,KAAK,CAAC,GAAG,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAClG,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,sBAAsB,GAAG,wBAAwB,CAAC;AAEjF,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,YAAY,EAAE,wBAAwB,CAAC;CACxC,CAAC"}

package/dest/types.js

@@ -0,0 +1 @@
+export { };

package/dest/utils.d.ts

@@ -0,0 +1,24 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { Logger } from '@aztec/foundation/log';
+import { type Abi, type ContractEventName, type DecodeEventLogReturnType, type Hex, type Log } from 'viem';
+export interface L2Claim {
+    claimSecret: Fr;
+    claimAmount: Fr;
+    messageHash: Hex;
+    messageLeafIndex: bigint;
+}
+export declare class FormattedViemError extends Error {
+    metaMessages?: any[];
+    constructor(message: string, metaMessages?: any[]);
+}
+export declare function extractEvent<const TAbi extends Abi | readonly unknown[], TEventName extends ContractEventName<TAbi>, TEventType = DecodeEventLogReturnType<TAbi, TEventName, Hex[], undefined, true>>(logs: Log[], address: Hex, abi: TAbi, eventName: TEventName, filter?: (log: TEventType) => boolean, logger?: Logger): TEventType;
+export declare function prettyLogViemErrorMsg(err: any): any;
+/**
+ * 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 declare function formatViemError(error: any, abi?: Abi): FormattedViemError;
+export declare function tryGetCustomErrorName(err: any): string | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/dest/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAGpD,OAAO,EACL,KAAK,GAAG,EAER,KAAK,iBAAiB,EAEtB,KAAK,wBAAwB,EAC7B,KAAK,GAAG,EACR,KAAK,GAAG,EAGT,MAAM,MAAM,CAAC;AAEd,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,EAAE,CAAC;IAChB,WAAW,EAAE,GAAG,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,CAAC,EAAE,GAAG,EAAE,CAAC;gBAET,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,GAAG,EAAE;CAKlD;AAED,wBAAgB,YAAY,CAC1B,KAAK,CAAC,IAAI,SAAS,GAAG,GAAG,SAAS,OAAO,EAAE,EAC3C,UAAU,SAAS,iBAAiB,CAAC,IAAI,CAAC,EAC1C,UAAU,GAAG,wBAAwB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,EAE/E,IAAI,EAAE,GAAG,EAAE,EACX,OAAO,EAAE,GAAG,EACZ,GAAG,EAAE,IAAI,EACT,SAAS,EAAE,UAAU,EACrB,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,OAAO,EACrC,MAAM,CAAC,EAAE,MAAM,GACd,UAAU,CAMZ;AA+BD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,OAW7C;AA0BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,GAAE,GAAe,GAAG,kBAAkB,CAwIpF;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,GAAG,sBAa7C"}