@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.03f7ef2

package/dest/l1_tx_utils/l1_tx_utils_with_blobs.js

@@ -0,0 +1,26 @@
+import { Blob } from '@aztec/blob-lib';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { createViemSigner } from './signer.js';
+/** Extends L1TxUtils with the capability to cancel blobs. This needs to be a separate class so we don't require a dependency on blob-lib unnecessarily. */ export class L1TxUtilsWithBlobs extends L1TxUtils {
+    /** Makes empty blob inputs for the cancellation tx. */ makeEmptyBlobInputs(maxFeePerBlobGas) {
+        const blobData = new Uint8Array(131072).fill(0);
+        const kzg = Blob.getViemKzgInstance();
+        return {
+            blobs: [
+                blobData
+            ],
+            kzg,
+            maxFeePerBlobGas
+        };
+    }
+}
+export function createL1TxUtilsWithBlobsFromViemWallet(client, deps = {}, config = {}, debugMaxGasLimit = false) {
+    return new L1TxUtilsWithBlobs(client, EthAddress.fromString(client.account.address), createViemSigner(client), deps.logger, deps.dateProvider, config, debugMaxGasLimit, deps.store, deps.metrics);
+}
+export function createL1TxUtilsWithBlobsFromEthSigner(client, signer, deps = {}, config = {}, debugMaxGasLimit = false) {
+    const callback = async (transaction, _signingAddress)=>{
+        return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+    };
+    return new L1TxUtilsWithBlobs(client, signer.address, callback, deps.logger, deps.dateProvider, config, debugMaxGasLimit, deps.store, deps.metrics);
+}

package/dest/l1_tx_utils/readonly_l1_tx_utils.d.ts

@@ -0,0 +1,87 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { type Abi, type Account, type BlockOverrides, type GetCodeReturnType, type Hex, type StateOverride } from 'viem';
+import type { ViemClient } from '../types.js';
+import { type L1TxUtilsConfig } from './config.js';
+import type { GasPrice, L1BlobInputs, L1TxRequest, TransactionStats } from './types.js';
+export declare class ReadOnlyL1TxUtils {
+    client: ViemClient;
+    protected logger: Logger;
+    readonly dateProvider: DateProvider;
+    protected debugMaxGasLimit: boolean;
+    config: Required<L1TxUtilsConfig>;
+    protected interrupted: boolean;
+    constructor(client: ViemClient, logger: Logger | undefined, dateProvider: DateProvider, config?: Partial<L1TxUtilsConfig>, debugMaxGasLimit?: boolean);
+    interrupt(): void;
+    restart(): void;
+    getBlock(): Promise<{
+        baseFeePerGas: bigint | null;
+        blobGasUsed: bigint;
+        difficulty: bigint;
+        excessBlobGas: bigint;
+        extraData: `0x${string}`;
+        gasLimit: bigint;
+        gasUsed: bigint;
+        hash: `0x${string}`;
+        logsBloom: `0x${string}`;
+        miner: `0x${string}`;
+        mixHash: `0x${string}`;
+        nonce: `0x${string}`;
+        number: bigint;
+        parentBeaconBlockRoot?: `0x${string}` | undefined;
+        parentHash: `0x${string}`;
+        receiptsRoot: `0x${string}`;
+        sealFields: `0x${string}`[];
+        sha3Uncles: `0x${string}`;
+        size: bigint;
+        stateRoot: `0x${string}`;
+        timestamp: bigint;
+        totalDifficulty: bigint | null;
+        transactionsRoot: `0x${string}`;
+        uncles: `0x${string}`[];
+        withdrawals?: import("viem").Withdrawal[] | undefined;
+        withdrawalsRoot?: `0x${string}` | undefined;
+        transactions: `0x${string}`[];
+    }>;
+    getBlockNumber(): Promise<bigint>;
+    getCode(address: EthAddress): Promise<GetCodeReturnType>;
+    /**
+     * Gets the current gas price with bounds checking
+     */
+    getGasPrice(gasConfigOverrides?: L1TxUtilsConfig, isBlobTx?: boolean, attempt?: number, previousGasPrice?: typeof attempt extends 0 ? never : GasPrice): Promise<GasPrice>;
+    /**
+     * Estimates gas and adds buffer
+     */
+    estimateGas(account: Account | Hex, request: L1TxRequest, _gasConfig?: L1TxUtilsConfig, _blobInputs?: L1BlobInputs): Promise<bigint>;
+    getTransactionStats(txHash: string): Promise<TransactionStats | undefined>;
+    tryGetErrorFromRevertedTx(data: Hex, args: {
+        args: readonly any[];
+        functionName: string;
+        abi: Abi;
+        address: Hex;
+    }, blobInputs: (L1BlobInputs & {
+        maxFeePerBlobGas: bigint;
+    }) | undefined, stateOverride?: StateOverride): Promise<string | undefined>;
+    simulate(request: L1TxRequest & {
+        gas?: bigint;
+        from?: Hex;
+    }, blockOverrides?: BlockOverrides<bigint, number>, stateOverrides?: StateOverride, abi?: Abi, _gasConfig?: L1TxUtilsConfig & {
+        fallbackGasEstimate?: bigint;
+    }): Promise<{
+        gasUsed: bigint;
+        result: `0x${string}`;
+    }>;
+    protected _simulate(call: any, blockOverrides: BlockOverrides<bigint, number> | undefined, stateOverrides: StateOverride | undefined, gasConfig: L1TxUtilsConfig & {
+        fallbackGasEstimate?: bigint;
+    }, abi: Abi): Promise<{
+        gasUsed: bigint;
+        result: `0x${string}`;
+    }>;
+    bumpGasLimit(gasLimit: bigint, _gasConfig?: L1TxUtilsConfig): bigint;
+    /**
+     * Helper function to retry RPC calls twice
+     */
+    private tryTwice;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/dest/l1_tx_utils/readonly_l1_tx_utils.js

@@ -0,0 +1,360 @@
+import { getKeys, merge, pick, times } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { makeBackoff, retry } from '@aztec/foundation/retry';
+import { RollupAbi } from '@aztec/l1-artifacts/RollupAbi';
+import pickBy from 'lodash.pickby';
+import { MethodNotFoundRpcError, MethodNotSupportedRpcError, decodeErrorResult, formatGwei, getContractError, hexToBytes } from 'viem';
+import { defaultL1TxUtilsConfig, l1TxUtilsConfigMappings } from './config.js';
+import { BLOCK_TIME_MS, LARGE_GAS_LIMIT, MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE, MIN_REPLACEMENT_BUMP_PERCENTAGE, WEI_CONST } from './constants.js';
+import { P75AllTxsPriorityFeeStrategy } from './fee-strategies/index.js';
+import { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
+// Change this to the current strategy we want to use
+const CurrentStrategy = P75AllTxsPriorityFeeStrategy;
+export class ReadOnlyL1TxUtils {
+    client;
+    logger;
+    dateProvider;
+    debugMaxGasLimit;
+    config;
+    interrupted;
+    constructor(client, logger = createLogger('ethereum:readonly-l1-utils'), dateProvider, config, debugMaxGasLimit = false){
+        this.client = client;
+        this.logger = logger;
+        this.dateProvider = dateProvider;
+        this.debugMaxGasLimit = debugMaxGasLimit;
+        this.interrupted = false;
+        this.config = merge(defaultL1TxUtilsConfig, pick(config || {}, ...getKeys(l1TxUtilsConfigMappings)));
+    }
+    interrupt() {
+        this.interrupted = true;
+    }
+    restart() {
+        this.interrupted = false;
+    }
+    getBlock() {
+        return this.client.getBlock();
+    }
+    getBlockNumber() {
+        return this.client.getBlockNumber();
+    }
+    getCode(address) {
+        return this.client.getCode({
+            address: address.toString()
+        });
+    }
+    /**
+   * Gets the current gas price with bounds checking
+   */ async getGasPrice(gasConfigOverrides, isBlobTx = false, attempt = 0, previousGasPrice) {
+        const gasConfig = merge(this.config, gasConfigOverrides);
+        // Make all RPC calls in parallel upfront with retry logic
+        // First 2 calls are necessary to complete
+        const latestBlockPromise = this.tryTwice(()=>this.client.getBlock({
+                blockTag: 'latest'
+            }), 'Getting latest block');
+        let blobBaseFeePromise = null;
+        if (isBlobTx) {
+            blobBaseFeePromise = this.tryTwice(()=>this.client.getBlobBaseFee(), 'Getting blob base fee');
+        }
+        // Get strategy promises for priority fee calculation
+        const strategyPromises = CurrentStrategy.getRequiredPromises(this.client, {
+            isBlobTx
+        });
+        const strategyPromiseKeys = [];
+        const strategyPromisesArr = [];
+        for (const [key, promise] of Object.entries(strategyPromises)){
+            strategyPromiseKeys.push(key);
+            strategyPromisesArr.push(this.tryTwice(()=>promise, `Getting strategy data for ${key}`));
+        }
+        const [latestBlockResult, blobBaseFeeResult, ...strategyResults] = await Promise.allSettled([
+            latestBlockPromise,
+            blobBaseFeePromise ?? Promise.resolve(0n),
+            ...strategyPromisesArr
+        ]);
+        // Extract results
+        const baseFee = latestBlockResult.status === 'fulfilled' && typeof latestBlockResult.value === 'object' && latestBlockResult.value.baseFeePerGas ? latestBlockResult.value.baseFeePerGas : 0n;
+        // Get blob base fee if available
+        let blobBaseFee = 0n;
+        if (isBlobTx && blobBaseFeeResult.status === 'fulfilled' && typeof blobBaseFeeResult.value === 'bigint') {
+            blobBaseFee = blobBaseFeeResult.value;
+        } else if (isBlobTx) {
+            this.logger?.warn('Failed to get L1 blob base fee', attempt);
+        }
+        let priorityFee;
+        // Get competitive priority fee using strategy
+        // Reconstruct the results object with the same keys as the promises
+        const resultsObject = {};
+        strategyPromiseKeys.forEach((key, index)=>{
+            resultsObject[key] = strategyResults[index];
+        });
+        const result = CurrentStrategy.calculate(resultsObject, {
+            gasConfig,
+            isBlobTx,
+            logger: this.logger
+        });
+        priorityFee = result.priorityFee;
+        // Apply minimum priority fee floor if configured
+        if (gasConfig.minimumPriorityFeePerGas) {
+            const minimumPriorityFee = BigInt(Math.trunc(gasConfig.minimumPriorityFeePerGas * Number(WEI_CONST)));
+            if (priorityFee < minimumPriorityFee) {
+                this.logger?.debug('Applying minimum priority fee floor', {
+                    calculatedPriorityFee: formatGwei(priorityFee),
+                    minimumPriorityFeePerGas: gasConfig.minimumPriorityFeePerGas,
+                    appliedFee: formatGwei(minimumPriorityFee)
+                });
+                priorityFee = minimumPriorityFee;
+            }
+        }
+        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;
+            // Apply bump percentage to competitive fee
+            const competitivePriorityFee = priorityFee * (100_00n + BigInt(configBump * 1_00)) / 100_00n;
+            this.logger?.debug(`Speed-up attempt ${attempt}: using competitive fee strategy`, {
+                networkEstimate: formatGwei(priorityFee),
+                competitiveFee: formatGwei(competitivePriorityFee),
+                minRequired: formatGwei(minPriorityFee),
+                bumpPercentage: configBump
+            });
+            // Use maximum between competitive fee and minimum required bump
+            const finalPriorityFee = competitivePriorityFee > minPriorityFee ? competitivePriorityFee : minPriorityFee;
+            const feeSource = finalPriorityFee === competitivePriorityFee ? 'competitive' : 'minimum-bump';
+            priorityFee = finalPriorityFee;
+            // Add the final priority fee to maxFeePerGas
+            maxFeePerGas += finalPriorityFee;
+            maxFeePerGas = maxFeePerGas > minMaxFee ? maxFeePerGas : minMaxFee;
+            this.logger?.debug(`Speed-up fee decision: using ${feeSource} fee`, {
+                finalPriorityFee: formatGwei(finalPriorityFee)
+            });
+        } else {
+            // First attempt: apply configured bump percentage to competitive fee
+            // multiply by 100 & divide by 100 to maintain some precision
+            priorityFee = priorityFee * (100_00n + BigInt((gasConfig.priorityFeeBumpPercentage || 0) * 1_00)) / 100_00n;
+            this.logger?.debug('Initial transaction: using competitive fee from market analysis', {
+                networkEstimate: formatGwei(priorityFee)
+            });
+            maxFeePerGas += priorityFee;
+        }
+        // maxGwei and maxBlobGwei are hard limits
+        const effectiveMaxGwei = BigInt(Math.trunc(gasConfig.maxGwei * Number(WEI_CONST)));
+        const effectiveMaxBlobGwei = BigInt(Math.trunc(gasConfig.maxBlobGwei * Number(WEI_CONST)));
+        // Ensure we don't exceed maxGwei
+        if (effectiveMaxGwei > 0n) {
+            maxFeePerGas = maxFeePerGas > effectiveMaxGwei ? effectiveMaxGwei : maxFeePerGas;
+        }
+        // Ensure we don't exceed maxBlobGwei
+        if (maxFeePerBlobGas && effectiveMaxBlobGwei > 0n) {
+            maxFeePerBlobGas = maxFeePerBlobGas > effectiveMaxBlobGwei ? effectiveMaxBlobGwei : 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?.trace(`Computed L1 gas price max fee ${formatGwei(maxFeePerGas)} and max priority fee ${formatGwei(maxPriorityFeePerGas)}`, {
+            attempt,
+            baseFee: formatGwei(baseFee),
+            maxFeePerGas: formatGwei(maxFeePerGas),
+            maxPriorityFeePerGas: formatGwei(maxPriorityFeePerGas),
+            blobBaseFee: formatGwei(blobBaseFee),
+            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,
+                blockTag: 'latest'
+            });
+            this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
+        } else {
+            initialEstimate = await this.client.estimateGas({
+                account,
+                ...request,
+                gas: LARGE_GAS_LIMIT,
+                blockTag: 'latest'
+            });
+            this.logger?.trace(`Estimated gas for 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?.trace(`Bumping gas limit from ${gasLimit} to ${bumpedGasLimit}`, {
+            gasLimit,
+            gasConfig: cleanGasConfig,
+            bumpedGasLimit
+        });
+        return bumpedGasLimit;
+    }
+    /**
+   * Helper function to retry RPC calls twice
+   */ tryTwice(fn, description) {
+        return retry(fn, description, makeBackoff(times(2, ()=>0)), this.logger, true);
+    }
+}

package/dest/l1_tx_utils/signer.d.ts

@@ -0,0 +1,4 @@
+import { type WalletClient } from 'viem';
+import type { SigningCallback } from './types.js';
+export declare function createViemSigner(client: WalletClient): SigningCallback;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbDFfdHhfdXRpbHMvc2lnbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE9BQU8sRUFBZ0MsS0FBSyxZQUFZLEVBQW9CLE1BQU0sTUFBTSxDQUFDO0FBRXpGLE9BQU8sS0FBSyxFQUFFLGVBQWUsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVsRCx3QkFBZ0IsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLFlBQVksbUJBb0JwRCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/signer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgC,KAAK,YAAY,EAAoB,MAAM,MAAM,CAAC;AAEzF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,YAAY,mBAoBpD"}

package/dest/l1_tx_utils/signer.js

@@ -0,0 +1,16 @@
+import { parseTransaction } from 'viem';
+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;
+}

package/dest/l1_tx_utils/types.d.ts

@@ -0,0 +1,67 @@
+import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
+import type { Abi, Address, Hex, TransactionReceipt, TransactionSerializable } from 'viem';
+import type { L1TxUtilsConfig } from './config.js';
+export interface L1TxRequest {
+    to: Address | null;
+    data?: Hex;
+    value?: bigint;
+    abi?: Abi;
+}
+export type L1TxConfig = Partial<L1TxUtilsConfig> & {
+    gasLimit?: bigint;
+    txTimeoutAt?: Date;
+};
+export interface L1BlobInputs {
+    blobs: Uint8Array[];
+    kzg: BlobKzgInstance;
+    maxFeePerBlobGas?: bigint;
+}
+export interface GasPrice {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    maxFeePerBlobGas?: bigint;
+}
+export type TransactionStats = {
+    /** Address of the sender. */
+    sender: string;
+    /** Hash of the transaction. */
+    transactionHash: string;
+    /** Size in bytes of the tx calldata */
+    calldataSize: number;
+    /** Gas required to pay for the calldata inclusion (depends on size and number of zeros)  */
+    calldataGas: number;
+};
+export declare enum TxUtilsState {
+    IDLE = 0,
+    SENT = 1,
+    SPEED_UP = 2,
+    CANCELLED = 3,
+    NOT_MINED = 4,
+    MINED = 5
+}
+export declare const TerminalTxUtilsState: TxUtilsState[];
+export type L1TxState = {
+    id: number;
+    txHashes: Hex[];
+    cancelTxHashes: Hex[];
+    gasLimit: bigint;
+    gasPrice: GasPrice;
+    txConfigOverrides: L1TxConfig;
+    request: L1TxRequest;
+    status: TxUtilsState;
+    nonce: number;
+    sentAtL1Ts: Date;
+    lastSentAtL1Ts: Date;
+    receipt?: TransactionReceipt;
+    blobInputs: L1BlobInputs | undefined;
+};
+export type SigningCallback = (transaction: TransactionSerializable, signingAddress: EthAddress) => Promise<ViemTransactionSignature>;
+export declare class UnknownMinedTxError extends Error {
+    constructor(nonce: number, account: string);
+}
+export declare class DroppedTransactionError extends Error {
+    constructor(nonce: number, account: string);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAEhF,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,MAAM,MAAM,CAAC;AAE3F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,GAAG,CAAC;CACX;AAED,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,eAAe,CAAC,GAAG;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE9F,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,GAAG,EAAE,eAAe,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,QAAQ;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,uCAAuC;IACvC,YAAY,EAAE,MAAM,CAAC;IACrB,4FAA4F;IAC5F,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,oBAAY,YAAY;IACtB,IAAI,IAAA;IACJ,IAAI,IAAA;IACJ,QAAQ,IAAA;IACR,SAAS,IAAA;IACT,SAAS,IAAA;IACT,KAAK,IAAA;CACN;AAED,eAAO,MAAM,oBAAoB,gBAAkE,CAAC;AAEpG,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,GAAG,EAAE,CAAC;IAChB,cAAc,EAAE,GAAG,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,iBAAiB,EAAE,UAAU,CAAC;IAC9B,OAAO,EAAE,WAAW,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,IAAI,CAAC;IACjB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,UAAU,EAAE,YAAY,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAC5B,WAAW,EAAE,uBAAuB,EACpC,cAAc,EAAE,UAAU,KACvB,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAEvC,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAGzC;CACF;AAED,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAGzC;CACF"}

package/dest/l1_tx_utils/types.js

@@ -0,0 +1,26 @@
+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 const TerminalTxUtilsState = [
+    0,
+    5,
+    4
+];
+export class UnknownMinedTxError extends Error {
+    constructor(nonce, account){
+        super(`Nonce ${nonce} from account ${account} is MINED but not by one of our expected transactions`);
+        this.name = 'UnknownMinedTxError';
+    }
+}
+export class DroppedTransactionError extends Error {
+    constructor(nonce, account){
+        super(`Transaction with nonce ${nonce} from account ${account} was dropped from the mempool`);
+        this.name = 'DroppedTransactionError';
+    }
+}

package/dest/l1_tx_utils/utils.d.ts

@@ -0,0 +1,4 @@
+import type { ContractFunctionExecutionError } from 'viem';
+export declare function tryGetCustomErrorNameContractFunction(err: ContractFunctionExecutionError): string;
+export declare function getCalldataGasUsage(data: Uint8Array): number;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9sMV90eF91dGlscy91dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSw4QkFBOEIsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUUzRCx3QkFBZ0IscUNBQXFDLENBQUMsR0FBRyxFQUFFLDhCQUE4QixVQUV4RjtBQU9ELHdCQUFnQixtQkFBbUIsQ0FBQyxJQUFJLEVBQUUsVUFBVSxVQUVuRCJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/l1_tx_utils/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,MAAM,CAAC;AAE3D,wBAAgB,qCAAqC,CAAC,GAAG,EAAE,8BAA8B,UAExF;AAOD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,UAEnD"}

package/dest/l1_tx_utils/utils.js

@@ -0,0 +1,14 @@
+import { compactArray } from '@aztec/foundation/collection';
+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_types.d.ts

@@ -0,0 +1,6 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+export type L1BlockId = {
+    l1BlockNumber: bigint;
+    l1BlockHash: Buffer32;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDFfdHlwZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9sMV90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV6RCxNQUFNLE1BQU0sU0FBUyxHQUFHO0lBQ3RCLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsV0FBVyxFQUFFLFFBQVEsQ0FBQztDQUN2QixDQUFDIn0=

package/dest/l1_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_types.d.ts","sourceRoot":"","sources":["../src/l1_types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,MAAM,MAAM,SAAS,GAAG;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,QAAQ,CAAC;CACvB,CAAC"}

package/dest/l1_types.js

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