@aztec/ethereum 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/dest/l1_tx_utils/readonly_l1_tx_utils.d.ts

@@ -0,0 +1,81 @@
+import { type Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+import { type Abi, type Account, type BlockOverrides, 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<{
+        number: bigint;
+        hash: `0x${string}`;
+        nonce: `0x${string}`;
+        logsBloom: `0x${string}`;
+        baseFeePerGas: bigint | null;
+        blobGasUsed: bigint;
+        difficulty: bigint;
+        excessBlobGas: bigint;
+        extraData: Hex;
+        gasLimit: bigint;
+        gasUsed: bigint;
+        miner: import("viem").Address;
+        mixHash: import("viem").Hash;
+        parentBeaconBlockRoot?: `0x${string}` | undefined;
+        parentHash: import("viem").Hash;
+        receiptsRoot: Hex;
+        sealFields: Hex[];
+        sha3Uncles: import("viem").Hash;
+        size: bigint;
+        stateRoot: import("viem").Hash;
+        timestamp: bigint;
+        totalDifficulty: bigint | null;
+        transactionsRoot: import("viem").Hash;
+        uncles: import("viem").Hash[];
+        withdrawals?: import("viem").Withdrawal[] | undefined | undefined;
+        withdrawalsRoot?: `0x${string}` | undefined;
+        transactions: `0x${string}`[];
+    }>;
+    getBlockNumber(): Promise<bigint>;
+    /**
+     * 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;
+}
+//# sourceMappingURL=readonly_l1_tx_utils.d.ts.map

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,294 @@
+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 { getCalldataGasUsage, tryGetCustomErrorNameContractFunction } from './utils.js';
+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();
+    }
+    /**
+   * Gets the current gas price with bounds checking
+   */ async getGasPrice(gasConfigOverrides, isBlobTx = false, attempt = 0, previousGasPrice) {
+        const gasConfig = merge(this.config, gasConfigOverrides);
+        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);
+            } 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?.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
+            });
+            this.logger?.trace(`Estimated gas for blob tx: ${initialEstimate}`);
+        } else {
+            initialEstimate = await this.client.estimateGas({
+                account,
+                ...request,
+                gas: LARGE_GAS_LIMIT
+            });
+            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;
+    }
+}

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=signer.d.ts.map

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=types.d.ts.map

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;gBAChC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI3C;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI3C"}

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=utils.d.ts.map

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/publisher_manager.d.ts

@@ -1,9 +1,14 @@
-import { L1TxUtils } from './l1_tx_utils.js';
+import { L1TxUtils } from './l1_tx_utils/index.js';
 export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
 export declare class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
     private publishers;
     private log;
-    constructor(publishers: UtilsType[]);
+    private config;
+    constructor(publishers: UtilsType[], config: {
+        publisherAllowInvalidStates?: boolean;
+    });
+    /** Loads the state of all publishers and resumes monitoring any pending txs */
+    loadState(): Promise<void>;
     getAvailablePublisher(filter?: PublisherFilter<UtilsType>): Promise<UtilsType>;
     interrupt(): void;
 }

package/dest/publisher_manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"publisher_manager.d.ts","sourceRoot":"","sources":["../src/publisher_manager.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAgB,MAAM,kBAAkB,CAAC;AAK3D,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,SAAS,IAAI,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC;AAEzF,qBAAa,gBAAgB,CAAC,SAAS,SAAS,SAAS,GAAG,SAAS;IAGvD,OAAO,CAAC,UAAU;IAF9B,OAAO,CAAC,GAAG,CAAoC;gBAE3B,UAAU,EAAE,SAAS,EAAE;IAW9B,qBAAqB,CAAC,MAAM,GAAE,eAAe,CAAC,SAAS,CAAc,GAAG,OAAO,CAAC,SAAS,CAAC;IAqChG,SAAS;CAGjB"}
+{"version":3,"file":"publisher_manager.d.ts","sourceRoot":"","sources":["../src/publisher_manager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAgB,MAAM,wBAAwB,CAAC;AAwBjE,MAAM,MAAM,eAAe,CAAC,SAAS,SAAS,SAAS,IAAI,CAAC,KAAK,EAAE,SAAS,KAAK,OAAO,CAAC;AAEzF,qBAAa,gBAAgB,CAAC,SAAS,SAAS,SAAS,GAAG,SAAS;IAKjE,OAAO,CAAC,UAAU;IAJpB,OAAO,CAAC,GAAG,CAAqC;IAChD,OAAO,CAAC,MAAM,CAA4C;gBAGhD,UAAU,EAAE,SAAS,EAAE,EAC/B,MAAM,EAAE;QAAE,2BAA2B,CAAC,EAAE,OAAO,CAAA;KAAE;IAOnD,+EAA+E;IAClE,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAU1B,qBAAqB,CAAC,MAAM,GAAE,eAAe,CAAC,SAAS,CAAc,GAAG,OAAO,CAAC,SAAS,CAAC;IAiDhG,SAAS;CAGjB"}

package/dest/publisher_manager.js

@@ -1,33 +1,61 @@
+import { pick } from '@aztec/foundation/collection';
 import { createLogger } from '@aztec/foundation/log';
-import { TxUtilsState } from './l1_tx_utils.js';
+import { TxUtilsState } from './l1_tx_utils/index.js';
+// Defines the order in which we prioritise publishers based on their state (first is better)
 const sortOrder = [
+    // Always prefer sending from idle publishers
     TxUtilsState.IDLE,
-    TxUtilsState.MINED
+    // Then from publishers that have sent a tx and it got mined
+    TxUtilsState.MINED,
+    // Then from publishers that have sent a tx but it's in-flight
+    TxUtilsState.SPEED_UP,
+    TxUtilsState.SENT,
+    // We leave cancelled and not-mined states for last, since these represent failures to mines and could be problematic
+    TxUtilsState.CANCELLED,
+    TxUtilsState.NOT_MINED
 ];
-const invalidStates = [
+// Which states represent a busy publisher that we should avoid if possible
+const busyStates = [
     TxUtilsState.SENT,
     TxUtilsState.SPEED_UP,
     TxUtilsState.CANCELLED,
     TxUtilsState.NOT_MINED
-]; // Cancelled and not mined are states that can be handled by a later iteration
+];
 export class PublisherManager {
     publishers;
     log;
-    constructor(publishers){
+    config;
+    constructor(publishers, config){
         this.publishers = publishers;
-        this.log = createLogger('PublisherManager');
+        this.log = createLogger('publisher:manager');
         this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
         this.publishers = publishers;
+        this.config = pick(config, 'publisherAllowInvalidStates');
+    }
+    /** Loads the state of all publishers and resumes monitoring any pending txs */ async loadState() {
+        await Promise.all(this.publishers.map((pub)=>pub.loadStateAndResumeMonitoring()));
     }
     // Finds and prioritises available publishers based on
     // 1. Validity as per the provided filter function
     // 2. Validity based on the state the publisher is in
-    // 3. Priority based on state as defined bu sortOrder
+    // 3. Priority based on state as defined by sortOrder
     // 4. Then priority based on highest balance
     // 5. Then priority based on least recently used
     async getAvailablePublisher(filter = ()=>true) {
+        this.log.debug(`Getting available publisher`, {
+            publishers: this.publishers.map((p)=>({
+                    address: p.getSenderAddress(),
+                    state: p.state,
+                    lastMined: p.lastMinedAtBlockNumber
+                }))
+        });
         // Extract the valid publishers
-        const validPublishers = this.publishers.filter((pub)=>!invalidStates.includes(pub.state) && filter(pub));
+        let validPublishers = this.publishers.filter((pub)=>!busyStates.includes(pub.state) && filter(pub));
+        // If none found but we allow invalid (busy) states, try again including them
+        if (validPublishers.length === 0 && this.config.publisherAllowInvalidStates) {
+            this.log.warn(`No valid publishers found. Trying again including invalid states.`);
+            validPublishers = this.publishers.filter((pub)=>filter(pub));
+        }
         // Error if none found
         if (validPublishers.length === 0) {
             throw new Error(`Failed to find an available publisher.`);

package/dest/queries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAK3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qDAAqD;AACrD,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE;IAAE,iBAAiB,EAAE,UAAU,CAAC;IAAC,aAAa,CAAC,EAAE,UAAU,CAAA;CAAE,GACvE,OAAO,CACR,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,GAAG;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,KAAK,MAAM,EAAE,CAAC;CACvC,CACF,CAqFA"}
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAIrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD,qDAAqD;AACrD,wBAAsB,oBAAoB,CACxC,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE;IAAE,iBAAiB,EAAE,UAAU,CAAC;IAAC,aAAa,CAAC,EAAE,UAAU,CAAA;CAAE,GACvE,OAAO,CACR,IAAI,CAAC,iBAAiB,EAAE,sBAAsB,CAAC,GAAG;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,KAAK,MAAM,EAAE,CAAC;CACvC,CACF,CA6FA"}