@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.001888fc

package/dest/l1_tx_utils/tx_delayer.js

@@ -0,0 +1,221 @@
+import { omit } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+import { retryUntil } from '@aztec/foundation/retry';
+import { inspect } from 'util';
+import { keccak256, parseTransaction, publicActions, recoverTransactionAddress, serializeTransaction, walletActions } from 'viem';
+const MAX_WAIT_TIME_SECONDS = 180;
+export function waitUntilBlock(client, blockNumber, logger, timeout) {
+    const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
+    return retryUntil(async ()=>{
+        const currentBlockNumber = await publicClient.getBlockNumber({
+            cacheTime: 0
+        });
+        logger?.debug(`Block number is ${currentBlockNumber} (waiting until ${blockNumber})`);
+        return currentBlockNumber >= BigInt(blockNumber);
+    }, `Wait until L1 block ${blockNumber}`, timeout ?? MAX_WAIT_TIME_SECONDS, 0.1);
+}
+export function waitUntilL1Timestamp(client, timestamp, logger, timeout) {
+    const publicClient = 'getBlockNumber' in client && typeof client.getBlockNumber === 'function' ? client : client.extend(publicActions);
+    let lastBlock = undefined;
+    return retryUntil(async ()=>{
+        const currentBlockNumber = await publicClient.getBlockNumber({
+            cacheTime: 0
+        });
+        if (currentBlockNumber === lastBlock) {
+            return false;
+        }
+        lastBlock = currentBlockNumber;
+        const currentBlock = await publicClient.getBlock({
+            includeTransactions: false,
+            blockNumber: currentBlockNumber
+        });
+        const currentTs = currentBlock.timestamp;
+        logger?.debug(`Block timstamp is ${currentTs} (waiting until ${timestamp})`);
+        return currentTs >= BigInt(timestamp);
+    }, `Wait until L1 timestamp ${timestamp}`, timeout ?? MAX_WAIT_TIME_SECONDS, 0.1);
+}
+/** Manages tx delaying for testing, intercepting sendRawTransaction calls to delay or cancel them. */ export class Delayer {
+    dateProvider;
+    logger;
+    maxInclusionTimeIntoSlot;
+    ethereumSlotDuration;
+    nextWait;
+    sentTxHashes;
+    cancelledTxs;
+    constructor(dateProvider, opts, bindings){
+        this.dateProvider = dateProvider;
+        this.maxInclusionTimeIntoSlot = undefined;
+        this.nextWait = undefined;
+        this.sentTxHashes = [];
+        this.cancelledTxs = [];
+        this.ethereumSlotDuration = BigInt(opts.ethereumSlotDuration);
+        this.logger = createLogger('ethereum:tx_delayer', bindings);
+    }
+    /** Returns the logger instance used by this delayer. */ getLogger() {
+        return this.logger;
+    }
+    /** Returns the hashes of all effectively sent txs. */ getSentTxHashes() {
+        return this.sentTxHashes;
+    }
+    /** Returns the raw hex for all cancelled txs. */ getCancelledTxs() {
+        return this.cancelledTxs;
+    }
+    /** Delays the next tx to be sent so it lands on the given L1 block number. */ pauseNextTxUntilBlock(l1BlockNumber) {
+        this.nextWait = {
+            l1BlockNumber: BigInt(l1BlockNumber)
+        };
+    }
+    /** Delays the next tx to be sent so it lands on the given timestamp. */ pauseNextTxUntilTimestamp(l1Timestamp) {
+        this.nextWait = {
+            l1Timestamp: BigInt(l1Timestamp)
+        };
+    }
+    /** Delays the next tx to be sent indefinitely. */ cancelNextTx() {
+        this.nextWait = {
+            indefinitely: true
+        };
+    }
+    /**
+   * Sets max inclusion time into slot. If more than this many seconds have passed
+   * since the last L1 block was mined, then any tx will not be mined in the current
+   * L1 slot but will be deferred for the next one.
+   */ setMaxInclusionTimeIntoSlot(seconds) {
+        this.maxInclusionTimeIntoSlot = seconds;
+    }
+}
+/**
+ * Creates a new Delayer instance. Exposed so callers can create a single shared delayer
+ * and pass it to multiple `wrapClientWithDelayer` calls.
+ */ export function createDelayer(dateProvider, opts, bindings) {
+    return new Delayer(dateProvider, opts, bindings);
+}
+/** Tries to recover the sender address from a serialized signed transaction. */ async function tryRecoverSender(serializedTransaction) {
+    try {
+        return await recoverTransactionAddress({
+            serializedTransaction: serializedTransaction
+        });
+    } catch  {
+        return undefined;
+    }
+}
+/**
+ * Wraps a viem client with tx delaying logic. Returns the wrapped client.
+ * The delayer intercepts sendRawTransaction calls and delays them based on the delayer's state.
+ */ export function wrapClientWithDelayer(client, delayer) {
+    const logger = delayer.getLogger();
+    // Cast to ExtendedViemWalletClient for the extend chain since it has sendRawTransaction.
+    // The sendRawTransaction override is applied to all clients regardless of type.
+    const withRawTx = client// Tweak sendRawTransaction so it uses the delay defined in the delayer.
+    // Note that this will only work with local accounts (ie accounts for which we have the private key).
+    // Transactions signed by the node will not be delayed since they use sendTransaction directly,
+    // but we do not use them in our codebase at all.
+    .extend((client)=>({
+            async sendRawTransaction (...args) {
+                let wait;
+                let txHash;
+                const { serializedTransaction } = args[0];
+                const publicClient = client;
+                const sender = await tryRecoverSender(serializedTransaction);
+                if (delayer.nextWait !== undefined) {
+                    // Check if we have been instructed to delay the next tx.
+                    const waitUntil = delayer.nextWait;
+                    delayer.nextWait = undefined;
+                    // Compute the tx hash manually so we emulate sendRawTransaction response
+                    txHash = computeTxHash(serializedTransaction);
+                    // Cancel tx outright if instructed
+                    if ('indefinitely' in waitUntil && waitUntil.indefinitely) {
+                        logger.info(`Cancelling tx ${txHash}`, {
+                            sender
+                        });
+                        delayer.cancelledTxs.push(serializedTransaction);
+                        return Promise.resolve(txHash);
+                    }
+                    // Or wait until the desired block number or timestamp
+                    wait = 'l1BlockNumber' in waitUntil ? waitUntilBlock(publicClient, waitUntil.l1BlockNumber - 1n, logger) : 'l1Timestamp' in waitUntil ? waitUntilL1Timestamp(publicClient, waitUntil.l1Timestamp - delayer.ethereumSlotDuration, logger) : undefined;
+                    logger.info(`Delaying tx ${txHash} until ${inspect(waitUntil)}`, {
+                        sender,
+                        argsLen: args.length,
+                        ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars')
+                    });
+                } else if (delayer.maxInclusionTimeIntoSlot !== undefined) {
+                    // Check if we need to delay txs sent too close to the end of the slot.
+                    const currentBlock = await publicClient.getBlock({
+                        includeTransactions: false
+                    });
+                    const { timestamp: lastBlockTimestamp, number } = currentBlock;
+                    const now = delayer.dateProvider.now();
+                    txHash = computeTxHash(serializedTransaction);
+                    const logData = {
+                        sender,
+                        ...omit(parseTransaction(serializedTransaction), 'data', 'sidecars'),
+                        lastBlockTimestamp,
+                        now,
+                        maxInclusionTimeIntoSlot: delayer.maxInclusionTimeIntoSlot
+                    };
+                    if (now / 1000 - Number(lastBlockTimestamp) > delayer.maxInclusionTimeIntoSlot) {
+                        // If the last block was mined more than `maxInclusionTimeIntoSlot` seconds ago, then we cannot include
+                        // any txs in the current slot, so we delay the tx until the next slot.
+                        logger.info(`Delaying inclusion of tx ${txHash} until the next slot since it was sent too late`, logData);
+                        wait = waitUntilBlock(publicClient, number + 1n, logger);
+                    } else {
+                        logger.debug(`Immediately sending tx ${txHash} as it was received early enough in the slot`, logData);
+                    }
+                }
+                if (wait !== undefined) {
+                    // Do not await here so we can return the tx hash immediately as if it had been sent on the spot.
+                    // Instead, delay it so it lands on the desired block number or timestamp, assuming anvil will
+                    // mine it immediately.
+                    void wait.then(async ()=>{
+                        const clientTxHash = await client.sendRawTransaction(...args);
+                        if (clientTxHash !== txHash) {
+                            logger.error(`Tx hash returned by the client does not match computed one`, {
+                                clientTxHash,
+                                computedTxHash: txHash
+                            });
+                        }
+                        logger.info(`Sent previously delayed tx ${clientTxHash}`, {
+                            sender
+                        });
+                        delayer.sentTxHashes.push(clientTxHash);
+                    }).catch((err)=>logger.error(`Error sending tx after delay`, err));
+                    return Promise.resolve(txHash);
+                } else {
+                    const txHash = await client.sendRawTransaction(...args);
+                    logger.debug(`Sent tx immediately ${txHash}`, {
+                        sender
+                    });
+                    delayer.sentTxHashes.push(txHash);
+                    return txHash;
+                }
+            }
+        }));
+    // Only re-bind wallet actions (sendTransaction, writeContract, deployContract) for wallet clients.
+    // This is needed for tests that use wallet actions directly rather than sendRawTransaction.
+    const isWalletClient = 'account' in client && client.account !== undefined;
+    const extended = isWalletClient ? withRawTx// Re-extend with sendTransaction so it uses the modified sendRawTransaction.
+    .extend((client)=>({
+            sendTransaction: walletActions(client).sendTransaction
+        }))// And with the actions that depend on the modified sendTransaction
+    .extend((client)=>({
+            writeContract: walletActions(client).writeContract,
+            deployContract: walletActions(client).deployContract
+        })) : withRawTx;
+    return extended;
+}
+/**
+ * Compute the tx hash given the serialized tx. Note that if this is a blob tx, we need to
+ * exclude the blobs, commitments, and proofs from the hash.
+ */ function computeTxHash(serializedTransaction) {
+    if (serializedTransaction.startsWith('0x03')) {
+        const parsed = parseTransaction(serializedTransaction);
+        if (parsed.blobs || parsed.sidecars) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { blobs, sidecars, ...rest } = parsed;
+            return keccak256(serializeTransaction({
+                type: 'eip4844',
+                ...rest
+            }));
+        }
+    }
+    return keccak256(serializedTransaction);
+}

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 { };

package/dest/publisher_manager.d.ts

@@ -0,0 +1,16 @@
+import { type LoggerBindings } from '@aztec/foundation/log';
+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;
+    private config;
+    constructor(publishers: UtilsType[], config: {
+        publisherAllowInvalidStates?: boolean;
+    }, bindings?: LoggerBindings);
+    /** Loads the state of all publishers and resumes monitoring any pending txs */
+    loadState(): Promise<void>;
+    getAvailablePublisher(filter?: PublisherFilter<UtilsType>): Promise<UtilsType>;
+    interrupt(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGlzaGVyX21hbmFnZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9wdWJsaXNoZXJfbWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQWUsS0FBSyxjQUFjLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFFdkYsT0FBTyxFQUFFLFNBQVMsRUFBZ0IsTUFBTSx3QkFBd0IsQ0FBQztBQXdCakUsTUFBTSxNQUFNLGVBQWUsQ0FBQyxTQUFTLFNBQVMsU0FBUyxJQUFJLENBQUMsS0FBSyxFQUFFLFNBQVMsS0FBSyxPQUFPLENBQUM7QUFFekYscUJBQWEsZ0JBQWdCLENBQUMsU0FBUyxTQUFTLFNBQVMsR0FBRyxTQUFTO0lBS2pFLE9BQU8sQ0FBQyxVQUFVO0lBSnBCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFDcEIsT0FBTyxDQUFDLE1BQU0sQ0FBNEM7SUFFMUQsWUFDVSxVQUFVLEVBQUUsU0FBUyxFQUFFLEVBQy9CLE1BQU0sRUFBRTtRQUFFLDJCQUEyQixDQUFDLEVBQUUsT0FBTyxDQUFBO0tBQUUsRUFDakQsUUFBUSxDQUFDLEVBQUUsY0FBYyxFQU0xQjtJQUVELCtFQUErRTtJQUNsRSxTQUFTLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQUV0QztJQVFZLHFCQUFxQixDQUFDLE1BQU0sR0FBRSxlQUFlLENBQUMsU0FBUyxDQUFjLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQStDdEc7SUFFTSxTQUFTLFNBRWY7Q0FDRiJ9

package/dest/publisher_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publisher_manager.d.ts","sourceRoot":"","sources":["../src/publisher_manager.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,uBAAuB,CAAC;AAEvF,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,CAAS;IACpB,OAAO,CAAC,MAAM,CAA4C;IAE1D,YACU,UAAU,EAAE,SAAS,EAAE,EAC/B,MAAM,EAAE;QAAE,2BAA2B,CAAC,EAAE,OAAO,CAAA;KAAE,EACjD,QAAQ,CAAC,EAAE,cAAc,EAM1B;IAED,+EAA+E;IAClE,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAEtC;IAQY,qBAAqB,CAAC,MAAM,GAAE,eAAe,CAAC,SAAS,CAAc,GAAG,OAAO,CAAC,SAAS,CAAC,CA+CtG;IAEM,SAAS,SAEf;CACF"}

package/dest/publisher_manager.js

@@ -0,0 +1,88 @@
+import { pick } from '@aztec/foundation/collection';
+import { createLogger } from '@aztec/foundation/log';
+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,
+    // 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
+];
+// Which states represent a busy publisher that we should avoid if possible
+const busyStates = [
+    TxUtilsState.SENT,
+    TxUtilsState.SPEED_UP,
+    TxUtilsState.CANCELLED,
+    TxUtilsState.NOT_MINED
+];
+export class PublisherManager {
+    publishers;
+    log;
+    config;
+    constructor(publishers, config, bindings){
+        this.publishers = publishers;
+        this.log = createLogger('publisher:manager', bindings);
+        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 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
+        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.`);
+        }
+        // Get the balances
+        const publishersWithBalance = await Promise.all(validPublishers.map(async (pub)=>{
+            return {
+                balance: await pub.getSenderBalance(),
+                publisher: pub
+            };
+        }));
+        // Sort based on state, then balance, then time since last use
+        const sortedPublishers = publishersWithBalance.sort((a, b)=>{
+            const stateComparison = sortOrder.indexOf(a.publisher.state) - sortOrder.indexOf(b.publisher.state);
+            if (stateComparison !== 0) {
+                return stateComparison;
+            }
+            const balanceComparison = Number(b.balance - a.balance);
+            if (balanceComparison !== 0) {
+                return balanceComparison;
+            }
+            const lastUsedComparison = Number((a.publisher.lastMinedAtBlockNumber ?? 0n) - (b.publisher.lastMinedAtBlockNumber ?? 0n));
+            return lastUsedComparison;
+        });
+        return sortedPublishers[0].publisher;
+    }
+    interrupt() {
+        this.publishers.forEach((pub)=>pub.interrupt());
+    }
+}

package/dest/queries.d.ts

@@ -1,5 +1,5 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { L1ContractsConfig } from './config.js';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type L1ContractsConfig } from './config.js';
 import type { ViemPublicClient } from './types.js';
 /** Reads the L1ContractsConfig from L1 contracts. */
 export declare function getL1ContractsConfig(publicClient: ViemPublicClient, addresses: {
@@ -8,5 +8,7 @@ export declare function getL1ContractsConfig(publicClient: ViemPublicClient, add
 }): Promise<Omit<L1ContractsConfig, 'ethereumSlotDuration'> & {
     l1StartBlock: bigint;
     l1GenesisTime: bigint;
+    rollupVersion: number;
+    genesisArchiveTreeRoot: `0x${string}`;
 }>;
-//# sourceMappingURL=queries.d.ts.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcmllcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3F1ZXJpZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRTNELE9BQU8sRUFBNEIsS0FBSyxpQkFBaUIsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUsvRSxPQUFPLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVuRCxxREFBcUQ7QUFDckQsd0JBQXNCLG9CQUFvQixDQUN4QyxZQUFZLEVBQUUsZ0JBQWdCLEVBQzlCLFNBQVMsRUFBRTtJQUFFLGlCQUFpQixFQUFFLFVBQVUsQ0FBQztJQUFDLGFBQWEsQ0FBQyxFQUFFLFVBQVUsQ0FBQTtDQUFFLEdBQ3ZFLE9BQU8sQ0FDUixJQUFJLENBQUMsaUJBQWlCLEVBQUUsc0JBQXNCLENBQUMsR0FBRztJQUNoRCxZQUFZLEVBQUUsTUFBTSxDQUFDO0lBQ3JCLGFBQWEsRUFBRSxNQUFNLENBQUM7SUFDdEIsYUFBYSxFQUFFLE1BQU0sQ0FBQztJQUN0QixzQkFBc0IsRUFBRSxLQUFLLE1BQU0sRUFBRSxDQUFDO0NBQ3ZDLENBQ0YsQ0F1R0EifQ==

package/dest/queries.d.ts.map

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

package/dest/queries.js

@@ -1,35 +1,84 @@
-import { GovernanceContract } from './contracts/governance.js';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { DefaultL1ContractsConfig } from './config.js';
+import { ReadOnlyGovernanceContract } from './contracts/governance.js';
+import { GovernanceProposerContract } from './contracts/governance_proposer.js';
+import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
 /** Reads the L1ContractsConfig from L1 contracts. */ export async function getL1ContractsConfig(publicClient, addresses) {
-    const governance = new GovernanceContract(addresses.governanceAddress.toString(), publicClient, undefined);
-    const governanceProposer = await governance.getProposer();
-    const rollupAddress = addresses.rollupAddress ?? (await governance.getGovernanceAddresses()).rollupAddress;
+    const governance = new ReadOnlyGovernanceContract(addresses.governanceAddress.toString(), publicClient);
+    const governanceProposerAddress = await governance.getGovernanceProposerAddress();
+    const governanceProposer = new GovernanceProposerContract(publicClient, governanceProposerAddress.toString());
+    const rollupAddress = addresses.rollupAddress ?? await governanceProposer.getRollupAddress();
     const rollup = new RollupContract(publicClient, rollupAddress.toString());
     const slasherProposer = await rollup.getSlashingProposer();
-    const [l1StartBlock, l1GenesisTime, aztecEpochDuration, aztecProofSubmissionWindow, aztecSlotDuration, aztecTargetCommitteeSize, minimumStake, governanceProposerQuorum, governanceProposerRoundSize, slashingQuorum, slashingRoundSize] = await Promise.all([
+    const slasher = await rollup.getSlasherContract();
+    const rollupAddresses = await rollup.getRollupAddresses();
+    const inboxContract = new InboxContract(publicClient, rollupAddresses.inboxAddress.toString());
+    const [l1StartBlock, l1GenesisTime, aztecEpochDuration, aztecSlotDuration, aztecProofSubmissionEpochs, aztecTargetCommitteeSize, lagInEpochsForValidatorSet, lagInEpochsForRandao, inboxLag, activationThreshold, ejectionThreshold, localEjectionThreshold, governanceProposerQuorum, governanceProposerRoundSize, slashingQuorum, slashingRoundSize, slashingLifetimeInRounds, slashingExecutionDelayInRounds, slashingOffsetInRounds, slashingAmounts, slashingVetoer, slashingDisableDuration, manaTarget, provingCostPerMana, rollupVersion, genesisArchiveTreeRoot, exitDelay] = await Promise.all([
         rollup.getL1StartBlock(),
         rollup.getL1GenesisTime(),
         rollup.getEpochDuration(),
-        rollup.getProofSubmissionWindow(),
         rollup.getSlotDuration(),
+        rollup.getProofSubmissionEpochs(),
         rollup.getTargetCommitteeSize(),
-        rollup.getMinimumStake(),
+        rollup.getLagInEpochsForValidatorSet(),
+        rollup.getLagInEpochsForRandao(),
+        inboxContract.getLag(),
+        rollup.getActivationThreshold(),
+        rollup.getEjectionThreshold(),
+        rollup.getLocalEjectionThreshold(),
         governanceProposer.getQuorumSize(),
         governanceProposer.getRoundSize(),
-        slasherProposer.getQuorumSize(),
-        slasherProposer.getRoundSize()
+        slasherProposer?.getQuorumSize() ?? 0n,
+        slasherProposer?.getRoundSize() ?? 0n,
+        slasherProposer?.getLifetimeInRounds() ?? 0n,
+        slasherProposer?.getExecutionDelayInRounds() ?? 0n,
+        slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
+        slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [
+            0n,
+            0n,
+            0n
+        ],
+        slasher?.getVetoer() ?? EthAddress.ZERO,
+        slasher?.getSlashingDisableDuration() ?? 0,
+        rollup.getManaTarget(),
+        rollup.getProvingCostPerMana(),
+        rollup.getVersion(),
+        rollup.getGenesisArchiveTreeRoot(),
+        rollup.getExitDelay()
     ]);
     return {
         l1StartBlock,
         l1GenesisTime,
         aztecEpochDuration: Number(aztecEpochDuration),
-        aztecProofSubmissionWindow: Number(aztecProofSubmissionWindow),
         aztecSlotDuration: Number(aztecSlotDuration),
+        aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
         aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+        lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+        lagInEpochsForRandao: Number(lagInEpochsForRandao),
+        inboxLag: Number(inboxLag),
         governanceProposerQuorum: Number(governanceProposerQuorum),
         governanceProposerRoundSize: Number(governanceProposerRoundSize),
-        minimumStake,
+        governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
+        activationThreshold,
+        ejectionThreshold,
+        localEjectionThreshold,
         slashingQuorum: Number(slashingQuorum),
-        slashingRoundSize: Number(slashingRoundSize)
+        slashingRoundSizeInEpochs: Number(Number(slashingRoundSize) / aztecEpochDuration),
+        slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
+        slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+        slashingVetoer,
+        slashingDisableDuration,
+        manaTarget,
+        provingCostPerMana: provingCostPerMana,
+        rollupVersion: Number(rollupVersion),
+        genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
+        exitDelaySeconds: Number(exitDelay),
+        slasherFlavor: slasherProposer?.type ?? 'tally',
+        slashingOffsetInRounds: Number(slashingOffsetInRounds),
+        slashAmountSmall: slashingAmounts[0],
+        slashAmountMedium: slashingAmounts[1],
+        slashAmountLarge: slashingAmounts[2],
+        initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset
     };
 }