@aztec/ethereum 3.0.0-nightly.20250925 → 3.0.0-nightly.20250927

package/dest/l1_tx_utils/l1_tx_utils.d.ts

@@ -0,0 +1,80 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { type Abi, type BlockOverrides, type Hex, type PrepareTransactionRequestRequest, type StateOverride, type TransactionReceipt } from 'viem';
+import type { ViemClient } from '../types.js';
+import { type L1TxUtilsConfig } from './config.js';
+import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
+import { type GasPrice, type L1BlobInputs, type L1GasConfig, type L1TxRequest, type SigningCallback, TxUtilsState } from './types.js';
+export declare class L1TxUtils extends ReadOnlyL1TxUtils {
+    client: ViemClient;
+    address: EthAddress;
+    protected signer: SigningCallback;
+    protected logger: Logger;
+    private txUtilsState;
+    private lastMinedBlockNumber;
+    private nonceManager;
+    constructor(client: ViemClient, address: EthAddress, signer: SigningCallback, logger?: Logger, dateProvider?: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean);
+    get state(): TxUtilsState;
+    get lastMinedAtBlockNumber(): bigint | undefined;
+    private set lastMinedAtBlockNumber(value);
+    private set state(value);
+    getSenderAddress(): EthAddress;
+    getSenderBalance(): Promise<bigint>;
+    private signTransaction;
+    protected prepareSignedTransaction(txData: PrepareTransactionRequestRequest): Promise<`0x${string}`>;
+    /**
+     * 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
+     */
+    sendTransaction(request: L1TxRequest, _gasConfig?: L1GasConfig, blobInputs?: L1BlobInputs, stateChange?: TxUtilsState): Promise<{
+        txHash: Hex;
+        gasLimit: bigint;
+        gasPrice: 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 allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
+     * @param params - Parameters used in the initial transaction
+     * @param gasConfig - Optional gas configuration
+     */
+    monitorTransaction(request: L1TxRequest, initialTxHash: Hex, allVersions: Set<Hex>, params: {
+        gasLimit: bigint;
+    }, _gasConfig?: Partial<L1TxUtilsConfig> & {
+        txTimeoutAt?: Date;
+    }, _blobInputs?: L1BlobInputs, isCancelTx?: boolean): Promise<TransactionReceipt>;
+    /**
+     * 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
+     */
+    sendAndMonitorTransaction(request: L1TxRequest, gasConfig?: L1GasConfig, blobInputs?: L1BlobInputs): Promise<{
+        receipt: TransactionReceipt;
+        gasPrice: GasPrice;
+    }>;
+    simulate(request: L1TxRequest & {
+        gas?: bigint;
+        from?: Hex;
+    }, _blockOverrides?: BlockOverrides<bigint, number>, stateOverrides?: StateOverride, abi?: Abi, _gasConfig?: L1TxUtilsConfig & {
+        fallbackGasEstimate?: bigint;
+        ignoreBlockGasLimit?: boolean;
+    }): Promise<{
+        gasUsed: bigint;
+        result: `0x${string}`;
+    }>;
+    /**
+     * 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 allVersions - Hashes of all transactions submitted under the same nonce (any of them could mine)
+     * @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
+     */
+    protected attemptTxCancellation(currentTxHash: Hex, nonce: number, allVersions: Set<Hex>, isBlobTx?: boolean, previousGasPrice?: GasPrice, attempts?: number): Promise<`0x${string}`>;
+}
+//# sourceMappingURL=l1_tx_utils.d.ts.map

package/dest/l1_tx_utils/l1_tx_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_tx_utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/l1_tx_utils.ts"],"names":[],"mappings":"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"}

package/dest/{l1_tx_utils.js → l1_tx_utils/l1_tx_utils.js}

@@ -1,400 +1,18 @@
-import { compactArray, times } from '@aztec/foundation/collection';
-import { bigintConfigHelper, booleanConfigHelper, getConfigFromMappings, getDefaultConfig, numberConfigHelper } from '@aztec/foundation/config';
+import { times } from '@aztec/foundation/collection';
 import { TimeoutError } from '@aztec/foundation/error';
-import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import { sleep } from '@aztec/foundation/sleep';
 import { DateProvider } from '@aztec/foundation/timer';
 import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
 import pickBy from 'lodash.pickby';
-import { MethodNotFoundRpcError, MethodNotSupportedRpcError, createNonceManager, decodeErrorResult, formatGwei, getContractError, hexToBytes, parseTransaction, serializeTransaction } from 'viem';
+import { createNonceManager, formatGwei, serializeTransaction } from 'viem';
 import { jsonRpc } from 'viem/nonce';
-import { formatViemError } from './utils.js';
-// 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 = 1_000_000_000n;
-// @note using this large gas limit to avoid the issue of `gas limit too low` when estimating gas in reth
-const LARGE_GAS_LIMIT = 12_000_000n;
-// 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 = 10;
-// setting a minimum bump percentage to 100% due to geth's implementation
-// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/blobpool/config.go#L34
-const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
-// Avg ethereum block time is ~12s
-const BLOCK_TIME_MS = 12_000;
-export const l1TxUtilsConfigMappings = {
-    gasLimitBufferPercentage: {
-        description: 'How much to increase calculated gas limit by (percentage)',
-        env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
-        ...numberConfigHelper(20)
-    },
-    maxGwei: {
-        description: 'Maximum gas price in gwei',
-        env: 'L1_GAS_PRICE_MAX',
-        ...bigintConfigHelper(500n)
-    },
-    maxBlobGwei: {
-        description: 'Maximum blob fee per gas in gwei',
-        env: 'L1_BLOB_FEE_PER_GAS_MAX',
-        ...bigintConfigHelper(1_500n)
-    },
-    priorityFeeBumpPercentage: {
-        description: 'How much to increase priority fee by each attempt (percentage)',
-        env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
-        ...numberConfigHelper(20)
-    },
-    priorityFeeRetryBumpPercentage: {
-        description: 'How much to increase priority fee by each retry attempt (percentage)',
-        env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
-        ...numberConfigHelper(50)
-    },
-    fixedPriorityFeePerGas: {
-        description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
-        env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
-        ...numberConfigHelper(0)
-    },
-    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(1_000)
-    },
-    stallTimeMs: {
-        description: 'How long before considering tx stalled',
-        env: 'L1_TX_MONITOR_STALL_TIME_MS',
-        ...numberConfigHelper(24_000)
-    },
-    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(120_000)
-    },
-    txPropagationMaxQueryAttempts: {
-        description: 'How many attempts will be done to get a tx after it was sent',
-        env: 'L1_TX_PROPAGATION_MAX_QUERY_ATTEMPTS',
-        ...numberConfigHelper(3)
-    },
-    cancelTxOnTimeout: {
-        description: "Whether to attempt to cancel a tx if it's not mined after txTimeoutMs",
-        env: 'L1_TX_MONITOR_CANCEL_TX_ON_TIMEOUT',
-        ...booleanConfigHelper(true)
-    }
-};
-export const defaultL1TxUtilsConfig = getDefaultConfig(l1TxUtilsConfigMappings);
-export function getL1TxUtilsConfigEnvVars() {
-    return getConfigFromMappings(l1TxUtilsConfigMappings);
-}
-export var TxUtilsState = /*#__PURE__*/ function(TxUtilsState) {
-    TxUtilsState[TxUtilsState["IDLE"] = 0] = "IDLE";
-    TxUtilsState[TxUtilsState["SENT"] = 1] = "SENT";
-    TxUtilsState[TxUtilsState["SPEED_UP"] = 2] = "SPEED_UP";
-    TxUtilsState[TxUtilsState["CANCELLED"] = 3] = "CANCELLED";
-    TxUtilsState[TxUtilsState["NOT_MINED"] = 4] = "NOT_MINED";
-    TxUtilsState[TxUtilsState["MINED"] = 5] = "MINED";
-    return TxUtilsState;
-}({});
-export class ReadOnlyL1TxUtils {
-    client;
-    logger;
-    dateProvider;
-    debugMaxGasLimit;
-    config;
-    interrupted;
-    constructor(client, logger = createLogger('ReadOnlyL1TxUtils'), dateProvider, config, debugMaxGasLimit = false){
-        this.client = client;
-        this.logger = logger;
-        this.dateProvider = dateProvider;
-        this.debugMaxGasLimit = debugMaxGasLimit;
-        this.interrupted = false;
-        this.config = {
-            ...defaultL1TxUtilsConfig,
-            ...config || {}
-        };
-    }
-    interrupt() {
-        this.interrupted = true;
-    }
-    restart() {
-        this.interrupted = false;
-    }
-    getBlock() {
-        return this.client.getBlock();
-    }
-    getBlockNumber() {
-        return this.client.getBlockNumber();
-    }
-    /**
-   * Gets the current gas price with bounds checking
-   */ async getGasPrice(_gasConfig, isBlobTx = false, attempt = 0, previousGasPrice) {
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const block = await this.client.getBlock({
-            blockTag: 'latest'
-        });
-        const baseFee = block.baseFeePerGas ?? 0n;
-        // Get blob base fee if available
-        let blobBaseFee = 0n;
-        if (isBlobTx) {
-            try {
-                blobBaseFee = await retry(()=>this.client.getBlobBaseFee(), 'Getting L1 blob base fee', makeBackoff(times(2, ()=>1)), this.logger, true);
-                this.logger?.debug('L1 Blob base fee:', {
-                    blobBaseFee: formatGwei(blobBaseFee)
-                });
-            } catch  {
-                this.logger?.warn('Failed to get L1 blob base fee', attempt);
-            }
-        }
-        let priorityFee;
-        if (gasConfig.fixedPriorityFeePerGas) {
-            this.logger?.debug('Using fixed priority fee per L1 gas', {
-                fixedPriorityFeePerGas: gasConfig.fixedPriorityFeePerGas
-            });
-            // try to maintain precision up to 1000000 wei
-            priorityFee = BigInt(gasConfig.fixedPriorityFeePerGas * 1_000_000) * (WEI_CONST / 1_000_000n);
-        } else {
-            // Get initial priority fee from the network
-            priorityFee = await this.client.estimateMaxPriorityFeePerGas();
-        }
-        let maxFeePerGas = baseFee;
-        let maxFeePerBlobGas = blobBaseFee;
-        // 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 * (1_000n + 125n) / 1_000n;
-            // same for blob gas fee
-            maxFeePerBlobGas = maxFeePerBlobGas * (1_000n + 125n) / 1_000n;
-        }
-        if (attempt > 0) {
-            const configBump = gasConfig.priorityFeeRetryBumpPercentage ?? defaultL1TxUtilsConfig.priorityFeeRetryBumpPercentage;
-            // if this is a blob tx, we have to use the blob bump percentage
-            const minBumpPercentage = isBlobTx ? MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE : MIN_REPLACEMENT_BUMP_PERCENTAGE;
-            const bumpPercentage = configBump > minBumpPercentage ? configBump : minBumpPercentage;
-            // Calculate minimum required fees based on previous attempt
-            // multiply by 100 & divide by 100 to maintain some precision
-            const minPriorityFee = previousGasPrice.maxPriorityFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
-            const minMaxFee = previousGasPrice.maxFeePerGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
-            // 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, unless it's a fixed config
-            // multiply by 100 & divide by 100 to maintain some precision
-            if (!gasConfig.fixedPriorityFeePerGas) {
-                priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
-            }
-            maxFeePerGas += priorityFee;
-        }
-        // Ensure we don't exceed maxGwei
-        const maxGweiInWei = gasConfig.maxGwei * WEI_CONST;
-        maxFeePerGas = maxFeePerGas > maxGweiInWei ? maxGweiInWei : maxFeePerGas;
-        // Ensure we don't exceed maxBlobGwei
-        if (maxFeePerBlobGas) {
-            const maxBlobGweiInWei = gasConfig.maxBlobGwei * WEI_CONST;
-            maxFeePerBlobGas = maxFeePerBlobGas > maxBlobGweiInWei ? maxBlobGweiInWei : maxFeePerBlobGas;
-        }
-        // Ensure priority fee doesn't exceed max fee
-        const maxPriorityFeePerGas = priorityFee > maxFeePerGas ? maxFeePerGas : priorityFee;
-        if (attempt > 0 && previousGasPrice?.maxFeePerBlobGas) {
-            const bumpPercentage = gasConfig.priorityFeeRetryBumpPercentage > MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE ? gasConfig.priorityFeeRetryBumpPercentage : MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE;
-            // calculate min blob fee based on previous attempt
-            const minBlobFee = previousGasPrice.maxFeePerBlobGas * (100_00n + BigInt(bumpPercentage * 1_00)) / 100_00n;
-            // use max between current network values and min required values
-            maxFeePerBlobGas = maxFeePerBlobGas > minBlobFee ? maxFeePerBlobGas : minBlobFee;
-        }
-        this.logger?.debug(`Computed L1 gas price`, {
-            attempt,
-            baseFee: formatGwei(baseFee),
-            maxFeePerGas: formatGwei(maxFeePerGas),
-            maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
-            ...maxFeePerBlobGas && {
-                maxFeePerBlobGas: formatGwei(maxFeePerBlobGas)
-            }
-        });
-        return {
-            maxFeePerGas,
-            maxPriorityFeePerGas,
-            ...maxFeePerBlobGas && {
-                maxFeePerBlobGas: maxFeePerBlobGas
-            }
-        };
-    }
-    /**
-   * Estimates gas and adds buffer
-   */ async estimateGas(account, request, _gasConfig, _blobInputs) {
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        let initialEstimate = 0n;
-        if (_blobInputs) {
-            // @note requests with blobs also require maxFeePerBlobGas to be set
-            const gasPrice = await this.getGasPrice(gasConfig, true, 0);
-            initialEstimate = await this.client.estimateGas({
-                account,
-                ...request,
-                ..._blobInputs,
-                maxFeePerBlobGas: gasPrice.maxFeePerBlobGas,
-                gas: LARGE_GAS_LIMIT
-            });
-            this.logger?.debug(`L1 gas used in estimateGas by blob tx: ${initialEstimate}`);
-        } else {
-            initialEstimate = await this.client.estimateGas({
-                account,
-                ...request,
-                gas: LARGE_GAS_LIMIT
-            });
-            this.logger?.debug(`L1 gas used in estimateGas by non-blob tx: ${initialEstimate}`);
-        }
-        // Add buffer based on either fixed amount or percentage
-        const withBuffer = this.bumpGasLimit(initialEstimate, gasConfig);
-        return withBuffer;
-    }
-    async getTransactionStats(txHash) {
-        const tx = await this.client.getTransaction({
-            hash: txHash
-        });
-        if (!tx) {
-            return undefined;
-        }
-        const calldata = hexToBytes(tx.input);
-        return {
-            sender: tx.from.toString(),
-            transactionHash: tx.hash,
-            calldataSize: calldata.length,
-            calldataGas: getCalldataGasUsage(calldata)
-        };
-    }
-    async tryGetErrorFromRevertedTx(data, args, blobInputs, stateOverride = []) {
-        try {
-            await this.client.simulateContract({
-                ...args,
-                account: this.client.account,
-                stateOverride
-            });
-            this.logger?.trace('Simulated blob tx', {
-                blobInputs
-            });
-            // If the above passes, we have a blob error. We cannot simulate blob txs, and failed txs no longer throw errors.
-            // Strangely, the only way to throw the revert reason as an error and provide blobs is prepareTransactionRequest.
-            // See: https://github.com/wevm/viem/issues/2075
-            // This throws a EstimateGasExecutionError with the custom error information:
-            const request = blobInputs ? {
-                account: this.client.account,
-                to: args.address,
-                data,
-                blobs: blobInputs.blobs,
-                kzg: blobInputs.kzg,
-                maxFeePerBlobGas: blobInputs.maxFeePerBlobGas
-            } : {
-                account: this.client.account,
-                to: args.address,
-                data
-            };
-            this.logger?.trace('Preparing tx', {
-                request
-            });
-            await this.client.prepareTransactionRequest(request);
-            this.logger?.trace('Prepared tx');
-            return undefined;
-        } catch (simulationErr) {
-            // If we don't have a ContractFunctionExecutionError, we have a blob related error => use getContractError to get the error msg.
-            const contractErr = simulationErr.name === 'ContractFunctionExecutionError' ? simulationErr : getContractError(simulationErr, {
-                args: [],
-                abi: args.abi,
-                functionName: args.functionName,
-                address: args.address
-            });
-            if (contractErr.name === 'ContractFunctionExecutionError') {
-                const execErr = contractErr;
-                return tryGetCustomErrorNameContractFunction(execErr);
-            }
-            this.logger?.error(`Error getting error from simulation`, simulationErr);
-        }
-    }
-    async simulate(request, blockOverrides = {}, stateOverrides = [], abi = RollupAbi, _gasConfig) {
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const call = {
-            to: request.to,
-            data: request.data,
-            ...request.from && {
-                from: request.from
-            }
-        };
-        return await this._simulate(call, blockOverrides, stateOverrides, gasConfig, abi);
-    }
-    async _simulate(call, blockOverrides = {}, stateOverrides = [], gasConfig, abi) {
-        try {
-            const result = await this.client.simulateBlocks({
-                validation: false,
-                blocks: [
-                    {
-                        blockOverrides,
-                        stateOverrides,
-                        calls: [
-                            call
-                        ]
-                    }
-                ]
-            });
-            if (result[0].calls[0].status === 'failure') {
-                this.logger?.error('L1 transaction simulation failed', result[0].calls[0].error);
-                const decodedError = decodeErrorResult({
-                    abi,
-                    data: result[0].calls[0].data
-                });
-                throw new Error(`L1 transaction simulation failed with error ${decodedError.errorName}(${decodedError.args?.join(',')})`);
-            }
-            this.logger?.debug(`L1 transaction simulation succeeded`, {
-                ...result[0].calls[0]
-            });
-            return {
-                gasUsed: result[0].gasUsed,
-                result: result[0].calls[0].data
-            };
-        } catch (err) {
-            if (err instanceof MethodNotFoundRpcError || err instanceof MethodNotSupportedRpcError) {
-                if (gasConfig.fallbackGasEstimate) {
-                    this.logger?.warn(`Node does not support eth_simulateV1 API. Using fallback gas estimate: ${gasConfig.fallbackGasEstimate}`);
-                    return {
-                        gasUsed: gasConfig.fallbackGasEstimate,
-                        result: '0x'
-                    };
-                }
-                this.logger?.error('Node does not support eth_simulateV1 API');
-            }
-            throw err;
-        }
-    }
-    bumpGasLimit(gasLimit, _gasConfig) {
-        const gasConfig = {
-            ...this.config,
-            ..._gasConfig
-        };
-        const bumpedGasLimit = gasLimit + gasLimit * BigInt((gasConfig?.gasLimitBufferPercentage || 0) * 1_00) / 100_00n;
-        const cleanGasConfig = pickBy(gasConfig, (_, key)=>key in l1TxUtilsConfigMappings);
-        this.logger?.debug('Bumping gas limit', {
-            gasLimit,
-            gasConfig: cleanGasConfig,
-            bumpedGasLimit
-        });
-        return bumpedGasLimit;
-    }
-}
+import { formatViemError } from '../utils.js';
+import { l1TxUtilsConfigMappings } from './config.js';
+import { LARGE_GAS_LIMIT } from './constants.js';
+import { ReadOnlyL1TxUtils } from './readonly_l1_tx_utils.js';
+import { TxUtilsState } from './types.js';
 export class L1TxUtils extends ReadOnlyL1TxUtils {
     client;
     address;
@@ -404,7 +22,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     lastMinedBlockNumber;
     nonceManager;
     constructor(client, address, signer, logger = createLogger('L1TxUtils'), dateProvider = new DateProvider(), config, debugMaxGasLimit = false){
-        super(client, logger, dateProvider, config, debugMaxGasLimit), this.client = client, this.address = address, this.signer = signer, this.logger = logger, this.txUtilsState = 0, this.lastMinedBlockNumber = undefined;
+        super(client, logger, dateProvider, config, debugMaxGasLimit), this.client = client, this.address = address, this.signer = signer, this.logger = logger, this.txUtilsState = TxUtilsState.IDLE, this.lastMinedBlockNumber = undefined;
         this.nonceManager = createNonceManager({
             source: jsonRpc()
         });
@@ -443,7 +61,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
    * @param request - The transaction request (to, data, value)
    * @param gasConfig - Optional gas configuration
    * @returns The transaction hash and parameters used
-   */ async sendTransaction(request, _gasConfig, blobInputs, stateChange = 1) {
+   */ async sendTransaction(request, _gasConfig, blobInputs, stateChange = TxUtilsState.SENT) {
         try {
             const gasConfig = {
                 ...this.config,
@@ -588,7 +206,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                                 } else {
                                     this.logger?.debug(`L1 transaction ${hash} mined`);
                                 }
-                                this.state = 5;
+                                this.state = TxUtilsState.MINED;
                                 this.lastMinedAtBlockNumber = receipt.blockNumber;
                                 return receipt;
                             }
@@ -600,7 +218,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                     }
                     // If we get here then we have checked all of our tx versions and not found anything.
                     // We should consider the nonce as MINED
-                    this.state = 5;
+                    this.state = TxUtilsState.MINED;
                     throw new Error(`Nonce ${nonce} is MINED but not by one of our expected transactions`);
                 }
                 this.logger?.trace(`Tx timeout check for ${currentTxHash}: ${isTimedOut()}`, {
@@ -658,7 +276,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
                         serializedTransaction: signedRequest
                     });
                     if (!isCancelTx) {
-                        this.state = 2;
+                        this.state = TxUtilsState.SPEED_UP;
                     }
                     const cleanGasConfig = pickBy(gasConfig, (_, key)=>key in l1TxUtilsConfigMappings);
                     this.logger?.verbose(`Sent L1 speed-up tx ${newHash}, replacing ${currentTxHash}`, {
@@ -689,7 +307,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         // The transaction has timed out. If it's a cancellation then we are giving up on it.
         // Otherwise we may attempt to cancel it if configured to do so.
         if (isCancelTx) {
-            this.state = 4;
+            this.state = TxUtilsState.NOT_MINED;
         } else if (gasConfig.cancelTxOnTimeout) {
             // Fire cancellation without awaiting to avoid blocking the main thread
             this.attemptTxCancellation(currentTxHash, nonce, allVersions, isBlobTx, lastGasPrice, attempts).catch((err)=>{
@@ -786,7 +404,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         const cancelTxHash = await this.client.sendRawTransaction({
             serializedTransaction: signedRequest
         });
-        this.state = 3;
+        this.state = TxUtilsState.CANCELLED;
         this.logger?.info(`Sent cancellation tx ${cancelTxHash} for timed out tx ${currentTxHash}`, {
             nonce
         });
@@ -796,40 +414,3 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         return receipt.transactionHash;
     }
 }
-export function createViemSigner(client) {
-    const signer = async (tx, _address)=>{
-        const signedTx = await client.signTransaction(tx);
-        const parsed = parseTransaction(signedTx);
-        if (!parsed.r || !parsed.s || parsed.yParity !== 0 && parsed.yParity !== 1) {
-            throw new Error('Failed to extract signature from viem signed transaction');
-        }
-        return {
-            r: parsed.r,
-            s: parsed.s,
-            yParity: parsed.yParity
-        };
-    };
-    return signer;
-}
-export function createL1TxUtilsFromViemWallet(client, logger = createLogger('L1TxUtils'), dateProvider = new DateProvider(), config, debugMaxGasLimit = false) {
-    return new L1TxUtils(client, EthAddress.fromString(client.account.address), createViemSigner(client), logger, dateProvider, config, debugMaxGasLimit);
-}
-export function createL1TxUtilsFromEthSigner(client, signer, logger = createLogger('L1TxUtils'), dateProvider = new DateProvider(), config, debugMaxGasLimit = false) {
-    const callback = async (transaction, _signingAddress)=>{
-        return (await signer.signTransaction(transaction)).toViemTransactionSignature();
-    };
-    return new L1TxUtils(client, signer.address, callback, logger, dateProvider, config, debugMaxGasLimit);
-}
-export function tryGetCustomErrorNameContractFunction(err) {
-    return compactArray([
-        err.shortMessage,
-        ...(err.metaMessages ?? []).slice(0, 2).map((s)=>s.trim())
-    ]).join(' ');
-}
-/*
- * Returns cost of calldata usage in Ethereum.
- * @param data - Calldata.
- * @returns 4 for each zero byte, 16 for each nonzero.
- */ export function getCalldataGasUsage(data) {
-    return data.filter((byte)=>byte === 0).length * 4 + data.filter((byte)=>byte !== 0).length * 16;
-}

package/dest/{l1_tx_utils_with_blobs.d.ts → l1_tx_utils/l1_tx_utils_with_blobs.d.ts}

@@ -1,9 +1,11 @@
 import { type Logger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import { type Hex } from 'viem';
-import type { EthSigner } from './eth-signer/eth-signer.js';
-import { type GasPrice, L1TxUtils, type L1TxUtilsConfig } from './l1_tx_utils.js';
-import type { ExtendedViemWalletClient, ViemClient } from './types.js';
+import type { EthSigner } from '../eth-signer/eth-signer.js';
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { L1TxUtilsConfig } from './config.js';
+import { L1TxUtils } from './l1_tx_utils.js';
+import type { GasPrice } from './types.js';
 export declare class L1TxUtilsWithBlobs extends L1TxUtils {
     /**
      * Attempts to cancel a transaction by sending a 0-value tx to self with same nonce but higher gas prices
@@ -13,7 +15,7 @@ export declare class L1TxUtilsWithBlobs extends L1TxUtils {
      * @param attempts - The number of attempts to cancel the transaction
      * @returns The hash of the cancellation transaction
      */
-    attemptTxCancellation(currentTxHash: Hex, nonce: number, allVersions: Set<Hex>, isBlobTx?: boolean, previousGasPrice?: GasPrice, attempts?: number): Promise<`0x${string}`>;
+    protected attemptTxCancellation(currentTxHash: Hex, nonce: number, allVersions: Set<Hex>, isBlobTx?: boolean, previousGasPrice?: GasPrice, attempts?: number): Promise<`0x${string}`>;
 }
 export declare function createL1TxUtilsWithBlobsFromViemWallet(client: ExtendedViemWalletClient, logger?: Logger, dateProvider?: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean): L1TxUtilsWithBlobs;
 export declare function createL1TxUtilsWithBlobsFromEthSigner(client: ViemClient, signer: EthSigner, logger?: Logger, dateProvider?: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean): L1TxUtilsWithBlobs;

package/dest/l1_tx_utils/l1_tx_utils_with_blobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_tx_utils_with_blobs.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/l1_tx_utils_with_blobs.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,EAAE,KAAK,GAAG,EAA4C,MAAM,MAAM,CAAC;AAE1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,wBAAwB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,KAAK,EAAE,QAAQ,EAAmB,MAAM,YAAY,CAAC;AAE5D,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C;;;;;;;OAOG;cACsB,qBAAqB,CAC5C,aAAa,EAAE,GAAG,EAClB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,GAAG,CAAC,GAAG,CAAC,EACrB,QAAQ,UAAQ,EAChB,gBAAgB,CAAC,EAAE,QAAQ,EAC3B,QAAQ,SAAI;CAoFf;AAED,wBAAgB,sCAAsC,CACpD,MAAM,EAAE,wBAAwB,EAChC,MAAM,GAAE,MAAkC,EAC1C,YAAY,GAAE,YAAiC,EAC/C,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,EACjC,gBAAgB,GAAE,OAAe,sBAWlC;AAED,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,SAAS,EACjB,MAAM,GAAE,MAAkC,EAC1C,YAAY,GAAE,YAAiC,EAC/C,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,EACjC,gBAAgB,GAAE,OAAe,sBAOlC"}

package/dest/{l1_tx_utils_with_blobs.js → l1_tx_utils/l1_tx_utils_with_blobs.js}

@@ -3,7 +3,8 @@ import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { DateProvider } from '@aztec/foundation/timer';
 import { formatGwei } from 'viem';
-import { L1TxUtils, createViemSigner } from './l1_tx_utils.js';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { createViemSigner } from './signer.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