@aztec/p2p 0.0.1-commit.96dac018d → 0.0.1-commit.993d240

package/dest/mem_pools/tx_pool_v2/tx_pool_v2_impl.js

@@ -1,4 +1,5 @@
 import { BlockNumber } from '@aztec/foundation/branded-types';
+import { FifoSet } from '@aztec/foundation/fifo-set';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
@@ -6,11 +7,16 @@ import { DatabasePublicStateSource } from '@aztec/stdlib/trees';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { TxArchive } from './archive/index.js';
 import { DeletedPool } from './deleted_pool.js';
-import { EvictionManager, FeePayerBalanceEvictionRule, FeePayerBalancePreAddRule, InvalidTxsAfterMiningRule, InvalidTxsAfterReorgRule, LowPriorityEvictionRule, LowPriorityPreAddRule, NullifierConflictRule, TxPoolRejectionCode } from './eviction/index.js';
+import { EvictionManager, FeePayerBalanceEvictionRule, FeePayerBalancePreAddRule, InsufficientFeePerGasEvictionRule, InvalidTxsAfterMiningRule, InvalidTxsAfterReorgRule, LowPriorityEvictionRule, LowPriorityPreAddRule, NullifierConflictRule, TxPoolRejectionCode } from './eviction/index.js';
 import { TxPoolV2Instrumentation } from './instrumentation.js';
 import { DEFAULT_TX_POOL_V2_CONFIG } from './interfaces.js';
 import { buildTxMetaData, checkNullifierConflict } from './tx_metadata.js';
 import { TxPoolIndices } from './tx_pool_indices.js';
+/**
+ * Maximum number of full transactions to load into memory at once when finalizing a block.
+ * Bounds peak memory while archiving and hard-deleting mined txs (~23k txs/epoch at 10 TPS would
+ * otherwise OOM the node).
+ */ const FINALIZE_BLOCK_CHUNK_SIZE = 100;
 /**
  * Implementation of TxPoolV2 logic.
  *
@@ -23,6 +29,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
     #l2BlockSource;
     #worldStateSynchronizer;
     #createTxValidator;
+    #checkAllowedSetupCalls;
     // === In-Memory Indices ===
     #indices = new TxPoolIndices();
     // === Config & Services ===
@@ -32,7 +39,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
     #evictionManager;
     #dateProvider;
     #instrumentation;
-    #evictedTxHashes = new Set();
+    #evictedTxHashes;
     #log;
     #callbacks;
     constructor(store, archiveStore, deps, callbacks, telemetry, config = {}, dateProvider, log){
@@ -41,10 +48,12 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         this.#l2BlockSource = deps.l2BlockSource;
         this.#worldStateSynchronizer = deps.worldStateSynchronizer;
         this.#createTxValidator = deps.createTxValidator;
+        this.#checkAllowedSetupCalls = deps.checkAllowedSetupCalls;
         this.#config = {
             ...DEFAULT_TX_POOL_V2_CONFIG,
             ...config
         };
+        this.#evictedTxHashes = FifoSet.withLimit(this.#config.evictedTxCacheSize);
         this.#archive = new TxArchive(archiveStore, this.#config.archivedTxLimit, log);
         this.#deletedPool = new DeletedPool(store, this.#txsDB, log);
         this.#dateProvider = dateProvider;
@@ -61,6 +70,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         }));
         // Post-event eviction rules (run after events to check ALL pending txs)
         this.#evictionManager.registerRule(new InvalidTxsAfterMiningRule());
+        this.#evictionManager.registerRule(new InsufficientFeePerGasEvictionRule(deps.blockMinFeesProvider));
         this.#evictionManager.registerRule(new InvalidTxsAfterReorgRule(deps.worldStateSynchronizer));
         this.#evictionManager.registerRule(new FeePayerBalanceEvictionRule(deps.worldStateSynchronizer));
         // LowPriorityEvictionRule handles cases where txs become pending via prepareForSlot (unprotect)
@@ -81,30 +91,63 @@ import { TxPoolIndices } from './tx_pool_indices.js';
    */ async hydrateFromDatabase() {
         // Step 0: Hydrate deleted pool state
         await this.#deletedPool.hydrateFromDatabase();
-        // Step 1: Load all transactions from DB (excluding soft-deleted)
-        const { loaded, errors: deserializationErrors } = await this.#loadAllTxsFromDb();
-        // Step 2: Check mined status for each tx
-        await this.#markMinedStatusBatch(loaded.map((l)=>l.meta));
-        // Step 3: Partition by mined status
-        const mined = [];
-        const nonMined = [];
-        for (const entry of loaded){
-            if (entry.meta.minedL2BlockId !== undefined) {
-                mined.push(entry.meta);
+        // Step 1: Stream txs from DB, building metadata and mined status one at a time.
+        const minedMetas = [];
+        const pendingMetas = [];
+        const deserializationErrors = [];
+        for await (const [txHashStr, buffer] of this.#txsDB.entriesAsync()){
+            // Skip soft-deleted transactions - they stay in DB but not in indices
+            if (this.#deletedPool.isSoftDeleted(txHashStr)) {
+                continue;
+            }
+            let meta;
+            let txEffect;
+            try {
+                const tx = Tx.fromBuffer(buffer);
+                // Resolve allowed-setup-calls and the tx effect concurrently
+                // getTxEffect failures are non-fatal (we just treat the tx as not-yet-mined), so
+                // its rejection is swallowed before the Promise.all so it can't fail-fast the batch.
+                const txEffectPromise = this.#l2BlockSource.getTxEffect(tx.getTxHash()).catch((err)=>{
+                    this.#log.warn(`Failed to check mined status for tx ${txHashStr}`, {
+                        err
+                    });
+                    return undefined;
+                });
+                const [allowedSetupCalls, fetchedTxEffect] = await Promise.all([
+                    this.#checkAllowedSetupCalls(tx),
+                    txEffectPromise
+                ]);
+                meta = await buildTxMetaData(tx, allowedSetupCalls);
+                txEffect = fetchedTxEffect;
+            } catch (err) {
+                this.#log.warn(`Failed to deserialize tx ${txHashStr}, deleting`, {
+                    err
+                });
+                deserializationErrors.push(txHashStr);
+                continue;
+            }
+            if (txEffect) {
+                meta.minedL2BlockId = {
+                    number: txEffect.l2BlockNumber,
+                    hash: txEffect.l2BlockHash.toString()
+                };
+            }
+            if (meta.minedL2BlockId !== undefined) {
+                minedMetas.push(meta);
             } else {
-                nonMined.push(entry);
+                pendingMetas.push(meta);
             }
         }
-        // Step 4: Validate non-mined transactions
-        const { valid, invalid } = await this.#revalidateMetadata(nonMined.map((e)=>e.meta), 'on startup');
-        // Step 5: Populate mined indices (these don't need conflict resolution)
-        for (const meta of mined){
+        // Step 2: Validate non-mined transactions
+        const { valid, invalid } = await this.#revalidateMetadata(pendingMetas, 'on startup');
+        // Step 3: Populate mined indices (these don't need conflict resolution)
+        for (const meta of minedMetas){
             this.#indices.addMined(meta);
         }
-        // Step 6: Rebuild pending pool by running pre-add rules for each tx
+        // Step 4: Rebuild pending pool by running pre-add rules for each tx
         // This resolves nullifier conflicts, fee payer balance issues, and pool size limits
         const { rejected } = await this.#rebuildPendingPool(valid);
-        // Step 7: Delete invalid and rejected txs from DB only (indices were never populated for these)
+        // Step 5: Delete invalid and rejected txs from DB only (indices were never populated for these)
         const toDelete = [
             ...deserializationErrors,
             ...invalid,
@@ -128,9 +171,32 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         const rejected = [];
         const errors = new Map();
         const acceptedPending = new Set();
+        // Phase 1: Pre-compute all throwable I/O outside the transaction.
+        // If any pre-computation throws, the entire call fails before mutations happen.
+        const precomputed = new Map();
+        const validator = await this.#createTxValidator();
+        for (const tx of txs){
+            const txHash = tx.getTxHash();
+            const txHashStr = txHash.toString();
+            const meta = await buildTxMetaData(tx);
+            const minedBlockId = await this.#getMinedBlockId(txHash);
+            // Validate non-mined txs (mined and pre-protected txs bypass validation inside the transaction)
+            let isValid = true;
+            if (!minedBlockId) {
+                isValid = await this.#validateMeta(meta, validator);
+            }
+            precomputed.set(txHashStr, {
+                meta,
+                minedBlockId,
+                isValid
+            });
+        }
+        // Phase 2: Apply mutations inside the transaction using only pre-computed results,
+        // in-memory reads, and buffered DB writes. Nothing here can throw an unhandled exception.
         const poolAccess = this.#createPreAddPoolAccess();
         const preAddContext = opts.feeComparisonOnly !== undefined ? {
-            feeComparisonOnly: opts.feeComparisonOnly
+            feeComparisonOnly: opts.feeComparisonOnly,
+            priceBumpPercentage: this.#config.priceBumpPercentage
         } : undefined;
         await this.#store.transactionAsync(async ()=>{
             for (const tx of txs){
@@ -141,28 +207,28 @@ import { TxPoolIndices } from './tx_pool_indices.js';
                     ignored.push(txHash);
                     continue;
                 }
-                // Check mined status first (applies to all paths)
-                const minedBlockId = await this.#getMinedBlockId(txHash);
+                const { meta, minedBlockId, isValid } = precomputed.get(txHashStr);
                 const preProtectedSlot = this.#indices.getProtectionSlot(txHashStr);
                 if (minedBlockId) {
                     // Already mined - add directly (protection already set if pre-protected)
                     await this.#addTx(tx, {
                         mined: minedBlockId
-                    }, opts);
+                    }, opts, meta);
                     accepted.push(txHash);
                 } else if (preProtectedSlot !== undefined) {
                     // Pre-protected and not mined - add as protected (bypass validation)
                     await this.#addTx(tx, {
                         protected: preProtectedSlot
-                    }, opts);
+                    }, opts, meta);
                     accepted.push(txHash);
+                } else if (!isValid) {
+                    // Failed pre-computed validation
+                    rejected.push(txHash);
                 } else {
-                    // Regular pending tx - validate and run pre-add rules
-                    const result = await this.#tryAddRegularPendingTx(tx, opts, poolAccess, acceptedPending, ignored, errors, preAddContext);
+                    // Regular pending tx - run pre-add rules using pre-computed metadata
+                    const result = await this.#tryAddRegularPendingTx(tx, meta, opts, poolAccess, acceptedPending, ignored, errors, preAddContext);
                     if (result.status === 'accepted') {
                         acceptedPending.add(txHashStr);
-                    } else if (result.status === 'rejected') {
-                        rejected.push(txHash);
                     } else {
                         ignored.push(txHash);
                     }
@@ -197,18 +263,10 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             } : {}
         };
     }
-    /** Validates and adds a regular pending tx. Returns status. */ async #tryAddRegularPendingTx(tx, opts, poolAccess, acceptedPending, ignored, errors, preAddContext) {
-        const txHash = tx.getTxHash();
-        const txHashStr = txHash.toString();
-        // Build metadata and validate using metadata
-        const meta = await buildTxMetaData(tx);
-        if (!await this.#validateMeta(meta)) {
-            return {
-                status: 'rejected'
-            };
-        }
+    /** Adds a validated pending tx, running pre-add rules and evicting conflicts. */ async #tryAddRegularPendingTx(tx, precomputedMeta, opts, poolAccess, acceptedPending, ignored, errors, preAddContext) {
+        const txHashStr = tx.getTxHash().toString();
         // Run pre-add rules
-        const preAddResult = await this.#evictionManager.runPreAddRules(meta, poolAccess, preAddContext);
+        const preAddResult = await this.#evictionManager.runPreAddRules(precomputedMeta, poolAccess, preAddContext);
         if (preAddResult.shouldIgnore) {
             this.#log.debug(`Ignoring tx ${txHashStr}: ${preAddResult.reason?.message ?? 'unknown reason'}`);
             if (preAddResult.reason && preAddResult.reason.code !== TxPoolRejectionCode.INTERNAL_ERROR) {
@@ -254,7 +312,7 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             };
         }
         // Add the transaction
-        await this.#addTx(tx, 'pending', opts);
+        await this.#addTx(tx, 'pending', opts, precomputedMeta);
         return {
             status: 'accepted'
         };
@@ -263,33 +321,44 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         const txHashStr = tx.getTxHash().toString();
         // Check if already in pool
         if (this.#indices.has(txHashStr)) {
+            this.#log.verbose(`canAddPendingTx: tx ${txHashStr} already in pool`);
             return 'ignored';
         }
         // Build metadata and check pre-add rules
         const meta = await buildTxMetaData(tx);
         const poolAccess = this.#createPreAddPoolAccess();
         const preAddResult = await this.#evictionManager.runPreAddRules(meta, poolAccess);
-        return preAddResult.shouldIgnore ? 'ignored' : 'accepted';
+        if (preAddResult.shouldIgnore) {
+            this.#log.verbose(`canAddPendingTx: tx ${txHashStr} ignored by pre-add rule`, {
+                reason: preAddResult.reason?.message ?? 'no reason provided'
+            });
+            return 'ignored';
+        }
+        return 'accepted';
     }
     async addProtectedTxs(txs, block, opts) {
         const slotNumber = block.globalVariables.slotNumber;
+        // Precompute setup-call allow-list flags outside the store transaction
+        const allowedFlags = await Promise.all(txs.map((tx)=>this.#checkAllowedSetupCalls(tx)));
         await this.#store.transactionAsync(async ()=>{
-            for (const tx of txs){
+            for(let i = 0; i < txs.length; i++){
+                const tx = txs[i];
                 const txHash = tx.getTxHash();
                 const txHashStr = txHash.toString();
                 const isNew = !this.#indices.has(txHashStr);
                 const minedBlockId = await this.#getMinedBlockId(txHash);
                 if (isNew) {
+                    const meta = await buildTxMetaData(tx, allowedFlags[i]);
                     // New tx - add as mined or protected (callback emitted by #addTx)
                     if (minedBlockId) {
                         await this.#addTx(tx, {
                             mined: minedBlockId
-                        }, opts);
+                        }, opts, meta);
                         this.#indices.setProtection(txHashStr, slotNumber);
                     } else {
                         await this.#addTx(tx, {
                             protected: slotNumber
-                        }, opts);
+                        }, opts, meta);
                     }
                 } else {
                     // Existing tx - update protection and mined status
@@ -396,6 +465,9 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             // Step 5: Run post-event eviction rules (inside transaction for atomicity)
             await this.#evictionManager.evictAfterNewBlock(block.header, nullifiers, feePayers);
         });
+        if (found.length > 0) {
+            this.#callbacks.onTxsMined(found.map((m)=>m.txHash));
+        }
         this.#log.info(`Marked ${found.length} txs as mined in block ${blockId.number}`);
     }
     async prepareForSlot(slotNumber) {
@@ -488,25 +560,28 @@ import { TxPoolIndices } from './tx_pool_indices.js';
         const blockNumber = block.globalVariables.blockNumber;
         // Step 1: Find mined txs at or before finalized block
         const minedTxsToFinalize = this.#indices.findTxsMinedAtOrBefore(blockNumber);
-        await this.#store.transactionAsync(async ()=>{
-            // Step 2: Collect mined txs for archiving (before deletion)
-            const txsToArchive = [];
-            if (this.#archive.isEnabled()) {
-                for (const txHashStr of minedTxsToFinalize){
+        // Step 2: Archive in chunks if archiving is enabled. Hydrating an entire epoch's worth of
+        // mined txs at once would OOM under load. When archiving is disabled there is no need to hydrate the txs at all.
+        if (this.#archive.isEnabled()) {
+            for(let i = 0; i < minedTxsToFinalize.length; i += FINALIZE_BLOCK_CHUNK_SIZE){
+                const chunk = minedTxsToFinalize.slice(i, i + FINALIZE_BLOCK_CHUNK_SIZE);
+                const txsToArchive = [];
+                for (const txHashStr of chunk){
                     const buffer = await this.#txsDB.getAsync(txHashStr);
                     if (buffer) {
                         txsToArchive.push(Tx.fromBuffer(buffer));
                     }
                 }
+                if (txsToArchive.length > 0) {
+                    await this.#archive.archiveTxs(txsToArchive);
+                }
             }
-            // Step 3: Delete mined txs from active pool
+        }
+        // Step 3: Delete mined txs from the active pool and finalize soft-deleted txs in one
+        // transaction. Only tx hashes are touched here, so memory is bounded and atomicity is preserved.
+        await this.#store.transactionAsync(async ()=>{
             await this.#deleteTxsBatch(minedTxsToFinalize);
-            // Step 4: Finalize soft-deleted txs
             await this.#deletedPool.finalizeBlock(blockNumber);
-            // Step 5: Archive mined txs
-            if (txsToArchive.length > 0) {
-                await this.#archive.archiveTxs(txsToArchive);
-            }
         });
         if (minedTxsToFinalize.length > 0) {
             this.#log.info(`Finalized ${minedTxsToFinalize.length} mined txs from blocks up to ${blockNumber}`, {
@@ -623,9 +698,9 @@ import { TxPoolIndices } from './tx_pool_indices.js';
     /**
    * Adds a new transaction to the pool with the specified state.
    * Emits onTxsAdded callback immediately after DB write.
-   */ async #addTx(tx, state, opts = {}) {
+   */ async #addTx(tx, state, opts = {}, precomputedMeta) {
         const txHashStr = tx.getTxHash().toString();
-        const meta = await buildTxMetaData(tx);
+        const meta = precomputedMeta ?? await buildTxMetaData(tx);
         meta.receivedAt = this.#dateProvider.now();
         await this.#txsDB.set(txHashStr, tx.toBuffer());
         await this.#deletedPool.clearSoftDeleted(txHashStr);
@@ -678,18 +753,10 @@ import { TxPoolIndices } from './tx_pool_indices.js';
                 txHash: txHashStr,
                 reason
             });
-            this.#addToEvictedCache(txHashStr);
+            this.#evictedTxHashes.add(txHashStr);
         }
         await this.#deleteTxsBatch(txHashes);
     }
-    /** Adds a tx hash to the bounded evicted cache, evicting the oldest entry if at capacity. */ #addToEvictedCache(txHashStr) {
-        if (this.#evictedTxHashes.size >= this.#config.evictedTxCacheSize) {
-            // FIFO eviction: remove the first (oldest) entry
-            const oldest = this.#evictedTxHashes.values().next().value;
-            this.#evictedTxHashes.delete(oldest);
-        }
-        this.#evictedTxHashes.add(txHashStr);
-    }
     // ============================================================================
     // PRIVATE HELPERS - Validation & Conflict Resolution
     // ============================================================================
@@ -770,50 +837,6 @@ import { TxPoolIndices } from './tx_pool_indices.js';
             hash: txEffect.l2BlockHash.toString()
         };
     }
-    /** Loads all transactions from the database, returning loaded txs and deserialization errors */ async #loadAllTxsFromDb() {
-        const loaded = [];
-        const errors = [];
-        for await (const [txHashStr, buffer] of this.#txsDB.entriesAsync()){
-            // Skip soft-deleted transactions - they stay in DB but not in indices
-            if (this.#deletedPool.isSoftDeleted(txHashStr)) {
-                continue;
-            }
-            try {
-                const tx = Tx.fromBuffer(buffer);
-                const meta = await buildTxMetaData(tx);
-                loaded.push({
-                    tx,
-                    meta
-                });
-            } catch (err) {
-                this.#log.warn(`Failed to deserialize tx ${txHashStr}, deleting`, {
-                    err
-                });
-                errors.push(txHashStr);
-            }
-        }
-        return {
-            loaded,
-            errors
-        };
-    }
-    /** Queries block source and marks mined status on transaction metadata */ async #markMinedStatusBatch(metas) {
-        for (const meta of metas){
-            try {
-                const txEffect = await this.#l2BlockSource.getTxEffect(TxHash.fromString(meta.txHash));
-                if (txEffect) {
-                    meta.minedL2BlockId = {
-                        number: txEffect.l2BlockNumber,
-                        hash: txEffect.l2BlockHash.toString()
-                    };
-                }
-            } catch (err) {
-                this.#log.warn(`Failed to check mined status for tx ${meta.txHash}`, {
-                    err
-                });
-            }
-        }
-    }
     /**
    * Rebuilds the pending pool by processing each tx through pre-add rules.
    * Starts with an empty pending pool and adds txs one by one, resolving conflicts.

package/dest/msg_validators/attestation_validator/attestation_validator.d.ts

@@ -1,10 +1,16 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { type Logger } from '@aztec/foundation/log';
-import { type CheckpointAttestation, type P2PValidator, type ValidationResult } from '@aztec/stdlib/p2p';
+import { type CheckpointAttestation, type CoordinationSignatureContext, type P2PValidator, type ValidationResult } from '@aztec/stdlib/p2p';
 export declare class CheckpointAttestationValidator implements P2PValidator<CheckpointAttestation> {
     protected epochCache: EpochCacheInterface;
     protected logger: Logger;
-    constructor(epochCache: EpochCacheInterface);
+    private readonly pipeliningWindow;
+    protected readonly signatureContext: CoordinationSignatureContext;
+    constructor(epochCache: EpochCacheInterface, opts: {
+        l1PublishingTime?: number;
+        p2pPropagationTime?: number;
+        signatureContext: CoordinationSignatureContext;
+    });
     validate(message: CheckpointAttestation): Promise<ValidationResult>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvYXR0ZXN0YXRpb25fdmFsaWRhdG9yL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRTlELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBQ0wsS0FBSyxxQkFBcUIsRUFDMUIsS0FBSyxZQUFZLEVBRWpCLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sbUJBQW1CLENBQUM7QUFJM0IscUJBQWEsOEJBQStCLFlBQVcsWUFBWSxDQUFDLHFCQUFxQixDQUFDO0lBQ3hGLFNBQVMsQ0FBQyxVQUFVLEVBQUUsbUJBQW1CLENBQUM7SUFDMUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFFekIsWUFBWSxVQUFVLEVBQUUsbUJBQW1CLEVBRzFDO0lBRUssUUFBUSxDQUFDLE9BQU8sRUFBRSxxQkFBcUIsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0E2RHhFO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXR0ZXN0YXRpb25fdmFsaWRhdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvYXR0ZXN0YXRpb25fdmFsaWRhdG9yL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRTlELE9BQU8sRUFBRSxLQUFLLE1BQU0sRUFBZ0IsTUFBTSx1QkFBdUIsQ0FBQztBQUNsRSxPQUFPLEVBQ0wsS0FBSyxxQkFBcUIsRUFDMUIsS0FBSyw0QkFBNEIsRUFDakMsS0FBSyxZQUFZLEVBRWpCLEtBQUssZ0JBQWdCLEVBRXRCLE1BQU0sbUJBQW1CLENBQUM7QUFJM0IscUJBQWEsOEJBQStCLFlBQVcsWUFBWSxDQUFDLHFCQUFxQixDQUFDO0lBQ3hGLFNBQVMsQ0FBQyxVQUFVLEVBQUUsbUJBQW1CLENBQUM7SUFDMUMsU0FBUyxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDekIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBbUI7SUFDcEQsU0FBUyxDQUFDLFFBQVEsQ0FBQyxnQkFBZ0IsRUFBRSw0QkFBNEIsQ0FBQztJQUVsRSxZQUNFLFVBQVUsRUFBRSxtQkFBbUIsRUFDL0IsSUFBSSxFQUFFO1FBQ0osZ0JBQWdCLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDMUIsa0JBQWtCLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDNUIsZ0JBQWdCLEVBQUUsNEJBQTRCLENBQUM7S0FDaEQsRUFTRjtJQUVLLFFBQVEsQ0FBQyxPQUFPLEVBQUUscUJBQXFCLEdBQUcsT0FBTyxDQUFDLGdCQUFnQixDQUFDLENBNkV4RTtDQUNGIn0=

package/dest/msg_validators/attestation_validator/attestation_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAI3B,qBAAa,8BAA+B,YAAW,YAAY,CAAC,qBAAqB,CAAC;IACxF,SAAS,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IAEzB,YAAY,UAAU,EAAE,mBAAmB,EAG1C;IAEK,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6DxE;CACF"}
+{"version":3,"file":"attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EACjC,KAAK,YAAY,EAEjB,KAAK,gBAAgB,EAEtB,MAAM,mBAAmB,CAAC;AAI3B,qBAAa,8BAA+B,YAAW,YAAY,CAAC,qBAAqB,CAAC;IACxF,SAAS,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAC1C,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,4BAA4B,CAAC;IAElE,YACE,UAAU,EAAE,mBAAmB,EAC/B,IAAI,EAAE;QACJ,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,gBAAgB,EAAE,4BAA4B,CAAC;KAChD,EASF;IAEK,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA6ExE;CACF"}

package/dest/msg_validators/attestation_validator/attestation_validator.js

@@ -1,31 +1,56 @@
 import { NoCommitteeError } from '@aztec/ethereum/contracts';
 import { createLogger } from '@aztec/foundation/log';
-import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
-import { isWithinClockTolerance } from '../clock_tolerance.js';
+import { PeerErrorSeverity, hasValidSignatureContext } from '@aztec/stdlib/p2p';
+import { PipeliningWindow, isWithinClockTolerance } from '../clock_tolerance.js';
 export class CheckpointAttestationValidator {
     epochCache;
     logger;
-    constructor(epochCache){
+    pipeliningWindow;
+    signatureContext;
+    constructor(epochCache, opts){
         this.epochCache = epochCache;
+        this.pipeliningWindow = new PipeliningWindow(epochCache, {
+            l1PublishingTime: opts.l1PublishingTime,
+            p2pPropagationTime: opts.p2pPropagationTime
+        });
+        this.signatureContext = opts.signatureContext;
         this.logger = createLogger('p2p:checkpoint-attestation-validator');
     }
     async validate(message) {
         const slotNumber = message.payload.header.slotNumber;
         try {
-            const { currentSlot, nextSlot } = this.epochCache.getCurrentAndNextSlot();
-            if (slotNumber !== currentSlot && slotNumber !== nextSlot) {
-                // Check if message is for previous slot and within clock tolerance
-                if (!isWithinClockTolerance(slotNumber, currentSlot, this.epochCache)) {
-                    this.logger.warn(`Checkpoint attestation slot ${slotNumber} is not current (${currentSlot}) or next (${nextSlot}) slot`);
+            // Cross-chain replay check: reject attestations that carry a foreign signing domain.
+            if (!hasValidSignatureContext(message.payload, this.signatureContext)) {
+                this.logger.warn(`Rejecting checkpoint attestation with foreign signature context for slot ${slotNumber}`, {
+                    chainId: message.payload.signatureContext.chainId,
+                    rollupAddress: message.payload.signatureContext.rollupAddress.toString(),
+                    expectedChainId: this.signatureContext.chainId,
+                    expectedRollupAddress: this.signatureContext.rollupAddress.toString()
+                });
+                return {
+                    result: 'reject',
+                    severity: PeerErrorSeverity.LowToleranceError
+                };
+            }
+            // Use target slots since proposals target pipeline slots (slot + 1 when pipelining).
+            const { targetSlot, nextSlot } = this.epochCache.getTargetAndNextSlot();
+            if (slotNumber !== targetSlot && slotNumber !== nextSlot) {
+                // When pipelining, accept attestations for the current slot (built in the previous slot)
+                // until the target slot reaches its L1 publish cutoff.
+                if (this.pipeliningWindow.acceptsAttestation(slotNumber)) {
+                // Fall through to remaining validation (signature, committee, etc.)
+                } else if (!isWithinClockTolerance(slotNumber, targetSlot, this.epochCache)) {
+                    this.logger.warn(`Checkpoint attestation slot ${slotNumber} is not current (${targetSlot}) or next (${nextSlot}) slot`);
                     return {
                         result: 'reject',
                         severity: PeerErrorSeverity.HighToleranceError
                     };
+                } else {
+                    this.logger.debug(`Ignoring checkpoint attestation for previous slot ${slotNumber} within clock tolerance`);
+                    return {
+                        result: 'ignore'
+                    };
                 }
-                this.logger.debug(`Ignoring checkpoint attestation for previous slot ${slotNumber} within clock tolerance`);
-                return {
-                    result: 'ignore'
-                };
             }
             // Verify the signature is valid
             const attester = message.getSender();

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.d.ts

@@ -1,5 +1,5 @@
 import type { EpochCacheInterface } from '@aztec/epoch-cache';
-import { type CheckpointAttestation, type ValidationResult } from '@aztec/stdlib/p2p';
+import { type CheckpointAttestation, type CoordinationSignatureContext, type ValidationResult } from '@aztec/stdlib/p2p';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 import type { AttestationPoolApi } from '../../mem_pools/attestation_pool/attestation_pool.js';
 import { CheckpointAttestationValidator } from './attestation_validator.js';
@@ -14,7 +14,11 @@ import { CheckpointAttestationValidator } from './attestation_validator.js';
 export declare class FishermanAttestationValidator extends CheckpointAttestationValidator {
     private attestationPool;
     private invalidAttestationCounter;
-    constructor(epochCache: EpochCacheInterface, attestationPool: AttestationPoolApi, telemetryClient: TelemetryClient);
+    constructor(epochCache: EpochCacheInterface, attestationPool: AttestationPoolApi, telemetryClient: TelemetryClient, opts: {
+        l1PublishingTime?: number;
+        p2pPropagationTime?: number;
+        signatureContext: CoordinationSignatureContext;
+    });
     validate(message: CheckpointAttestation): Promise<ValidationResult>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlzaGVybWFuX2F0dGVzdGF0aW9uX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci9maXNoZXJtYW5fYXR0ZXN0YXRpb25fdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUQsT0FBTyxFQUFFLEtBQUsscUJBQXFCLEVBQXFCLEtBQUssZ0JBQWdCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUN6RyxPQUFPLEVBQXVCLEtBQUssZUFBZSxFQUFrQyxNQUFNLHlCQUF5QixDQUFDO0FBRXBILE9BQU8sS0FBSyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sc0RBQXNELENBQUM7QUFDL0YsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFNUU7Ozs7Ozs7R0FPRztBQUNILHFCQUFhLDZCQUE4QixTQUFRLDhCQUE4QjtJQUs3RSxPQUFPLENBQUMsZUFBZTtJQUp6QixPQUFPLENBQUMseUJBQXlCLENBQUM7SUFFbEMsWUFDRSxVQUFVLEVBQUUsbUJBQW1CLEVBQ3ZCLGVBQWUsRUFBRSxrQkFBa0IsRUFDM0MsZUFBZSxFQUFFLGVBQWUsRUFhakM7SUFFYyxRQUFRLENBQUMsT0FBTyxFQUFFLHFCQUFxQixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQXdEakY7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlzaGVybWFuX2F0dGVzdGF0aW9uX3ZhbGlkYXRvci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL21zZ192YWxpZGF0b3JzL2F0dGVzdGF0aW9uX3ZhbGlkYXRvci9maXNoZXJtYW5fYXR0ZXN0YXRpb25fdmFsaWRhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUQsT0FBTyxFQUNMLEtBQUsscUJBQXFCLEVBQzFCLEtBQUssNEJBQTRCLEVBRWpDLEtBQUssZ0JBQWdCLEVBQ3RCLE1BQU0sbUJBQW1CLENBQUM7QUFDM0IsT0FBTyxFQUF1QixLQUFLLGVBQWUsRUFBa0MsTUFBTSx5QkFBeUIsQ0FBQztBQUVwSCxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNEQUFzRCxDQUFDO0FBQy9GLE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRTVFOzs7Ozs7O0dBT0c7QUFDSCxxQkFBYSw2QkFBOEIsU0FBUSw4QkFBOEI7SUFLN0UsT0FBTyxDQUFDLGVBQWU7SUFKekIsT0FBTyxDQUFDLHlCQUF5QixDQUFDO0lBRWxDLFlBQ0UsVUFBVSxFQUFFLG1CQUFtQixFQUN2QixlQUFlLEVBQUUsa0JBQWtCLEVBQzNDLGVBQWUsRUFBRSxlQUFlLEVBQ2hDLElBQUksRUFBRTtRQUNKLGdCQUFnQixDQUFDLEVBQUUsTUFBTSxDQUFDO1FBQzFCLGtCQUFrQixDQUFDLEVBQUUsTUFBTSxDQUFDO1FBQzVCLGdCQUFnQixFQUFFLDRCQUE0QixDQUFDO0tBQ2hELEVBYUY7SUFFYyxRQUFRLENBQUMsT0FBTyxFQUFFLHFCQUFxQixHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQXFEakY7Q0FDRiJ9

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fisherman_attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/fisherman_attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,KAAK,qBAAqB,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACzG,OAAO,EAAuB,KAAK,eAAe,EAAkC,MAAM,yBAAyB,CAAC;AAEpH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC/F,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,6BAA8B,SAAQ,8BAA8B;IAK7E,OAAO,CAAC,eAAe;IAJzB,OAAO,CAAC,yBAAyB,CAAC;IAElC,YACE,UAAU,EAAE,mBAAmB,EACvB,eAAe,EAAE,kBAAkB,EAC3C,eAAe,EAAE,eAAe,EAajC;IAEc,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwDjF;CACF"}
+{"version":3,"file":"fisherman_attestation_validator.d.ts","sourceRoot":"","sources":["../../../src/msg_validators/attestation_validator/fisherman_attestation_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,4BAA4B,EAEjC,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAuB,KAAK,eAAe,EAAkC,MAAM,yBAAyB,CAAC;AAEpH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC/F,OAAO,EAAE,8BAA8B,EAAE,MAAM,4BAA4B,CAAC;AAE5E;;;;;;;GAOG;AACH,qBAAa,6BAA8B,SAAQ,8BAA8B;IAK7E,OAAO,CAAC,eAAe;IAJzB,OAAO,CAAC,yBAAyB,CAAC;IAElC,YACE,UAAU,EAAE,mBAAmB,EACvB,eAAe,EAAE,kBAAkB,EAC3C,eAAe,EAAE,eAAe,EAChC,IAAI,EAAE;QACJ,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,gBAAgB,EAAE,4BAA4B,CAAC;KAChD,EAaF;IAEc,QAAQ,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAqDjF;CACF"}

package/dest/msg_validators/attestation_validator/fisherman_attestation_validator.js

@@ -11,8 +11,8 @@ import { CheckpointAttestationValidator } from './attestation_validator.js';
  */ export class FishermanAttestationValidator extends CheckpointAttestationValidator {
     attestationPool;
     invalidAttestationCounter;
-    constructor(epochCache, attestationPool, telemetryClient){
-        super(epochCache), this.attestationPool = attestationPool;
+    constructor(epochCache, attestationPool, telemetryClient, opts){
+        super(epochCache, opts), this.attestationPool = attestationPool;
         this.logger = this.logger.createChild('[FISHERMAN]');
         const meter = telemetryClient.getMeter('FishermanAttestationValidator');
         this.invalidAttestationCounter = createUpDownCounterWithDefault(meter, Metrics.VALIDATOR_INVALID_ATTESTATION_RECEIVED_COUNT, {
@@ -41,8 +41,7 @@ import { CheckpointAttestationValidator } from './attestation_validator.js';
                 result: 'accept'
             };
         }
-        const proposalId = message.archive.toString();
-        const proposal = await this.attestationPool.getCheckpointProposal(proposalId);
+        const proposal = await this.attestationPool.getCheckpointProposal(message.payload.header.slotNumber);
         if (proposal) {
             // Compare the attestation payload with the proposal payload
             if (!message.payload.equals(proposal)) {
@@ -67,7 +66,7 @@ import { CheckpointAttestationValidator } from './attestation_validator.js';
             }
         } else {
             // We might receive attestations before proposals in some cases
-            this.logger.debug(`Received attestation for slot ${slotNumberBigInt} but proposal not found yet. ` + `Proposal ID: ${proposalId}`);
+            this.logger.debug(`Received attestation for slot ${slotNumberBigInt} but proposal not found yet.`);
         }
         return {
             result: 'accept'

package/dest/msg_validators/clock_tolerance.d.ts

@@ -18,4 +18,15 @@ export declare const MAXIMUM_GOSSIP_CLOCK_DISPARITY_MS = 500;
  * @returns true if the message is for the previous slot AND we're within the clock tolerance window
  */
 export declare function isWithinClockTolerance(messageSlot: SlotNumber, currentSlot: SlotNumber, epochCache: EpochCacheInterface): boolean;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvY2tfdG9sZXJhbmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvY2xvY2tfdG9sZXJhbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRTdEOzs7Ozs7O0dBT0c7QUFDSCxlQUFPLE1BQU0saUNBQWlDLE1BQU0sQ0FBQztBQUVyRDs7Ozs7OztHQU9HO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUNwQyxXQUFXLEVBQUUsVUFBVSxFQUN2QixXQUFXLEVBQUUsVUFBVSxFQUN2QixVQUFVLEVBQUUsbUJBQW1CLEdBQzlCLE9BQU8sQ0F5QlQifQ==
+export declare class PipeliningWindow {
+    private readonly epochCache;
+    private readonly proposalWindowIntoTargetSlot;
+    private readonly attestationWindowIntoTargetSlot;
+    constructor(epochCache: EpochCacheInterface, opts?: {
+        p2pPropagationTime?: number;
+        l1PublishingTime?: number;
+    });
+    acceptsProposal(messageSlot: SlotNumber): boolean;
+    acceptsAttestation(messageSlot: SlotNumber): boolean;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvY2tfdG9sZXJhbmNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbXNnX3ZhbGlkYXRvcnMvY2xvY2tfdG9sZXJhbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDOUQsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBRzdEOzs7Ozs7O0dBT0c7QUFDSCxlQUFPLE1BQU0saUNBQWlDLE1BQU0sQ0FBQztBQUVyRDs7Ozs7OztHQU9HO0FBQ0gsd0JBQWdCLHNCQUFzQixDQUNwQyxXQUFXLEVBQUUsVUFBVSxFQUN2QixXQUFXLEVBQUUsVUFBVSxFQUN2QixVQUFVLEVBQUUsbUJBQW1CLEdBQzlCLE9BQU8sQ0EwQlQ7QUE0Q0QscUJBQWEsZ0JBQWdCO0lBS3pCLE9BQU8sQ0FBQyxRQUFRLENBQUMsVUFBVTtJQUo3QixPQUFPLENBQUMsUUFBUSxDQUFDLDRCQUE0QixDQUFTO0lBQ3RELE9BQU8sQ0FBQyxRQUFRLENBQUMsK0JBQStCLENBQVM7SUFFekQsWUFDbUIsVUFBVSxFQUFFLG1CQUFtQixFQUNoRCxJQUFJLEdBQUU7UUFDSixrQkFBa0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztRQUM1QixnQkFBZ0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQztLQUN0QixFQVlQO0lBRU0sZUFBZSxDQUFDLFdBQVcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUV2RDtJQUVNLGtCQUFrQixDQUFDLFdBQVcsRUFBRSxVQUFVLEdBQUcsT0FBTyxDQUUxRDtDQUNGIn0=

package/dest/msg_validators/clock_tolerance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clock_tolerance.d.ts","sourceRoot":"","sources":["../../src/msg_validators/clock_tolerance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAE7D;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,MAAM,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,UAAU,EACvB,WAAW,EAAE,UAAU,EACvB,UAAU,EAAE,mBAAmB,GAC9B,OAAO,CAyBT"}
+{"version":3,"file":"clock_tolerance.d.ts","sourceRoot":"","sources":["../../src/msg_validators/clock_tolerance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAG7D;;;;;;;GAOG;AACH,eAAO,MAAM,iCAAiC,MAAM,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,UAAU,EACvB,WAAW,EAAE,UAAU,EACvB,UAAU,EAAE,mBAAmB,GAC9B,OAAO,CA0BT;AA4CD,qBAAa,gBAAgB;IAKzB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAJ7B,OAAO,CAAC,QAAQ,CAAC,4BAA4B,CAAS;IACtD,OAAO,CAAC,QAAQ,CAAC,+BAA+B,CAAS;IAEzD,YACmB,UAAU,EAAE,mBAAmB,EAChD,IAAI,GAAE;QACJ,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;KACtB,EAYP;IAEM,eAAe,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAEvD;IAEM,kBAAkB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAE1D;CACF"}