@aztec/p2p 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/dest/mem_pools/attestation_pool/index.d.ts

@@ -1,3 +1,2 @@
-export * from './attestation_pool.js';
-export * from './memory_attestation_pool.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsOEJBQThCLENBQUMifQ==
+export { AttestationPool, type AttestationPoolApi, type TryAddResult, createTestAttestationPool, MAX_CHECKPOINT_PROPOSALS_PER_SLOT, MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER, } from './attestation_pool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZUFBZSxFQUNmLEtBQUssa0JBQWtCLEVBQ3ZCLEtBQUssWUFBWSxFQUNqQix5QkFBeUIsRUFDekIsaUNBQWlDLEVBQ2pDLGdDQUFnQyxFQUNoQyxvQ0FBb0MsR0FDckMsTUFBTSx1QkFBdUIsQ0FBQyJ9

package/dest/mem_pools/attestation_pool/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,YAAY,EACjB,yBAAyB,EACzB,iCAAiC,EACjC,gCAAgC,EAChC,oCAAoC,GACrC,MAAM,uBAAuB,CAAC"}

package/dest/mem_pools/attestation_pool/index.js

@@ -1,2 +1 @@
-export * from './attestation_pool.js';
-export * from './memory_attestation_pool.js';
+export { AttestationPool, createTestAttestationPool, MAX_CHECKPOINT_PROPOSALS_PER_SLOT, MAX_BLOCK_PROPOSALS_PER_POSITION, MAX_ATTESTATIONS_PER_SLOT_AND_SIGNER } from './attestation_pool.js';

package/dest/mem_pools/attestation_pool/mocks.d.ts

@@ -1,6 +1,7 @@
-import type { Secp256k1Signer } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
-import { BlockAttestation } from '@aztec/stdlib/p2p';
+import type { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CheckpointAttestation } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
 /** Generate Account
  *
  * Create a random signer
@@ -229,11 +230,13 @@ export declare const generateAccount: () => {
     source: string;
     type: "local";
 };
-/** Mock Attestation
+/** Mock Checkpoint Attestation
  *
- * @param signer A viem signer to create a signature
+ * @param signer A Secp256k1Signer to create a signature
  * @param slot The slot number the attestation is for
- * @returns A Block Attestation
+ * @param archive The archive root (defaults to random)
+ * @param header The checkpoint header (defaults to random with given slot)
+ * @returns A Checkpoint Attestation
  */
-export declare const mockAttestation: (signer: Secp256k1Signer, slot?: number, archive?: Fr) => BlockAttestation;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9tb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUNoRSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDOUMsT0FBTyxFQUNMLGdCQUFnQixFQUlqQixNQUFNLG1CQUFtQixDQUFDO0FBSzNCOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRzNCLENBQUM7QUFFRjs7Ozs7R0FLRztBQUNILGVBQU8sTUFBTSxlQUFlLDRFQWdCM0IsQ0FBQyJ9
+export declare const mockCheckpointAttestation: (signer: Secp256k1Signer, slot?: number, archive?: Fr, header?: CheckpointHeader | undefined, feeAssetPriceModifier?: bigint) => CheckpointAttestation;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9ja3MuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvYXR0ZXN0YXRpb25fcG9vbC9tb2Nrcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSwyQ0FBMkMsQ0FBQztBQUNqRixPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDcEQsT0FBTyxFQUNMLHFCQUFxQixFQUl0QixNQUFNLG1CQUFtQixDQUFDO0FBQzNCLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBS3hEOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sZUFBZTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBRzNCLENBQUM7QUFFRjs7Ozs7OztHQU9HO0FBQ0gsZUFBTyxNQUFNLHlCQUF5Qix3SkF3QnJDLENBQUMifQ==

package/dest/mem_pools/attestation_pool/mocks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/mocks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EACL,gBAAgB,EAIjB,MAAM,mBAAmB,CAAC;AAK3B;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG3B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,4EAgB3B,CAAC"}
+{"version":3,"file":"mocks.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/attestation_pool/mocks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EACL,qBAAqB,EAItB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAKxD;;;;GAIG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG3B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,wJAwBrC,CAAC"}

package/dest/mem_pools/attestation_pool/mocks.js

@@ -1,6 +1,8 @@
-import { Fr } from '@aztec/foundation/fields';
-import { BlockAttestation, ConsensusPayload, SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '@aztec/stdlib/p2p';
-import { makeL2BlockHeader } from '@aztec/stdlib/testing';
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { CheckpointAttestation, CheckpointProposal, ConsensusPayload, getHashedSignaturePayloadTypedData } from '@aztec/stdlib/p2p';
+import { CheckpointHeader } from '@aztec/stdlib/rollup';
+import { TEST_COORDINATION_SIGNATURE_CONTEXT } from '@aztec/stdlib/testing';
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
 /** Generate Account
  *
@@ -10,18 +12,22 @@ import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
     const privateKey = generatePrivateKey();
     return privateKeyToAccount(privateKey);
 };
-/** Mock Attestation
+/** Mock Checkpoint Attestation
  *
- * @param signer A viem signer to create a signature
+ * @param signer A Secp256k1Signer to create a signature
  * @param slot The slot number the attestation is for
- * @returns A Block Attestation
- */ export const mockAttestation = (signer, slot = 0, archive = Fr.random())=>{
-    // Use arbitrary numbers for all other than slot
-    const header = makeL2BlockHeader(1, 2, slot);
-    const payload = new ConsensusPayload(header.toCheckpointHeader(), archive);
-    const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+ * @param archive The archive root (defaults to random)
+ * @param header The checkpoint header (defaults to random with given slot)
+ * @returns A Checkpoint Attestation
+ */ export const mockCheckpointAttestation = (signer, slot = 0, archive = Fr.random(), header, feeAssetPriceModifier = 0n)=>{
+    header = header ?? CheckpointHeader.random({
+        slotNumber: SlotNumber(slot)
+    });
+    const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier, TEST_COORDINATION_SIGNATURE_CONTEXT);
+    const attestationHash = getHashedSignaturePayloadTypedData(payload);
     const attestationSignature = signer.sign(attestationHash);
-    const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+    const proposal = new CheckpointProposal(header, archive, feeAssetPriceModifier, attestationSignature, TEST_COORDINATION_SIGNATURE_CONTEXT);
+    const proposalHash = getHashedSignaturePayloadTypedData(proposal);
     const proposerSignature = signer.sign(proposalHash);
-    return new BlockAttestation(payload, attestationSignature, proposerSignature);
+    return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
 };

package/dest/mem_pools/index.d.ts

@@ -1,4 +1,4 @@
-export { type AttestationPool } from './attestation_pool/attestation_pool.js';
+export { AttestationPool, type AttestationPoolApi } from './attestation_pool/attestation_pool.js';
 export { type MemPools } from './interface.js';
-export { type TxPool } from './tx_pool/tx_pool.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZW1fcG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssZUFBZSxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDOUUsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDL0MsT0FBTyxFQUFFLEtBQUssTUFBTSxFQUFFLE1BQU0sc0JBQXNCLENBQUMifQ==
+export { type TxPoolV2, type TxPoolV2Config, type TxPoolV2Events, type AddTxsResult } from './tx_pool_v2/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tZW1fcG9vbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLGtCQUFrQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbEcsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDL0MsT0FBTyxFQUFFLEtBQUssUUFBUSxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssY0FBYyxFQUFFLEtBQUssWUFBWSxFQUFFLE1BQU0sdUJBQXVCLENBQUMifQ==

package/dest/mem_pools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mem_pools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mem_pools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAClG,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC"}

package/dest/mem_pools/index.js

@@ -1 +1 @@
-export { };
+export { AttestationPool } from './attestation_pool/attestation_pool.js';

package/dest/mem_pools/instrumentation.d.ts

@@ -17,12 +17,25 @@ export declare class PoolInstrumentation<PoolObject extends Gossipable> {
     private addObjectCounter;
     /** Tracks tx size */
     private objectSize;
+    /** Track delay between transaction added and evicted */
+    private minedDelay;
     private dbMetrics;
     private defaultAttributes;
     private meter;
+    private mempoolItemAddedTimestamp;
     constructor(telemetry: TelemetryClient, name: PoolName, poolStats: PoolStatsCallback, dbStats?: LmdbStatsCallback);
     recordSize(poolObject: PoolObject): void;
     incrementAddedObjects(count: number): void;
+    trackMempoolItemAdded(key: bigint | string): void;
+    trackMempoolItemRemoved(key: bigint | string): void;
+    /**
+     * Records a pre-computed pending-to-mined delay directly, bypassing the
+     * `mempoolItemAddedTimestamp` map. Used by the tx pool, which derives the
+     * delay from the persisted `receivedAt` on tx metadata at the mined
+     * transition — more accurate than the add/remove map (which also fires on
+     * eviction) and resilient to the caller not having tracked the add.
+     */
+    recordMinedDelay(delayMs: number): void;
     private observeStats;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2luc3RydW1lbnRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEVBS0wsS0FBSyxpQkFBaUIsRUFLdEIsS0FBSyxlQUFlLEVBRXJCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQVksUUFBUTtJQUNsQixPQUFPLFdBQVc7SUFDbEIsZ0JBQWdCLG9CQUFvQjtDQUNyQztBQStCRCxNQUFNLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxPQUFPLENBQUM7SUFDNUMsU0FBUyxFQUFFLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0NBQzVDLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gscUJBQWEsbUJBQW1CLENBQUMsVUFBVSxTQUFTLFVBQVU7SUFlMUQsT0FBTyxDQUFDLFNBQVM7SUFkbkIsdUNBQXVDO0lBQ3ZDLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBa0I7SUFDMUMsT0FBTyxDQUFDLGdCQUFnQixDQUFnQjtJQUN4QyxxQkFBcUI7SUFDckIsT0FBTyxDQUFDLFVBQVUsQ0FBWTtJQUU5QixPQUFPLENBQUMsU0FBUyxDQUFjO0lBRS9CLE9BQU8sQ0FBQyxpQkFBaUIsQ0FBQztJQUMxQixPQUFPLENBQUMsS0FBSyxDQUFRO0lBRXJCLFlBQ0UsU0FBUyxFQUFFLGVBQWUsRUFDMUIsSUFBSSxFQUFFLFFBQVEsRUFDTixTQUFTLEVBQUUsaUJBQWlCLEVBQ3BDLE9BQU8sQ0FBQyxFQUFFLGlCQUFpQixFQTZCNUI7SUFFTSxVQUFVLENBQUMsVUFBVSxFQUFFLFVBQVUsUUFFdkM7SUFFTSxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsTUFBTSxRQUV6QztJQUVELE9BQU8sQ0FBQyxZQUFZLENBWWxCO0NBQ0gifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5zdHJ1bWVudGF0aW9uLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2luc3RydW1lbnRhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNwRCxPQUFPLEVBS0wsS0FBSyxpQkFBaUIsRUFLdEIsS0FBSyxlQUFlLEVBR3JCLE1BQU0seUJBQXlCLENBQUM7QUFFakMsb0JBQVksUUFBUTtJQUNsQixPQUFPLFdBQVc7SUFDbEIsZ0JBQWdCLG9CQUFvQjtDQUNyQztBQWtDRCxNQUFNLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxPQUFPLENBQUM7SUFDNUMsU0FBUyxFQUFFLE1BQU0sR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0NBQzVDLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gscUJBQWEsbUJBQW1CLENBQUMsVUFBVSxTQUFTLFVBQVU7SUFtQjFELE9BQU8sQ0FBQyxTQUFTO0lBbEJuQix1Q0FBdUM7SUFDdkMsT0FBTyxDQUFDLGdCQUFnQixDQUFrQjtJQUMxQyxPQUFPLENBQUMsZ0JBQWdCLENBQWdCO0lBQ3hDLHFCQUFxQjtJQUNyQixPQUFPLENBQUMsVUFBVSxDQUFZO0lBQzlCLHdEQUF3RDtJQUN4RCxPQUFPLENBQUMsVUFBVSxDQUFZO0lBRTlCLE9BQU8sQ0FBQyxTQUFTLENBQWM7SUFFL0IsT0FBTyxDQUFDLGlCQUFpQixDQUFDO0lBQzFCLE9BQU8sQ0FBQyxLQUFLLENBQVE7SUFFckIsT0FBTyxDQUFDLHlCQUF5QixDQUFvRTtJQUVyRyxZQUNFLFNBQVMsRUFBRSxlQUFlLEVBQzFCLElBQUksRUFBRSxRQUFRLEVBQ04sU0FBUyxFQUFFLGlCQUFpQixFQUNwQyxPQUFPLENBQUMsRUFBRSxpQkFBaUIsRUE0QjVCO0lBRU0sVUFBVSxDQUFDLFVBQVUsRUFBRSxVQUFVLFFBRXZDO0lBRU0scUJBQXFCLENBQUMsS0FBSyxFQUFFLE1BQU0sUUFFekM7SUFFTSxxQkFBcUIsQ0FBQyxHQUFHLEVBQUUsTUFBTSxHQUFHLE1BQU0sR0FBRyxJQUFJLENBRXZEO0lBRU0sdUJBQXVCLENBQUMsR0FBRyxFQUFFLE1BQU0sR0FBRyxNQUFNLEdBQUcsSUFBSSxDQVN6RDtJQUVEOzs7Ozs7T0FNRztJQUNJLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxNQUFNLEdBQUcsSUFBSSxDQUk3QztJQUVELE9BQU8sQ0FBQyxZQUFZLENBWWxCO0NBQ0gifQ==

package/dest/mem_pools/instrumentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/mem_pools/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAKL,KAAK,iBAAiB,EAKtB,KAAK,eAAe,EAErB,MAAM,yBAAyB,CAAC;AAEjC,oBAAY,QAAQ;IAClB,OAAO,WAAW;IAClB,gBAAgB,oBAAoB;CACrC;AA+BD,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC;IAC5C,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC,CAAC;AAEH;;GAEG;AACH,qBAAa,mBAAmB,CAAC,UAAU,SAAS,UAAU;IAe1D,OAAO,CAAC,SAAS;IAdnB,uCAAuC;IACvC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IACxC,qBAAqB;IACrB,OAAO,CAAC,UAAU,CAAY;IAE9B,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,iBAAiB,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAQ;IAErB,YACE,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,QAAQ,EACN,SAAS,EAAE,iBAAiB,EACpC,OAAO,CAAC,EAAE,iBAAiB,EA6B5B;IAEM,UAAU,CAAC,UAAU,EAAE,UAAU,QAEvC;IAEM,qBAAqB,CAAC,KAAK,EAAE,MAAM,QAEzC;IAED,OAAO,CAAC,YAAY,CAYlB;CACH"}
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/mem_pools/instrumentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAKL,KAAK,iBAAiB,EAKtB,KAAK,eAAe,EAGrB,MAAM,yBAAyB,CAAC;AAEjC,oBAAY,QAAQ;IAClB,OAAO,WAAW;IAClB,gBAAgB,oBAAoB;CACrC;AAkCD,MAAM,MAAM,iBAAiB,GAAG,MAAM,OAAO,CAAC;IAC5C,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC,CAAC;AAEH;;GAEG;AACH,qBAAa,mBAAmB,CAAC,UAAU,SAAS,UAAU;IAmB1D,OAAO,CAAC,SAAS;IAlBnB,uCAAuC;IACvC,OAAO,CAAC,gBAAgB,CAAkB;IAC1C,OAAO,CAAC,gBAAgB,CAAgB;IACxC,qBAAqB;IACrB,OAAO,CAAC,UAAU,CAAY;IAC9B,wDAAwD;IACxD,OAAO,CAAC,UAAU,CAAY;IAE9B,OAAO,CAAC,SAAS,CAAc;IAE/B,OAAO,CAAC,iBAAiB,CAAC;IAC1B,OAAO,CAAC,KAAK,CAAQ;IAErB,OAAO,CAAC,yBAAyB,CAAoE;IAErG,YACE,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,QAAQ,EACN,SAAS,EAAE,iBAAiB,EACpC,OAAO,CAAC,EAAE,iBAAiB,EA4B5B;IAEM,UAAU,CAAC,UAAU,EAAE,UAAU,QAEvC;IAEM,qBAAqB,CAAC,KAAK,EAAE,MAAM,QAEzC;IAEM,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEvD;IAEM,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CASzD;IAED;;;;;;OAMG;IACI,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAI7C;IAED,OAAO,CAAC,YAAY,CAYlB;CACH"}

package/dest/mem_pools/instrumentation.js

@@ -1,4 +1,4 @@
-import { Attributes, LmdbMetrics, Metrics } from '@aztec/telemetry-client';
+import { Attributes, LmdbMetrics, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
 export var PoolName = /*#__PURE__*/ function(PoolName) {
     PoolName["TX_POOL"] = "TxPool";
     PoolName["ATTESTATION_POOL"] = "AttestationPool";
@@ -13,13 +13,15 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
         return {
             objectInMempool: Metrics.MEMPOOL_TX_COUNT,
             objectSize: Metrics.MEMPOOL_TX_SIZE,
-            itemsAdded: Metrics.MEMPOOL_TX_ADDED_COUNT
+            itemsAdded: Metrics.MEMPOOL_TX_ADDED_COUNT,
+            itemMinedDelay: Metrics.MEMPOOL_TX_MINED_DELAY
         };
     } else if (name === "AttestationPool") {
         return {
             objectInMempool: Metrics.MEMPOOL_ATTESTATIONS_COUNT,
             objectSize: Metrics.MEMPOOL_ATTESTATIONS_SIZE,
-            itemsAdded: Metrics.MEMPOOL_ATTESTATIONS_ADDED_COUNT
+            itemsAdded: Metrics.MEMPOOL_ATTESTATIONS_ADDED_COUNT,
+            itemMinedDelay: Metrics.MEMPOOL_ATTESTATIONS_MINED_DELAY
         };
     }
     throw new Error('Invalid pool type');
@@ -31,11 +33,14 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
     /** The number of txs in the mempool */ objectsInMempool;
     addObjectCounter;
     /** Tracks tx size */ objectSize;
+    /** Track delay between transaction added and evicted */ minedDelay;
     dbMetrics;
     defaultAttributes;
     meter;
+    mempoolItemAddedTimestamp;
     constructor(telemetry, name, poolStats, dbStats){
         this.poolStats = poolStats;
+        this.mempoolItemAddedTimestamp = new Map();
         this.observeStats = async (observer)=>{
             const { itemCount } = await this.poolStats();
             if (typeof itemCount === 'number') {
@@ -54,18 +59,28 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
             [Attributes.POOL_NAME]: name
         };
         const metricsLabels = getMetricsLabels(name);
-        this.objectsInMempool = this.meter.createObservableGauge(metricsLabels.objectInMempool, {
-            description: 'The current number of transactions in the mempool'
-        });
-        this.objectSize = this.meter.createHistogram(metricsLabels.objectSize, {
-            unit: 'By',
-            description: 'The size of transactions in the mempool'
-        });
+        this.objectsInMempool = this.meter.createObservableGauge(metricsLabels.objectInMempool);
+        this.objectSize = this.meter.createHistogram(metricsLabels.objectSize);
         this.dbMetrics = new LmdbMetrics(this.meter, {
             [Attributes.DB_DATA_TYPE]: 'tx-pool'
         }, dbStats);
-        this.addObjectCounter = this.meter.createUpDownCounter(metricsLabels.itemsAdded, {
-            description: 'The number of transactions added to the mempool'
+        this.addObjectCounter = createUpDownCounterWithDefault(this.meter, metricsLabels.itemsAdded);
+        this.minedDelay = this.meter.createHistogram(metricsLabels.itemMinedDelay, {
+            advice: {
+                explicitBucketBoundaries: [
+                    100,
+                    500,
+                    1000,
+                    5000,
+                    10000,
+                    30000,
+                    60000,
+                    300000,
+                    600000,
+                    1800000,
+                    3600000
+                ]
+            }
         });
         this.meter.addBatchObservableCallback(this.observeStats, [
             this.objectsInMempool
@@ -77,5 +92,29 @@ export var PoolName = /*#__PURE__*/ function(PoolName) {
     incrementAddedObjects(count) {
         this.addObjectCounter.add(count);
     }
+    trackMempoolItemAdded(key) {
+        this.mempoolItemAddedTimestamp.set(key, Date.now());
+    }
+    trackMempoolItemRemoved(key) {
+        const timestamp = Date.now();
+        const addedAt = this.mempoolItemAddedTimestamp.get(key);
+        if (addedAt !== undefined) {
+            this.mempoolItemAddedTimestamp.delete(key);
+            if (addedAt < timestamp) {
+                this.minedDelay.record(timestamp - addedAt);
+            }
+        }
+    }
+    /**
+   * Records a pre-computed pending-to-mined delay directly, bypassing the
+   * `mempoolItemAddedTimestamp` map. Used by the tx pool, which derives the
+   * delay from the persisted `receivedAt` on tx metadata at the mined
+   * transition — more accurate than the add/remove map (which also fires on
+   * eviction) and resilient to the caller not having tracked the add.
+   */ recordMinedDelay(delayMs) {
+        if (delayMs > 0) {
+            this.minedDelay.record(delayMs);
+        }
+    }
     observeStats;
 }

package/dest/mem_pools/interface.d.ts

@@ -1,11 +1,10 @@
-import type { P2PClientType } from '@aztec/stdlib/p2p';
-import type { AttestationPool } from './attestation_pool/attestation_pool.js';
-import type { TxPool } from './tx_pool/tx_pool.js';
+import type { AttestationPoolApi } from './attestation_pool/attestation_pool.js';
+import type { TxPoolV2 } from './tx_pool_v2/interfaces.js';
 /**
  * A interface the combines all mempools
  */
-export type MemPools<T extends P2PClientType = P2PClientType.Full> = {
-    txPool: TxPool;
-    attestationPool?: T extends P2PClientType.Full ? AttestationPool : undefined;
+export type MemPools = {
+    txPool: TxPoolV2;
+    attestationPool: AttestationPoolApi;
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUV2RCxPQUFPLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUM5RSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUVuRDs7R0FFRztBQUNILE1BQU0sTUFBTSxRQUFRLENBQUMsQ0FBQyxTQUFTLGFBQWEsR0FBRyxhQUFhLENBQUMsSUFBSSxJQUFJO0lBQ25FLE1BQU0sRUFBRSxNQUFNLENBQUM7SUFDZixlQUFlLENBQUMsRUFBRSxDQUFDLFNBQVMsYUFBYSxDQUFDLElBQUksR0FBRyxlQUFlLEdBQUcsU0FBUyxDQUFDO0NBQzlFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWVtX3Bvb2xzL2ludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBQ2pGLE9BQU8sS0FBSyxFQUFFLFFBQVEsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRTNEOztHQUVHO0FBQ0gsTUFBTSxNQUFNLFFBQVEsR0FBRztJQUNyQixNQUFNLEVBQUUsUUFBUSxDQUFDO0lBQ2pCLGVBQWUsRUFBRSxrQkFBa0IsQ0FBQztDQUNyQyxDQUFDIn0=

package/dest/mem_pools/interface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/mem_pools/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAC;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAAC,IAAI,IAAI;IACnE,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,CAAC,SAAS,aAAa,CAAC,IAAI,GAAG,eAAe,GAAG,SAAS,CAAC;CAC9E,CAAC"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../src/mem_pools/interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,QAAQ,CAAC;IACjB,eAAe,EAAE,kBAAkB,CAAC;CACrC,CAAC"}

package/dest/mem_pools/tx_pool_v2/archive/index.d.ts

@@ -0,0 +1,2 @@
+export { TxArchive } from './tx_archive.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tZW1fcG9vbHMvdHhfcG9vbF92Mi9hcmNoaXZlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dest/mem_pools/tx_pool_v2/archive/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/archive/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dest/mem_pools/tx_pool_v2/archive/index.js

@@ -0,0 +1 @@
+export { TxArchive } from './tx_archive.js';

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.d.ts

@@ -0,0 +1,39 @@
+import { type Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+import { Tx, TxHash } from '@aztec/stdlib/tx';
+/**
+ * Manages archived transactions with FIFO eviction.
+ * Archived transactions have their proofs stripped to save space.
+ */
+export declare class TxArchive {
+    #private;
+    constructor(store: AztecAsyncKVStore, limit: number, log?: Logger);
+    /**
+     * Updates the maximum number of archived transactions.
+     */
+    updateLimit(limit: number): void;
+    /**
+     * Gets the current archive limit.
+     */
+    getLimit(): number;
+    /**
+     * Checks if archiving is enabled.
+     */
+    isEnabled(): boolean;
+    /**
+     * Archives transactions, stripping their proofs.
+     * Evicts oldest transactions if the limit is exceeded.
+     */
+    archiveTxs(txs: Tx[]): Promise<void>;
+    /**
+     * Retrieves an archived transaction by its hash.
+     */
+    getTxByHash(txHash: TxHash): Promise<Tx | undefined>;
+    /**
+     * Gets the current count of archived transactions.
+     */
+    getCount(): Promise<number>;
+    private getHeadIndex;
+    private getTailIndex;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfYXJjaGl2ZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21lbV9wb29scy90eF9wb29sX3YyL2FyY2hpdmUvdHhfYXJjaGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxNQUFNLEVBQWdCLE1BQU0sdUJBQXVCLENBQUM7QUFDbEUsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWlCLE1BQU0saUJBQWlCLENBQUM7QUFDeEUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU5Qzs7O0dBR0c7QUFDSCxxQkFBYSxTQUFTOztJQU9wQixZQUFZLEtBQUssRUFBRSxpQkFBaUIsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQyxFQUFFLE1BQU0sRUFNaEU7SUFFRDs7T0FFRztJQUNILFdBQVcsQ0FBQyxLQUFLLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FFL0I7SUFFRDs7T0FFRztJQUNILFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQ7O09BRUc7SUFDSCxTQUFTLElBQUksT0FBTyxDQUVuQjtJQUVEOzs7T0FHRztJQUNHLFVBQVUsQ0FBQyxHQUFHLEVBQUUsRUFBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQW1DekM7SUFFRDs7T0FFRztJQUNHLFdBQVcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxFQUFFLEdBQUcsU0FBUyxDQUFDLENBR3pEO0lBRUQ7O09BRUc7SUFDRyxRQUFRLElBQUksT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUloQztZQUVhLFlBQVk7WUFLWixZQUFZO0NBSTNCIn0=

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_archive.d.ts","sourceRoot":"","sources":["../../../../src/mem_pools/tx_pool_v2/archive/tx_archive.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE9C;;;GAGG;AACH,qBAAa,SAAS;;IAOpB,YAAY,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAMhE;IAED;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE/B;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,SAAS,IAAI,OAAO,CAEnB;IAED;;;OAGG;IACG,UAAU,CAAC,GAAG,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAmCzC;IAED;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,CAGzD;IAED;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAIhC;YAEa,YAAY;YAKZ,YAAY;CAI3B"}

package/dest/mem_pools/tx_pool_v2/archive/tx_archive.js

@@ -0,0 +1,97 @@
+import { createLogger } from '@aztec/foundation/log';
+import { Tx } from '@aztec/stdlib/tx';
+/**
+ * Manages archived transactions with FIFO eviction.
+ * Archived transactions have their proofs stripped to save space.
+ */ export class TxArchive {
+    #store;
+    #txs;
+    #indices;
+    #limit;
+    #log;
+    constructor(store, limit, log){
+        this.#store = store;
+        this.#txs = store.openMap('archivedTxs');
+        this.#indices = store.openMap('archivedTxIndices');
+        this.#limit = limit;
+        this.#log = log ?? createLogger('p2p:tx_pool_v2:archive');
+    }
+    /**
+   * Updates the maximum number of archived transactions.
+   */ updateLimit(limit) {
+        this.#limit = limit;
+    }
+    /**
+   * Gets the current archive limit.
+   */ getLimit() {
+        return this.#limit;
+    }
+    /**
+   * Checks if archiving is enabled.
+   */ isEnabled() {
+        return this.#limit > 0;
+    }
+    /**
+   * Archives transactions, stripping their proofs.
+   * Evicts oldest transactions if the limit is exceeded.
+   */ async archiveTxs(txs) {
+        if (!this.isEnabled() || txs.length === 0) {
+            return;
+        }
+        try {
+            await this.#store.transactionAsync(async ()=>{
+                // Get current head and tail indices
+                let headIdx = await this.getHeadIndex();
+                let tailIdx = await this.getTailIndex();
+                for (const tx of txs){
+                    // Evict oldest entries if at capacity
+                    while(headIdx - tailIdx >= this.#limit){
+                        const txHashToEvict = await this.#indices.getAsync(tailIdx);
+                        if (txHashToEvict) {
+                            await this.#txs.delete(txHashToEvict);
+                            await this.#indices.delete(tailIdx);
+                        }
+                        tailIdx++;
+                    }
+                    // Archive the transaction with stripped proof
+                    const archivedTx = tx.withoutProof();
+                    const txHash = tx.getTxHash().toString();
+                    await this.#txs.set(txHash, archivedTx.toBuffer());
+                    await this.#indices.set(headIdx, txHash);
+                    headIdx++;
+                }
+                this.#log.debug(`Archived ${txs.length} txs, total: ${headIdx - tailIdx}`);
+            });
+        } catch (error) {
+            this.#log.error('Error archiving transactions', {
+                error
+            });
+        }
+    }
+    /**
+   * Retrieves an archived transaction by its hash.
+   */ async getTxByHash(txHash) {
+        const buffer = await this.#txs.getAsync(txHash.toString());
+        return buffer ? Tx.fromBuffer(buffer) : undefined;
+    }
+    /**
+   * Gets the current count of archived transactions.
+   */ async getCount() {
+        const head = await this.getHeadIndex();
+        const tail = await this.getTailIndex();
+        return head - tail;
+    }
+    async getHeadIndex() {
+        const entry = await this.#indices.entriesAsync({
+            limit: 1,
+            reverse: true
+        }).next();
+        return (entry.value?.[0] ?? -1) + 1;
+    }
+    async getTailIndex() {
+        const entry = await this.#indices.entriesAsync({
+            limit: 1
+        }).next();
+        return entry.value?.[0] ?? 0;
+    }
+}

package/dest/mem_pools/tx_pool_v2/deleted_pool.d.ts

@@ -0,0 +1,104 @@
+import { BlockNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import type { Logger } from '@aztec/foundation/log';
+import type { AztecAsyncKVStore } from '@aztec/kv-store';
+/**
+ * Manages all transaction deletions in the pool.
+ *
+ * When a chain prune (reorg) happens, transactions from pruned blocks are tracked here.
+ * This class is responsible for ALL deletion decisions:
+ *
+ * - Transactions from pruned blocks are "prune-soft-deleted" - removed from indices but kept
+ *   in the database for later re-execution until their mined block is finalized
+ * - Transactions NOT from pruned blocks are "slot-soft-deleted" - kept in the database
+ *   until the next slot, so other nodes can still fetch them via reqresp
+ *
+ * When a block is finalized, prune-soft-deleted transactions that were originally mined at or
+ * before that block number are permanently (hard) deleted. Slot-soft-deleted transactions
+ * are hard-deleted when `prepareForSlot` advances to a new slot.
+ */
+export declare class DeletedPool {
+    #private;
+    constructor(store: AztecAsyncKVStore, deleteTxData: (txHash: string) => Promise<void>, log: Logger);
+    /**
+     * Loads state from the database on startup.
+     * Slot-deleted txs are stale after restart and are immediately hard-deleted.
+     */
+    hydrateFromDatabase(): Promise<void>;
+    /**
+     * Marks transactions as being from a pruned block.
+     * Called during handlePrunedBlocks for ALL transactions that were un-mined.
+     *
+     * If a tx was previously tracked (e.g., mined at block 4, pruned, re-mined at block 5,
+     * pruned again), updates to the higher block number. This ensures the tx is kept until
+     * its most recent mined block is finalized.
+     *
+     * @param txs - Array of {txHash, minedAtBlock} pairs, where minedAtBlock is the block
+     *              number in which the tx was mined before being un-mined
+     */
+    markFromPrunedBlock(txs: {
+        txHash: string;
+        minedAtBlock: BlockNumber;
+    }[]): Promise<void>;
+    /**
+     * Deletes a transaction. This is the single entry point for ALL deletions.
+     * The tx is always soft-deleted (kept in DB):
+     *
+     * - If the tx is from a pruned block: prune-soft-delete (kept until finalized)
+     * - If the tx is NOT from a pruned block: slot-soft-delete (kept until next slot)
+     */
+    deleteTx(txHash: string): Promise<void>;
+    /**
+     * Clears tracking for a transaction if it re-mines at a block number >= the tracked minedAtBlock.
+     *
+     * When a tx re-mines at a higher (or equal) block, the old high-water mark is no longer needed:
+     * any future prune would re-add the tx with an even higher block number. Clearing keeps
+     * DeletedPool consistent — only txs that are actually un-mined should be tracked here.
+     *
+     * When a tx re-mines at a lower block, we must preserve the existing entry to retain
+     * the high-water mark for re-execution purposes.
+     */
+    clearIfMinedHigher(txHash: string, minedAtBlock: BlockNumber): Promise<void>;
+    /**
+     * Checks if a transaction is from a pruned block.
+     */
+    isFromPrunedBlock(txHash: string): boolean;
+    /**
+     * Checks if a transaction is soft-deleted (either prune-based or slot-based).
+     */
+    isSoftDeleted(txHash: string): boolean;
+    /**
+     * Gets the block number in which a transaction was originally mined.
+     */
+    getMinedAtBlock(txHash: string): BlockNumber | undefined;
+    /**
+     * Finalizes transactions when a block is finalized.
+     * Hard-deletes transactions that were originally mined at or before the finalized block.
+     *
+     * @returns The hashes of transactions that were hard-deleted
+     */
+    finalizeBlock(finalizedBlockNumber: BlockNumber): Promise<string[]>;
+    /**
+     * Cleans up slot-deleted transactions from previous slots.
+     * Called at the start of prepareForSlot. Updates #currentSlot and hard-deletes
+     * any txs that were deleted in an earlier slot.
+     */
+    cleanupSlotDeleted(currentSlot: SlotNumber): Promise<void>;
+    /**
+     * Clears soft-deletion status for a transaction being re-added to the pool.
+     * Removes slot-deleted tracking entirely, and resets the prune-soft-deleted flag
+     * while preserving the prune tracking itself (so a subsequent delete still uses
+     * the prune path).
+     */
+    clearSoftDeleted(txHash: string): Promise<void>;
+    /**
+     * Gets the count of transactions from pruned blocks.
+     */
+    getCount(): number;
+    /** Gets the count of soft-deleted transactions (both prune-based and slot-based). */
+    getSoftDeletedCount(): number;
+    /**
+     * Gets all transaction hashes from pruned blocks.
+     */
+    getPrunedTxHashes(): string[];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVsZXRlZF9wb29sLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2xfdjIvZGVsZXRlZF9wb29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsVUFBVSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDMUUsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDcEQsT0FBTyxLQUFLLEVBQUUsaUJBQWlCLEVBQWdDLE1BQU0saUJBQWlCLENBQUM7QUFpQ3ZGOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gscUJBQWEsV0FBVzs7SUFxQnRCLFlBQVksS0FBSyxFQUFFLGlCQUFpQixFQUFFLFlBQVksRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEtBQUssT0FBTyxDQUFDLElBQUksQ0FBQyxFQUFFLEdBQUcsRUFBRSxNQUFNLEVBS2pHO0lBRUQ7OztPQUdHO0lBQ0csbUJBQW1CLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxDQTRCekM7SUFFRDs7Ozs7Ozs7OztPQVVHO0lBQ0csbUJBQW1CLENBQUMsR0FBRyxFQUFFO1FBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQztRQUFDLFlBQVksRUFBRSxXQUFXLENBQUE7S0FBRSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXVCN0Y7SUFFRDs7Ozs7O09BTUc7SUFDRyxRQUFRLENBQUMsTUFBTSxFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLENBZTVDO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0csa0JBQWtCLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxZQUFZLEVBQUUsV0FBVyxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FTakY7SUFFRDs7T0FFRztJQUNILGlCQUFpQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUV6QztJQUVEOztPQUVHO0lBQ0gsYUFBYSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUVyQztJQUVEOztPQUVHO0lBQ0gsZUFBZSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsV0FBVyxHQUFHLFNBQVMsQ0FFdkQ7SUFFRDs7Ozs7T0FLRztJQUNHLGFBQWEsQ0FBQyxvQkFBb0IsRUFBRSxXQUFXLEdBQUcsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBdUJ4RTtJQUVEOzs7O09BSUc7SUFDRyxrQkFBa0IsQ0FBQyxXQUFXLEVBQUUsVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0F5Qi9EO0lBRUQ7Ozs7O09BS0c7SUFDRyxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FXcEQ7SUFFRDs7T0FFRztJQUNILFFBQVEsSUFBSSxNQUFNLENBRWpCO0lBRUQscUZBQXFGO0lBQ3JGLG1CQUFtQixJQUFJLE1BQU0sQ0FRNUI7SUFFRDs7T0FFRztJQUNILGlCQUFpQixJQUFJLE1BQU0sRUFBRSxDQUU1QjtDQUNGIn0=

package/dest/mem_pools/tx_pool_v2/deleted_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted_pool.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool_v2/deleted_pool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAgC,MAAM,iBAAiB,CAAC;AAiCvF;;;;;;;;;;;;;;GAcG;AACH,qBAAa,WAAW;;IAqBtB,YAAY,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,MAAM,EAKjG;IAED;;;OAGG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4BzC;IAED;;;;;;;;;;OAUG;IACG,mBAAmB,CAAC,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,WAAW,CAAA;KAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAuB7F;IAED;;;;;;OAMG;IACG,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5C;IAED;;;;;;;;;OASG;IACG,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CASjF;IAED;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzC;IAED;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAErC;IAED;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAEvD;IAED;;;;;OAKG;IACG,aAAa,CAAC,oBAAoB,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAuBxE;IAED;;;;OAIG;IACG,kBAAkB,CAAC,WAAW,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB/D;IAED;;;;;OAKG;IACG,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWpD;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM,CAEjB;IAED,qFAAqF;IACrF,mBAAmB,IAAI,MAAM,CAQ5B;IAED;;OAEG;IACH,iBAAiB,IAAI,MAAM,EAAE,CAE5B;CACF"}