@aztec/ethereum 0.65.1 → 0.66.0

package/dest/l1_tx_utils.js

@@ -0,0 +1,253 @@
+import { bigintConfigHelper, getDefaultConfig, numberConfigHelper, } from '@aztec/foundation/config';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { sleep } from '@aztec/foundation/sleep';
+import { formatGwei, } from 'viem';
+// 1_000_000_000 Gwei = 1 ETH
+// 1_000_000_000 Wei = 1 Gwei
+// 1_000_000_000_000_000_000 Wei = 1 ETH
+const WEI_CONST = 1000000000n;
+// setting a minimum bump percentage to 10% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298
+const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10n;
+// Avg ethereum block time is ~12s
+const BLOCK_TIME_MS = 12000;
+export const l1TxUtilsConfigMappings = {
+    gasLimitBufferPercentage: {
+        description: 'How much to increase gas price by each attempt (percentage)',
+        env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
+        ...bigintConfigHelper(20n),
+    },
+    minGwei: {
+        description: 'Minimum gas price in gwei',
+        env: 'L1_GAS_PRICE_MIN',
+        ...bigintConfigHelper(1n),
+    },
+    maxGwei: {
+        description: 'Maximum gas price in gwei',
+        env: 'L1_GAS_PRICE_MAX',
+        ...bigintConfigHelper(100n),
+    },
+    priorityFeeBumpPercentage: {
+        description: 'How much to increase priority fee by each attempt (percentage)',
+        env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
+        ...bigintConfigHelper(20n),
+    },
+    priorityFeeRetryBumpPercentage: {
+        description: 'How much to increase priority fee by each retry attempt (percentage)',
+        env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
+        ...bigintConfigHelper(50n),
+    },
+    maxAttempts: {
+        description: 'Maximum number of speed-up attempts',
+        env: 'L1_TX_MONITOR_MAX_ATTEMPTS',
+        ...numberConfigHelper(3),
+    },
+    checkIntervalMs: {
+        description: 'How often to check tx status',
+        env: 'L1_TX_MONITOR_CHECK_INTERVAL_MS',
+        ...numberConfigHelper(10000),
+    },
+    stallTimeMs: {
+        description: 'How long before considering tx stalled',
+        env: 'L1_TX_MONITOR_STALL_TIME_MS',
+        ...numberConfigHelper(30000),
+    },
+    txTimeoutMs: {
+        description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
+        env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
+        ...numberConfigHelper(300000), // 5 mins
+    },
+};
+export const defaultL1TxUtilsConfig = getDefaultConfig(l1TxUtilsConfigMappings);
+export class L1TxUtils {
+    constructor(publicClient, walletClient, logger, config) {
+        this.publicClient = publicClient;
+        this.walletClient = walletClient;
+        this.logger = logger;
+        this.config = {
+            ...defaultL1TxUtilsConfig,
+            ...(config || {}),
+        };
+    }
+    /**
+     * Sends a transaction with gas estimation and pricing
+     * @param request - The transaction request (to, data, value)
+     * @param gasConfig - Optional gas configuration
+     * @returns The transaction hash and parameters used
+     */
+    async sendTransaction(request, _gasConfig) {
+        const gasConfig = { ...this.config, ..._gasConfig };
+        const account = this.walletClient.account;
+        let gasLimit;
+        if (gasConfig.fixedGas) {
+            gasLimit = gasConfig.fixedGas;
+        }
+        else {
+            gasLimit = await this.estimateGas(account, request);
+        }
+        const gasPrice = await this.getGasPrice(gasConfig);
+        const txHash = await this.walletClient.sendTransaction({
+            ...request,
+            gas: gasLimit,
+            maxFeePerGas: gasPrice.maxFeePerGas,
+            maxPriorityFeePerGas: gasPrice.maxPriorityFeePerGas,
+        });
+        this.logger?.verbose(`Sent L1 transaction ${txHash} with gas limit ${gasLimit} and price ${formatGwei(gasPrice.maxFeePerGas)} gwei`);
+        return { txHash, gasLimit, gasPrice };
+    }
+    /**
+     * Monitors a transaction until completion, handling speed-ups if needed
+     * @param request - Original transaction request (needed for speed-ups)
+     * @param initialTxHash - Hash of the initial transaction
+     * @param params - Parameters used in the initial transaction
+     * @param gasConfig - Optional gas configuration
+     */
+    async monitorTransaction(request, initialTxHash, params, _gasConfig) {
+        const gasConfig = { ...this.config, ..._gasConfig };
+        const account = this.walletClient.account;
+        // Retry a few times, in case the tx is not yet propagated.
+        const tx = await retry(() => this.publicClient.getTransaction({ hash: initialTxHash }), `Getting L1 transaction ${initialTxHash}`, makeBackoff([1, 2, 3]), this.logger, true);
+        if (tx?.nonce === undefined || tx?.nonce === null) {
+            throw new Error(`Failed to get L1 transaction ${initialTxHash} nonce`);
+        }
+        const nonce = tx.nonce;
+        const txHashes = new Set([initialTxHash]);
+        let currentTxHash = initialTxHash;
+        let attempts = 0;
+        let lastAttemptSent = Date.now();
+        const initialTxTime = lastAttemptSent;
+        let txTimedOut = false;
+        while (!txTimedOut) {
+            try {
+                const currentNonce = await this.publicClient.getTransactionCount({ address: account.address });
+                if (currentNonce > nonce) {
+                    for (const hash of txHashes) {
+                        try {
+                            const receipt = await this.publicClient.getTransactionReceipt({ hash });
+                            if (receipt) {
+                                this.logger?.debug(`L1 Transaction ${hash} confirmed`);
+                                if (receipt.status === 'reverted') {
+                                    this.logger?.error(`L1 Transaction ${hash} reverted`);
+                                }
+                                return receipt;
+                            }
+                        }
+                        catch (err) {
+                            if (err instanceof Error && err.message.includes('reverted')) {
+                                throw err;
+                            }
+                        }
+                    }
+                }
+                // Retry a few times, in case the tx is not yet propagated.
+                const tx = await retry(() => this.publicClient.getTransaction({ hash: currentTxHash }), `Getting L1 transaction ${currentTxHash}`, makeBackoff([1, 2, 3]), this.logger, true);
+                const timePassed = Date.now() - lastAttemptSent;
+                if (tx && timePassed < gasConfig.stallTimeMs) {
+                    this.logger?.debug(`L1 Transaction ${currentTxHash} pending. Time passed: ${timePassed}ms`);
+                    // Check timeout before continuing
+                    if (gasConfig.txTimeoutMs) {
+                        txTimedOut = Date.now() - initialTxTime > gasConfig.txTimeoutMs;
+                        if (txTimedOut) {
+                            break;
+                        }
+                    }
+                    await sleep(gasConfig.checkIntervalMs);
+                    continue;
+                }
+                if (timePassed > gasConfig.stallTimeMs && attempts < gasConfig.maxAttempts) {
+                    attempts++;
+                    const newGasPrice = await this.getGasPrice(gasConfig, attempts, tx.maxFeePerGas && tx.maxPriorityFeePerGas
+                        ? { maxFeePerGas: tx.maxFeePerGas, maxPriorityFeePerGas: tx.maxPriorityFeePerGas }
+                        : undefined);
+                    this.logger?.debug(`L1 Transaction ${currentTxHash} appears stuck. Attempting speed-up ${attempts}/${gasConfig.maxAttempts} ` +
+                        `with new priority fee ${formatGwei(newGasPrice.maxPriorityFeePerGas)} gwei`);
+                    currentTxHash = await this.walletClient.sendTransaction({
+                        ...request,
+                        nonce,
+                        gas: params.gasLimit,
+                        maxFeePerGas: newGasPrice.maxFeePerGas,
+                        maxPriorityFeePerGas: newGasPrice.maxPriorityFeePerGas,
+                    });
+                    txHashes.add(currentTxHash);
+                    lastAttemptSent = Date.now();
+                }
+                await sleep(gasConfig.checkIntervalMs);
+            }
+            catch (err) {
+                this.logger?.warn(`Error monitoring tx ${currentTxHash}:`, err);
+                if (err.message?.includes('reverted')) {
+                    throw err;
+                }
+                await sleep(gasConfig.checkIntervalMs);
+            }
+            // Check if tx has timed out.
+            if (gasConfig.txTimeoutMs) {
+                txTimedOut = Date.now() - initialTxTime > gasConfig.txTimeoutMs;
+            }
+        }
+        throw new Error(`L1 Transaction ${currentTxHash} timed out`);
+    }
+    /**
+     * Sends a transaction and monitors it until completion
+     * @param request - The transaction request (to, data, value)
+     * @param gasConfig - Optional gas configuration
+     * @returns The receipt of the successful transaction
+     */
+    async sendAndMonitorTransaction(request, gasConfig) {
+        const { txHash, gasLimit } = await this.sendTransaction(request, gasConfig);
+        return this.monitorTransaction(request, txHash, { gasLimit }, gasConfig);
+    }
+    /**
+     * Gets the current gas price with bounds checking
+     */
+    async getGasPrice(_gasConfig, attempt = 0, previousGasPrice) {
+        const gasConfig = { ...this.config, ..._gasConfig };
+        const block = await this.publicClient.getBlock({ blockTag: 'latest' });
+        const baseFee = block.baseFeePerGas ?? 0n;
+        // Get initial priority fee from the network
+        let priorityFee = await this.publicClient.estimateMaxPriorityFeePerGas();
+        let maxFeePerGas = baseFee;
+        // Bump base fee so it's valid for next blocks if it stalls
+        const numBlocks = Math.ceil(gasConfig.stallTimeMs / BLOCK_TIME_MS);
+        for (let i = 0; i < numBlocks; i++) {
+            // each block can go up 12.5% from previous baseFee
+            maxFeePerGas = (maxFeePerGas * (1000n + 125n)) / 1000n;
+        }
+        if (attempt > 0) {
+            const configBump = gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage;
+            const bumpPercentage = configBump > MIN_REPLACEMENT_BUMP_PERCENTAGE ? configBump : MIN_REPLACEMENT_BUMP_PERCENTAGE;
+            // Calculate minimum required fees based on previous attempt
+            const minPriorityFee = (previousGasPrice.maxPriorityFeePerGas * (100n + bumpPercentage)) / 100n;
+            const minMaxFee = (previousGasPrice.maxFeePerGas * (100n + bumpPercentage)) / 100n;
+            // Add priority fee to maxFeePerGas
+            maxFeePerGas += priorityFee;
+            // Use maximum between current network values and minimum required values
+            priorityFee = priorityFee > minPriorityFee ? priorityFee : minPriorityFee;
+            maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
+        }
+        else {
+            // first attempt, just bump priority fee
+            priorityFee = (priorityFee * (100n + (gasConfig.priorityFeeBumpPercentage || 0n))) / 100n;
+            maxFeePerGas += priorityFee;
+        }
+        // Ensure we don't exceed maxGwei
+        const maxGweiInWei = gasConfig.maxGwei * WEI_CONST;
+        maxFeePerGas = maxFeePerGas > maxGweiInWei ? maxGweiInWei : maxFeePerGas;
+        // Ensure priority fee doesn't exceed max fee
+        const maxPriorityFeePerGas = priorityFee > maxFeePerGas ? maxFeePerGas : priorityFee;
+        this.logger?.debug(`Gas price calculation (attempt ${attempt}): baseFee=${formatGwei(baseFee)}, ` +
+            `maxPriorityFee=${formatGwei(maxPriorityFeePerGas)}, maxFee=${formatGwei(maxFeePerGas)}`);
+        return { maxFeePerGas, maxPriorityFeePerGas };
+    }
+    /**
+     * Estimates gas and adds buffer
+     */
+    async estimateGas(account, request, _gasConfig) {
+        const gasConfig = { ...this.config, ..._gasConfig };
+        const initialEstimate = await this.publicClient.estimateGas({ account, ...request });
+        // Add buffer based on either fixed amount or percentage
+        const withBuffer = initialEstimate + (initialEstimate * (gasConfig.gasLimitBufferPercentage ?? 0n)) / 100n;
+        return withBuffer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"l1_tx_utils.js","sourceRoot":"","sources":["../src/l1_tx_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,OAAO,EAUL,UAAU,GACX,MAAM,MAAM,CAAC;AAEd,6BAA6B;AAC7B,6BAA6B;AAC7B,wCAAwC;AAExC,MAAM,SAAS,GAAG,WAAc,CAAC;AAEjC,wEAAwE;AACxE,4HAA4H;AAC5H,MAAM,+BAA+B,GAAG,GAAG,CAAC;AAE5C,kCAAkC;AAClC,MAAM,aAAa,GAAG,KAAM,CAAC;AAyC7B,MAAM,CAAC,MAAM,uBAAuB,GAAwC;IAC1E,wBAAwB,EAAE;QACxB,WAAW,EAAE,6DAA6D;QAC1E,GAAG,EAAE,gCAAgC;QACrC,GAAG,kBAAkB,CAAC,GAAG,CAAC;KAC3B;IACD,OAAO,EAAE;QACP,WAAW,EAAE,2BAA2B;QACxC,GAAG,EAAE,kBAAkB;QACvB,GAAG,kBAAkB,CAAC,EAAE,CAAC;KAC1B;IACD,OAAO,EAAE;QACP,WAAW,EAAE,2BAA2B;QACxC,GAAG,EAAE,kBAAkB;QACvB,GAAG,kBAAkB,CAAC,IAAI,CAAC;KAC5B;IACD,yBAAyB,EAAE;QACzB,WAAW,EAAE,gEAAgE;QAC7E,GAAG,EAAE,iCAAiC;QACtC,GAAG,kBAAkB,CAAC,GAAG,CAAC;KAC3B;IACD,8BAA8B,EAAE;QAC9B,WAAW,EAAE,sEAAsE;QACnF,GAAG,EAAE,uCAAuC;QAC5C,GAAG,kBAAkB,CAAC,GAAG,CAAC;KAC3B;IACD,WAAW,EAAE;QACX,WAAW,EAAE,qCAAqC;QAClD,GAAG,EAAE,4BAA4B;QACjC,GAAG,kBAAkB,CAAC,CAAC,CAAC;KACzB;IACD,eAAe,EAAE;QACf,WAAW,EAAE,8BAA8B;QAC3C,GAAG,EAAE,iCAAiC;QACtC,GAAG,kBAAkB,CAAC,KAAM,CAAC;KAC9B;IACD,WAAW,EAAE;QACX,WAAW,EAAE,wCAAwC;QACrD,GAAG,EAAE,6BAA6B;QAClC,GAAG,kBAAkB,CAAC,KAAM,CAAC;KAC9B;IACD,WAAW,EAAE;QACX,WAAW,EAAE,8EAA8E;QAC3F,GAAG,EAAE,6BAA6B;QAClC,GAAG,kBAAkB,CAAC,MAAO,CAAC,EAAE,SAAS;KAC1C;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,gBAAgB,CAAkB,uBAAuB,CAAC,CAAC;AAajG,MAAM,OAAO,SAAS;IAGpB,YACmB,YAA0B,EAC1B,YAAyD,EACzD,MAAoB,EACrC,MAAiC;QAHhB,iBAAY,GAAZ,YAAY,CAAc;QAC1B,iBAAY,GAAZ,YAAY,CAA6C;QACzD,WAAM,GAAN,MAAM,CAAc;QAGrC,IAAI,CAAC,MAAM,GAAG;YACZ,GAAG,sBAAsB;YACzB,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC;SAClB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,eAAe,CAC1B,OAAoB,EACpB,UAA6D;QAE7D,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAC1C,IAAI,QAAgB,CAAC;QAErB,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;YACvB,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;QAChC,CAAC;aAAM,CAAC;YACN,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QACtD,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QAEnD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;YACrD,GAAG,OAAO;YACV,GAAG,EAAE,QAAQ;YACb,YAAY,EAAE,QAAQ,CAAC,YAAY;YACnC,oBAAoB,EAAE,QAAQ,CAAC,oBAAoB;SACpD,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,EAAE,OAAO,CAClB,uBAAuB,MAAM,mBAAmB,QAAQ,cAAc,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,CAC/G,CAAC;QAEF,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACxC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,kBAAkB,CAC7B,OAAoB,EACpB,aAAkB,EAClB,MAA4B,EAC5B,UAAqC;QAErC,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC;QAE1C,2DAA2D;QAC3D,MAAM,EAAE,GAAG,MAAM,KAAK,CACpB,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,EAC/D,0BAA0B,aAAa,EAAE,EACzC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EACtB,IAAI,CAAC,MAAM,EACX,IAAI,CACL,CAAC;QAEF,IAAI,EAAE,EAAE,KAAK,KAAK,SAAS,IAAI,EAAE,EAAE,KAAK,KAAK,IAAI,EAAE,CAAC;YAClD,MAAM,IAAI,KAAK,CAAC,gCAAgC,aAAa,QAAQ,CAAC,CAAC;QACzE,CAAC;QACD,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC;QAEvB,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAM,CAAC,aAAa,CAAC,CAAC,CAAC;QAC/C,IAAI,aAAa,GAAG,aAAa,CAAC;QAClC,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,IAAI,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACjC,MAAM,aAAa,GAAG,eAAe,CAAC;QACtC,IAAI,UAAU,GAAG,KAAK,CAAC;QAEvB,OAAO,CAAC,UAAU,EAAE,CAAC;YACnB,IAAI,CAAC;gBACH,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,mBAAmB,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;gBAC/F,IAAI,YAAY,GAAG,KAAK,EAAE,CAAC;oBACzB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;wBAC5B,IAAI,CAAC;4BACH,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;4BACxE,IAAI,OAAO,EAAE,CAAC;gCACZ,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,IAAI,YAAY,CAAC,CAAC;gCACvD,IAAI,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;oCAClC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,IAAI,WAAW,CAAC,CAAC;gCACxD,CAAC;gCACD,OAAO,OAAO,CAAC;4BACjB,CAAC;wBACH,CAAC;wBAAC,OAAO,GAAG,EAAE,CAAC;4BACb,IAAI,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;gCAC7D,MAAM,GAAG,CAAC;4BACZ,CAAC;wBACH,CAAC;oBACH,CAAC;gBACH,CAAC;gBAED,2DAA2D;gBAC3D,MAAM,EAAE,GAAG,MAAM,KAAK,CACpB,GAAG,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,EAC/D,0BAA0B,aAAa,EAAE,EACzC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EACtB,IAAI,CAAC,MAAM,EACX,IAAI,CACL,CAAC;gBACF,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,CAAC;gBAEhD,IAAI,EAAE,IAAI,UAAU,GAAG,SAAS,CAAC,WAAY,EAAE,CAAC;oBAC9C,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,kBAAkB,aAAa,0BAA0B,UAAU,IAAI,CAAC,CAAC;oBAE5F,kCAAkC;oBAClC,IAAI,SAAS,CAAC,WAAW,EAAE,CAAC;wBAC1B,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,aAAa,GAAG,SAAS,CAAC,WAAW,CAAC;wBAChE,IAAI,UAAU,EAAE,CAAC;4BACf,MAAM;wBACR,CAAC;oBACH,CAAC;oBAED,MAAM,KAAK,CAAC,SAAS,CAAC,eAAgB,CAAC,CAAC;oBACxC,SAAS;gBACX,CAAC;gBAED,IAAI,UAAU,GAAG,SAAS,CAAC,WAAY,IAAI,QAAQ,GAAG,SAAS,CAAC,WAAY,EAAE,CAAC;oBAC7E,QAAQ,EAAE,CAAC;oBACX,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,WAAW,CACxC,SAAS,EACT,QAAQ,EACR,EAAE,CAAC,YAAY,IAAI,EAAE,CAAC,oBAAoB;wBACxC,CAAC,CAAC,EAAE,YAAY,EAAE,EAAE,CAAC,YAAY,EAAE,oBAAoB,EAAE,EAAE,CAAC,oBAAoB,EAAE;wBAClF,CAAC,CAAC,SAAS,CACd,CAAC;oBAEF,IAAI,CAAC,MAAM,EAAE,KAAK,CAChB,kBAAkB,aAAa,uCAAuC,QAAQ,IAAI,SAAS,CAAC,WAAW,GAAG;wBACxG,yBAAyB,UAAU,CAAC,WAAW,CAAC,oBAAoB,CAAC,OAAO,CAC/E,CAAC;oBAEF,aAAa,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;wBACtD,GAAG,OAAO;wBACV,KAAK;wBACL,GAAG,EAAE,MAAM,CAAC,QAAQ;wBACpB,YAAY,EAAE,WAAW,CAAC,YAAY;wBACtC,oBAAoB,EAAE,WAAW,CAAC,oBAAoB;qBACvD,CAAC,CAAC;oBAEH,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;oBAC5B,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAC/B,CAAC;gBACD,MAAM,KAAK,CAAC,SAAS,CAAC,eAAgB,CAAC,CAAC;YAC1C,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAClB,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,uBAAuB,aAAa,GAAG,EAAE,GAAG,CAAC,CAAC;gBAChE,IAAI,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;oBACtC,MAAM,GAAG,CAAC;gBACZ,CAAC;gBACD,MAAM,KAAK,CAAC,SAAS,CAAC,eAAgB,CAAC,CAAC;YAC1C,CAAC;YACD,6BAA6B;YAC7B,IAAI,SAAS,CAAC,WAAW,EAAE,CAAC;gBAC1B,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,aAAa,GAAG,SAAS,CAAC,WAAY,CAAC;YACnE,CAAC;QACH,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,kBAAkB,aAAa,YAAY,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,yBAAyB,CACpC,OAAoB,EACpB,SAA4D;QAE5D,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC;IAC3E,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,WAAW,CACvB,UAA4B,EAC5B,UAAkB,CAAC,EACnB,gBAA8D;QAE9D,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC,CAAC;QACvE,MAAM,OAAO,GAAG,KAAK,CAAC,aAAa,IAAI,EAAE,CAAC;QAE1C,4CAA4C;QAC5C,IAAI,WAAW,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,4BAA4B,EAAE,CAAC;QACzE,IAAI,YAAY,GAAG,OAAO,CAAC;QAE3B,2DAA2D;QAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,WAAY,GAAG,aAAa,CAAC,CAAC;QACpE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;YACnC,mDAAmD;YACnD,YAAY,GAAG,CAAC,YAAY,GAAG,CAAC,KAAM,GAAG,IAAI,CAAC,CAAC,GAAG,KAAM,CAAC;QAC3D,CAAC;QAED,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YAChB,MAAM,UAAU,GACd,SAAS,CAAC,8BAA8B,IAAI,sBAAsB,CAAC,8BAA+B,CAAC;YACrG,MAAM,cAAc,GAClB,UAAU,GAAG,+BAA+B,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,+BAA+B,CAAC;YAE9F,4DAA4D;YAC5D,MAAM,cAAc,GAAG,CAAC,gBAAiB,CAAC,oBAAoB,GAAG,CAAC,IAAI,GAAG,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC;YACjG,MAAM,SAAS,GAAG,CAAC,gBAAiB,CAAC,YAAY,GAAG,CAAC,IAAI,GAAG,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC;YAEpF,mCAAmC;YACnC,YAAY,IAAI,WAAW,CAAC;YAE5B,yEAAyE;YACzE,WAAW,GAAG,WAAW,GAAG,cAAc,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC;YAC1E,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC;QACrE,CAAC;aAAM,CAAC;YACN,wCAAwC;YACxC,WAAW,GAAG,CAAC,WAAW,GAAG,CAAC,IAAI,GAAG,CAAC,SAAS,CAAC,yBAAyB,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YAC1F,YAAY,IAAI,WAAW,CAAC;QAC9B,CAAC;QAED,iCAAiC;QACjC,MAAM,YAAY,GAAG,SAAS,CAAC,OAAQ,GAAG,SAAS,CAAC;QACpD,YAAY,GAAG,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC;QAEzE,6CAA6C;QAC7C,MAAM,oBAAoB,GAAG,WAAW,GAAG,YAAY,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC;QAErF,IAAI,CAAC,MAAM,EAAE,KAAK,CAChB,kCAAkC,OAAO,cAAc,UAAU,CAAC,OAAO,CAAC,IAAI;YAC5E,kBAAkB,UAAU,CAAC,oBAAoB,CAAC,YAAY,UAAU,CAAC,YAAY,CAAC,EAAE,CAC3F,CAAC;QAEF,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,WAAW,CAAC,OAAgB,EAAE,OAAoB,EAAE,UAA4B;QAC3F,MAAM,SAAS,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,UAAU,EAAE,CAAC;QACpD,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;QAErF,wDAAwD;QACxD,MAAM,UAAU,GAAG,eAAe,GAAG,CAAC,eAAe,GAAG,CAAC,SAAS,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;QAE3G,OAAO,UAAU,CAAC;IACpB,CAAC;CACF"}

package/dest/utils.js

@@ -8,7 +8,7 @@ export function extractEvent(logs, address, abi, eventName, filter, logger) {
 }
 function tryExtractEvent(logs, address, abi, eventName, filter, logger) {
     for (const log of logs) {
-        if (log.address === address) {
+        if (log.address.toLowerCase() === address.toLowerCase()) {
             try {
                 const decodedEvent = decodeEventLog({ abi, ...log });
                 if (decodedEvent.eventName === eventName) {
@@ -24,4 +24,4 @@ function tryExtractEvent(logs, address, abi, eventName, filter, logger) {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQU1MLGNBQWMsR0FDZixNQUFNLE1BQU0sQ0FBQztBQVNkLE1BQU0sVUFBVSxZQUFZLENBSzFCLElBQVcsRUFDWCxPQUFZLEVBQ1osR0FBUyxFQUNULFNBQXFCLEVBQ3JCLE1BQXFDLEVBQ3JDLE1BQW9CO0lBRXBCLE1BQU0sS0FBSyxHQUFHLGVBQWUsQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzdFLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLFNBQVMsaUJBQWlCLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDeEYsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQztBQUVELFNBQVMsZUFBZSxDQUt0QixJQUFXLEVBQ1gsT0FBWSxFQUNaLEdBQVMsRUFDVCxTQUFxQixFQUNyQixNQUFxQyxFQUNyQyxNQUFvQjtJQUVwQixLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ3ZCLElBQUksR0FBRyxDQUFDLE9BQU8sS0FBSyxPQUFPLEVBQUUsQ0FBQztZQUM1QixJQUFJLENBQUM7Z0JBQ0gsTUFBTSxZQUFZLEdBQUcsY0FBYyxDQUFDLEVBQUUsR0FBRyxFQUFFLEdBQUcsR0FBRyxFQUFFLENBQUMsQ0FBQztnQkFDckQsSUFBSSxZQUFZLENBQUMsU0FBUyxLQUFLLFNBQVMsRUFBRSxDQUFDO29CQUN6QyxNQUFNLGFBQWEsR0FBRyxZQUEwQixDQUFDO29CQUNqRCxJQUFJLENBQUMsTUFBTSxJQUFJLE1BQU0sQ0FBQyxhQUFhLENBQUMsRUFBRSxDQUFDO3dCQUNyQyxPQUFPLGFBQWEsQ0FBQztvQkFDdkIsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztZQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7Z0JBQ2IsTUFBTSxFQUFFLElBQUksQ0FBQywyQ0FBMkMsT0FBTyxLQUFLLEdBQUcsRUFBRSxDQUFDLENBQUM7WUFDN0UsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQU1MLGNBQWMsR0FDZixNQUFNLE1BQU0sQ0FBQztBQVNkLE1BQU0sVUFBVSxZQUFZLENBSzFCLElBQVcsRUFDWCxPQUFZLEVBQ1osR0FBUyxFQUNULFNBQXFCLEVBQ3JCLE1BQXFDLEVBQ3JDLE1BQW9CO0lBRXBCLE1BQU0sS0FBSyxHQUFHLGVBQWUsQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzdFLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsaUNBQWlDLFNBQVMsaUJBQWlCLE9BQU8sRUFBRSxDQUFDLENBQUM7SUFDeEYsQ0FBQztJQUNELE9BQU8sS0FBSyxDQUFDO0FBQ2YsQ0FBQztBQUVELFNBQVMsZUFBZSxDQUt0QixJQUFXLEVBQ1gsT0FBWSxFQUNaLEdBQVMsRUFDVCxTQUFxQixFQUNyQixNQUFxQyxFQUNyQyxNQUFvQjtJQUVwQixLQUFLLE1BQU0sR0FBRyxJQUFJLElBQUksRUFBRSxDQUFDO1FBQ3ZCLElBQUksR0FBRyxDQUFDLE9BQU8sQ0FBQyxXQUFXLEVBQUUsS0FBSyxPQUFPLENBQUMsV0FBVyxFQUFFLEVBQUUsQ0FBQztZQUN4RCxJQUFJLENBQUM7Z0JBQ0gsTUFBTSxZQUFZLEdBQUcsY0FBYyxDQUFDLEVBQUUsR0FBRyxFQUFFLEdBQUcsR0FBRyxFQUFFLENBQUMsQ0FBQztnQkFDckQsSUFBSSxZQUFZLENBQUMsU0FBUyxLQUFLLFNBQVMsRUFBRSxDQUFDO29CQUN6QyxNQUFNLGFBQWEsR0FBRyxZQUEwQixDQUFDO29CQUNqRCxJQUFJLENBQUMsTUFBTSxJQUFJLE1BQU0sQ0FBQyxhQUFhLENBQUMsRUFBRSxDQUFDO3dCQUNyQyxPQUFPLGFBQWEsQ0FBQztvQkFDdkIsQ0FBQztnQkFDSCxDQUFDO1lBQ0gsQ0FBQztZQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7Z0JBQ2IsTUFBTSxFQUFFLElBQUksQ0FBQywyQ0FBMkMsT0FBTyxLQUFLLEdBQUcsRUFBRSxDQUFDLENBQUM7WUFDN0UsQ0FBQztRQUNILENBQUM7SUFDSCxDQUFDO0FBQ0gsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/ethereum",
-  "version": "0.65.1",
+  "version": "0.66.0",
   "type": "module",
   "exports": {
     ".": "./dest/index.js",
@@ -28,8 +28,8 @@
     "../package.common.json"
   ],
   "dependencies": {
-    "@aztec/foundation": "0.65.1",
-    "@aztec/l1-artifacts": "0.65.1",
+    "@aztec/foundation": "0.66.0",
+    "@aztec/l1-artifacts": "0.66.0",
     "@viem/anvil": "^0.0.10",
     "dotenv": "^16.0.3",
     "get-port": "^7.1.0",
@@ -41,6 +41,8 @@
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.14.6",
+    "@viem/anvil": "^0.0.10",
+    "get-port": "^7.1.0",
     "jest": "^29.5.0",
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4"

package/src/constants.ts

@@ -2,3 +2,4 @@ import { type Hex } from 'viem';
 
 export const NULL_KEY: Hex = `0x${'0000000000000000000000000000000000000000000000000000000000000000'}`;
 export const AZTEC_TEST_CHAIN_ID = 677692;
+export const MINIMUM_STAKE = BigInt(100e18);

package/src/contracts/rollup.ts

@@ -44,6 +44,26 @@ export class RollupContract {
     return this.rollup.read.getCurrentSlot();
   }
 
+  getCommitteeAt(timestamp: bigint) {
+    return this.rollup.read.getCommitteeAt([timestamp]);
+  }
+
+  getSampleSeedAt(timestamp: bigint) {
+    return this.rollup.read.getSampleSeedAt([timestamp]);
+  }
+
+  getCurrentSampleSeed() {
+    return this.rollup.read.getCurrentSampleSeed();
+  }
+
+  getCurrentEpochCommittee() {
+    return this.rollup.read.getCurrentEpochCommittee();
+  }
+
+  getCurrentProposer() {
+    return this.rollup.read.getCurrentProposer();
+  }
+
   async getEpochNumber(blockNumber?: bigint) {
     blockNumber ??= await this.getBlockNumber();
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);