@aztec/p2p 0.0.1-commit.d431d1c → 0.0.1-commit.dbf9cec

package/dest/mem_pools/tx_pool_v2/tx_metadata.js

@@ -0,0 +1,193 @@
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { ProtocolContractAddress } from '@aztec/protocol-contracts';
+import { BlockHash } from '@aztec/stdlib/block';
+import { Gas } from '@aztec/stdlib/gas';
+import { TxHash } from '@aztec/stdlib/tx';
+import { getFeePayerBalanceDelta } from '../../msg_validators/tx_validator/fee_payer_balance.js';
+import { getTxPriorityFee } from '../tx_pool/priority.js';
+import { TxPoolRejectionCode } from './eviction/interfaces.js';
+/**
+ * Builds TxMetaData from a full Tx object.
+ * Extracts all relevant fields for efficient in-memory storage and querying.
+ * Fr values are captured in closures for zero-cost re-validation.
+ */ export async function buildTxMetaData(tx) {
+    const txHashObj = tx.getTxHash();
+    const txHash = txHashObj.toString();
+    const txHashBigInt = txHashObj.toBigInt();
+    const nullifierFrs = tx.data.getNonEmptyNullifiers();
+    const nullifiers = nullifierFrs.map((n)=>n.toString());
+    const anchorBlockHeaderHashFr = await tx.data.constants.anchorBlockHeader.hash();
+    const anchorBlockHeaderHash = anchorBlockHeaderHashFr.toString();
+    const expirationTimestamp = tx.data.expirationTimestamp;
+    const anchorBlockNumber = tx.data.constants.anchorBlockHeader.globalVariables.blockNumber;
+    const priorityFee = getTxPriorityFee(tx);
+    const feePayer = tx.data.feePayer.toString();
+    const { feeLimit, claimAmount } = await getFeePayerBalanceDelta(tx, ProtocolContractAddress.FeeJuice);
+    const estimatedSizeBytes = estimateTxMetaDataSize(nullifiers.length);
+    return {
+        txHash,
+        txHashBigInt,
+        anchorBlockHeaderHash,
+        priorityFee,
+        feePayer,
+        claimAmount,
+        feeLimit,
+        nullifiers,
+        expirationTimestamp,
+        receivedAt: 0,
+        estimatedSizeBytes,
+        data: {
+            getNonEmptyNullifiers: ()=>nullifierFrs,
+            expirationTimestamp,
+            forPublic: !!tx.data.forPublic,
+            constants: {
+                anchorBlockHeader: {
+                    hash: ()=>Promise.resolve(anchorBlockHeaderHashFr),
+                    globalVariables: {
+                        blockNumber: anchorBlockNumber
+                    }
+                },
+                txContext: {
+                    gasSettings: {
+                        gasLimits: tx.data.constants.txContext.gasSettings.gasLimits
+                    }
+                }
+            }
+        }
+    };
+}
+// V8 JS object overhead (~64 bytes for a plain object with hidden class).
+// String overhead: ~32 bytes header + 1 byte per ASCII char (V8 one-byte strings).
+// Hex string (0x + 64 hex chars = 66 chars): ~98 bytes per string.
+// bigint: ~32 bytes. number: 8 bytes. Fr: ~80 bytes (32 data + object overhead).
+const OBJECT_OVERHEAD = 64;
+const HEX_STRING_BYTES = 98;
+const BIGINT_BYTES = 32;
+const FR_BYTES = 80;
+// Fixed cost: object shell + txHash + anchorBlockHeaderHash + feePayer (3 hex strings)
+// + txHashBigInt + priorityFee + claimAmount + feeLimit + includeByTimestamp (5 bigints)
+// + receivedAt (number, 8 bytes) + estimatedSizeBytes (number, 8 bytes)
+// + data closure object (~OBJECT_OVERHEAD + anchorBlockHeaderHashFr Fr + anchorBlockNumber number)
+const FIXED_METADATA_BYTES = OBJECT_OVERHEAD + 3 * HEX_STRING_BYTES + 5 * BIGINT_BYTES + 8 + 8 + OBJECT_OVERHEAD + FR_BYTES + 8;
+/** Estimates the in-memory size of a TxMetaData object based on the number of nullifiers. */ function estimateTxMetaDataSize(nullifierCount) {
+    // Per nullifier: one hex string in nullifiers[] + one Fr in the captured nullifierFrs[]
+    return FIXED_METADATA_BYTES + nullifierCount * (HEX_STRING_BYTES + FR_BYTES);
+}
+/** Converts a txHash bigint back to the canonical 0x-prefixed 64-char hex string. */ export function txHashFromBigInt(value) {
+    return TxHash.fromBigInt(value).toString();
+}
+/**
+ * Compares two priority fees in ascending order.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ */ export function compareFee(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Compares two tx hashes in ascending order.
+ * Uses field element comparison for deterministic ordering.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ */ export function compareTxHash(a, b) {
+    return Fr.cmpAsBigInt(a, b);
+}
+/**
+ * Compares two transactions by priority fee, with txHash as tiebreaker.
+ * Returns negative if a < b, positive if a > b, 0 if equal.
+ * Use with sort() for ascending order, or negate/reverse for descending.
+ */ export function comparePriority(a, b) {
+    const feeComparison = compareFee(a.priorityFee, b.priorityFee);
+    if (feeComparison !== 0) {
+        return feeComparison;
+    }
+    return compareTxHash(a.txHashBigInt, b.txHashBigInt);
+}
+/**
+ * Checks for nullifier conflicts between an incoming transaction and existing pool state.
+ *
+ * When the incoming tx shares nullifiers with existing pending txs:
+ * - If the incoming tx has strictly higher priority, mark conflicting txs for eviction
+ * - If any conflicting tx has equal or higher priority, ignore the incoming tx
+ *
+ * @param incomingMeta - Metadata for the incoming transaction
+ * @param getTxHashByNullifier - Accessor to find which tx uses a nullifier
+ * @param getMetadata - Accessor to get metadata for a tx hash
+ */ export function checkNullifierConflict(incomingMeta, getTxHashByNullifier, getMetadata) {
+    const txHashesToEvict = [];
+    for (const nullifier of incomingMeta.nullifiers){
+        const conflictingHashStr = getTxHashByNullifier(nullifier);
+        if (!conflictingHashStr || conflictingHashStr === incomingMeta.txHash) {
+            continue;
+        }
+        // Skip if already marked for eviction
+        if (txHashesToEvict.includes(conflictingHashStr)) {
+            continue;
+        }
+        const conflictingMeta = getMetadata(conflictingHashStr);
+        if (!conflictingMeta) {
+            continue;
+        }
+        // If incoming tx has strictly higher priority, mark for eviction
+        // Otherwise, ignore incoming tx (ties go to existing tx)
+        // Use comparePriority for deterministic ordering (includes txHash as tiebreaker)
+        if (comparePriority(incomingMeta, conflictingMeta) > 0) {
+            txHashesToEvict.push(conflictingHashStr);
+        } else {
+            return {
+                shouldIgnore: true,
+                txHashesToEvict: [],
+                reason: {
+                    code: TxPoolRejectionCode.NULLIFIER_CONFLICT,
+                    message: `Nullifier conflict with existing tx ${conflictingHashStr}`,
+                    conflictingTxHash: conflictingHashStr
+                }
+            };
+        }
+    }
+    return {
+        shouldIgnore: false,
+        txHashesToEvict
+    };
+}
+/** Creates a stub TxMetaValidationData for tests that don't exercise validators. */ export function stubTxMetaValidationData(overrides = {}) {
+    return {
+        getNonEmptyNullifiers: ()=>[],
+        expirationTimestamp: overrides.expirationTimestamp ?? 0n,
+        constants: {
+            anchorBlockHeader: {
+                hash: ()=>Promise.resolve(new BlockHash(Fr.ZERO)),
+                globalVariables: {
+                    blockNumber: BlockNumber(0)
+                }
+            },
+            txContext: {
+                gasSettings: {
+                    gasLimits: Gas.empty()
+                }
+            }
+        }
+    };
+}
+/** Creates a stub TxMetaData for tests. All fields have sensible defaults and can be overridden. */ export function stubTxMetaData(txHash, overrides = {}) {
+    const txHashBigInt = Fr.fromHexString(txHash).toBigInt();
+    // Normalize to canonical zero-padded hex so txHashFromBigInt(txHashBigInt) === normalizedTxHash
+    const normalizedTxHash = txHashFromBigInt(txHashBigInt);
+    const expirationTimestamp = overrides.expirationTimestamp ?? 0n;
+    return {
+        txHash: normalizedTxHash,
+        txHashBigInt,
+        anchorBlockHeaderHash: overrides.anchorBlockHeaderHash ?? '0x1234',
+        priorityFee: overrides.priorityFee ?? 100n,
+        feePayer: overrides.feePayer ?? '0xfeepayer',
+        claimAmount: overrides.claimAmount ?? 0n,
+        feeLimit: overrides.feeLimit ?? 100n,
+        nullifiers: overrides.nullifiers ?? [
+            `0x${normalizedTxHash.slice(2)}null1`
+        ],
+        expirationTimestamp,
+        receivedAt: 0,
+        estimatedSizeBytes: 0,
+        data: stubTxMetaValidationData({
+            expirationTimestamp
+        })
+    };
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Metrics types for tx pool benchmarks.
+ */
+export declare enum TxPoolOperation {
+    ADD_PENDING_TXS = "addPendingTxs",
+    CAN_ADD_PENDING_TX = "canAddPendingTx",
+    GET_PENDING_TX_HASHES = "getPendingTxHashes",
+    GET_TX_BY_HASH = "getTxByHash",
+    GET_TXS_BY_HASH = "getTxsByHash",
+    HAS_TXS = "hasTxs",
+    HANDLE_MINED_BLOCK = "handleMinedBlock",
+    PREPARE_FOR_SLOT = "prepareForSlot",
+    HANDLE_PRUNED_BLOCKS = "handlePrunedBlocks",
+    GET_LOWEST_PRIORITY_PENDING = "getLowestPriorityPending",
+    HYDRATE_FROM_DATABASE = "hydrateFromDatabase"
+}
+/**
+ * Collects and formats tx pool benchmark metrics.
+ */
+export declare class TxPoolBenchMetrics {
+    private metrics;
+    addMetric(operation: TxPoolOperation, poolSize: number, batchSize: number, value: number): void;
+    toPrettyString(): string;
+    toGithubActionBenchmarkJSON(indent?: number): string;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcG9vbF9iZW5jaF9tZXRyaWNzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2xfdjIvdHhfcG9vbF9iZW5jaF9tZXRyaWNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsb0JBQVksZUFBZTtJQUN6QixlQUFlLGtCQUFrQjtJQUNqQyxrQkFBa0Isb0JBQW9CO0lBQ3RDLHFCQUFxQix1QkFBdUI7SUFDNUMsY0FBYyxnQkFBZ0I7SUFDOUIsZUFBZSxpQkFBaUI7SUFDaEMsT0FBTyxXQUFXO0lBQ2xCLGtCQUFrQixxQkFBcUI7SUFDdkMsZ0JBQWdCLG1CQUFtQjtJQUNuQyxvQkFBb0IsdUJBQXVCO0lBQzNDLDJCQUEyQiw2QkFBNkI7SUFDeEQscUJBQXFCLHdCQUF3QjtDQUM5QztBQVNEOztHQUVHO0FBQ0gscUJBQWEsa0JBQWtCO0lBQzdCLE9BQU8sQ0FBQyxPQUFPLENBQXlCO0lBRWpDLFNBQVMsQ0FBQyxTQUFTLEVBQUUsZUFBZSxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxLQUFLLEVBQUUsTUFBTSxRQUU5RjtJQUVNLGNBQWMsSUFBSSxNQUFNLENBd0I5QjtJQUVNLDJCQUEyQixDQUFDLE1BQU0sU0FBSSxHQUFHLE1BQU0sQ0FjckQ7Q0FDRiJ9

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

@@ -0,0 +1 @@
+{"version":3,"file":"tx_pool_bench_metrics.d.ts","sourceRoot":"","sources":["../../../src/mem_pools/tx_pool_v2/tx_pool_bench_metrics.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,oBAAY,eAAe;IACzB,eAAe,kBAAkB;IACjC,kBAAkB,oBAAoB;IACtC,qBAAqB,uBAAuB;IAC5C,cAAc,gBAAgB;IAC9B,eAAe,iBAAiB;IAChC,OAAO,WAAW;IAClB,kBAAkB,qBAAqB;IACvC,gBAAgB,mBAAmB;IACnC,oBAAoB,uBAAuB;IAC3C,2BAA2B,6BAA6B;IACxD,qBAAqB,wBAAwB;CAC9C;AASD;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,OAAO,CAAyB;IAEjC,SAAS,CAAC,SAAS,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAE9F;IAEM,cAAc,IAAI,MAAM,CAwB9B;IAEM,2BAA2B,CAAC,MAAM,SAAI,GAAG,MAAM,CAcrD;CACF"}

package/dest/mem_pools/tx_pool_v2/tx_pool_bench_metrics.js

@@ -0,0 +1,70 @@
+/**
+ * Metrics types for tx pool benchmarks.
+ */ export var TxPoolOperation = /*#__PURE__*/ function(TxPoolOperation) {
+    TxPoolOperation["ADD_PENDING_TXS"] = "addPendingTxs";
+    TxPoolOperation["CAN_ADD_PENDING_TX"] = "canAddPendingTx";
+    TxPoolOperation["GET_PENDING_TX_HASHES"] = "getPendingTxHashes";
+    TxPoolOperation["GET_TX_BY_HASH"] = "getTxByHash";
+    TxPoolOperation["GET_TXS_BY_HASH"] = "getTxsByHash";
+    TxPoolOperation["HAS_TXS"] = "hasTxs";
+    TxPoolOperation["HANDLE_MINED_BLOCK"] = "handleMinedBlock";
+    TxPoolOperation["PREPARE_FOR_SLOT"] = "prepareForSlot";
+    TxPoolOperation["HANDLE_PRUNED_BLOCKS"] = "handlePrunedBlocks";
+    TxPoolOperation["GET_LOWEST_PRIORITY_PENDING"] = "getLowestPriorityPending";
+    TxPoolOperation["HYDRATE_FROM_DATABASE"] = "hydrateFromDatabase";
+    return TxPoolOperation;
+}({});
+/**
+ * Collects and formats tx pool benchmark metrics.
+ */ export class TxPoolBenchMetrics {
+    metrics = [];
+    addMetric(operation, poolSize, batchSize, value) {
+        this.metrics.push({
+            operation,
+            poolSize,
+            batchSize,
+            value
+        });
+    }
+    toPrettyString() {
+        let pretty = 'TxPool Benchmark Metrics:\n';
+        pretty += '='.repeat(60) + '\n';
+        // Group by operation
+        const byOperation = new Map();
+        for (const metric of this.metrics){
+            if (!byOperation.has(metric.operation)) {
+                byOperation.set(metric.operation, []);
+            }
+            byOperation.get(metric.operation).push(metric);
+        }
+        for (const [operation, opMetrics] of byOperation){
+            pretty += `\n${operation}:\n`;
+            for (const metric of opMetrics){
+                const poolSizeStr = metric.poolSize > 0 ? `pool=${metric.poolSize}` : '';
+                const batchSizeStr = metric.batchSize > 0 ? `batch=${metric.batchSize}` : '';
+                const params = [
+                    poolSizeStr,
+                    batchSizeStr
+                ].filter(Boolean).join(', ');
+                pretty += `  ${params ? `(${params})` : ''}: ${metric.value.toFixed(3)} ms\n`;
+            }
+        }
+        return pretty;
+    }
+    toGithubActionBenchmarkJSON(indent = 2) {
+        const data = this.metrics.map((metric)=>{
+            const poolSizeStr = metric.poolSize > 0 ? `${metric.poolSize} txs in pool` : '';
+            const batchSizeStr = metric.batchSize > 0 ? `batch of ${metric.batchSize}` : '';
+            const params = [
+                poolSizeStr,
+                batchSizeStr
+            ].filter(Boolean).join('/');
+            return {
+                name: `TxPool/${metric.operation}${params ? `/${params}` : ''}`,
+                value: metric.value,
+                unit: 'ms'
+            };
+        });
+        return JSON.stringify(data, null, indent);
+    }
+}

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

@@ -0,0 +1,108 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
+import type { L2BlockId } from '@aztec/stdlib/block';
+import { type TxMetaData, type TxState } from './tx_metadata.js';
+/**
+ * Manages in-memory indices for the transaction pool.
+ *
+ * Tracks transaction metadata and maintains several indices for efficient querying:
+ * - Metadata by txHash (primary store)
+ * - Nullifier to txHash mapping (pending txs only)
+ * - Fee payer to txHashes mapping (pending txs only)
+ * - Priority-ordered pending txs
+ * - Protected transaction tracking
+ *
+ * Key invariant: Only pending txs appear in nullifier/feePayer/priority indices.
+ */
+export declare class TxPoolIndices {
+    #private;
+    /**
+     * Derives the transaction state from its metadata and protection status.
+     * A transaction is:
+     * - 'mined' if it has a minedL2BlockId
+     * - 'protected' if it's in the protectedTransactions map (but not mined)
+     * - 'pending' otherwise
+     */
+    getTxState(meta: TxMetaData): TxState;
+    getMetadata(txHash: string): TxMetaData | undefined;
+    has(txHash: string): boolean;
+    isEmpty(): boolean;
+    getTxCount(): number;
+    /**
+     * Iterates pending transaction hashes in priority order.
+     * @param order - 'desc' for highest priority first, 'asc' for lowest priority first
+     */
+    iteratePendingByPriority(order: 'asc' | 'desc', filter?: (hash: string) => boolean): Generator<string>;
+    /**
+     * Iterates pending transaction hashes in priority order, skipping txs received after maxReceivedAt.
+     * @param order - 'desc' for highest priority first, 'asc' for lowest priority first
+     * @param maxReceivedAt - Only yield txs with receivedAt <= this value
+     */
+    iterateEligiblePendingByPriority(order: 'asc' | 'desc', maxReceivedAt: number): Generator<string>;
+    /** Iterates all metadata entries */
+    iterateMetadata(): Generator<[string, TxMetaData]>;
+    /** Adds a new pending transaction to all indices */
+    addPending(meta: TxMetaData): void;
+    /** Adds a new protected transaction (not added to pending indices) */
+    addProtected(meta: TxMetaData, slot: SlotNumber): void;
+    /** Adds a new mined transaction (not added to pending indices) */
+    addMined(meta: TxMetaData): void;
+    /** Marks an existing transaction as mined and removes from pending indices */
+    markAsMined(meta: TxMetaData, blockId: L2BlockId): void;
+    /** Clears the mined status from a transaction */
+    markAsUnmined(meta: TxMetaData): void;
+    /**
+     * Updates protection status for an existing transaction.
+     * Removes from pending indices if transitioning from pending to protected.
+     */
+    updateProtection(txHash: string, slotNumber: SlotNumber): void;
+    /** Sets protection for a txHash that may not have metadata yet */
+    setProtection(txHash: string, slotNumber: SlotNumber): void;
+    /** Gets the protection slot for a txHash, if protected */
+    getProtectionSlot(txHash: string): SlotNumber | undefined;
+    /** Removes protection from tx hashes */
+    clearProtection(txHashes: string[]): void;
+    /** Removes a transaction from all indices */
+    remove(txHash: string): void;
+    /** Removes a transaction from pending indices only (not metadata) */
+    removeFromPendingIndices(meta: TxMetaData): void;
+    /** Adds a transaction to pending indices (used during conflict resolution) */
+    addToPendingIndices(meta: TxMetaData): void;
+    /** Gets all pending transactions for a given fee payer */
+    getFeePayerPendingTxs(feePayer: string): TxMetaData[];
+    /** Gets the count of pending transactions */
+    getPendingTxCount(): number;
+    /** Gets the lowest priority pending transaction hashes (up to limit) */
+    getLowestPriorityPending(limit: number): string[];
+    /** Gets the lowest priority pending transaction */
+    getLowestPriorityPendingTx(): TxMetaData | undefined;
+    /** Gets all pending transactions */
+    getPendingTxs(): TxMetaData[];
+    /** Gets all fee payers with pending transactions */
+    getPendingFeePayers(): string[];
+    /** Gets the txHash that uses a given nullifier (pending txs only) */
+    getTxHashByNullifier(nullifier: string): string | undefined;
+    /** Gets txHashes for a fee payer */
+    getTxHashesByFeePayer(feePayer: string): Set<string> | undefined;
+    /** Finds all transactions mined in blocks after the given block number */
+    findTxsMinedAfter(blockNumber: number): TxMetaData[];
+    /** Finds tx hashes mined at or before the given block number */
+    findTxsMinedAtOrBefore(blockNumber: number): string[];
+    /** Finds protected tx hashes from slots earlier than the given slot number */
+    findExpiredProtectedTxs(slotNumber: SlotNumber): string[];
+    /** Filters out transactions that are currently protected */
+    filterUnprotected(txs: TxMetaData[]): TxMetaData[];
+    /** Filters to transactions that have metadata and are not mined */
+    filterRestorable(txHashes: string[]): TxMetaData[];
+    /** Counts transactions by state and estimates total metadata memory usage */
+    countTxs(): {
+        pending: number;
+        protected: number;
+        mined: number;
+        totalMetadataBytes: number;
+    };
+    /** Returns the estimated total memory consumed by all metadata objects */
+    getTotalMetadataBytes(): number;
+    /** Gets all mined transactions with their block IDs */
+    getMinedTxs(): [string, L2BlockId][];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcG9vbF9pbmRpY2VzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVtX3Bvb2xzL3R4X3Bvb2xfdjIvdHhfcG9vbF9pbmRpY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM3RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVyRCxPQUFPLEVBQUUsS0FBSyxVQUFVLEVBQUUsS0FBSyxPQUFPLEVBQStDLE1BQU0sa0JBQWtCLENBQUM7QUFFOUc7Ozs7Ozs7Ozs7O0dBV0c7QUFDSCxxQkFBYSxhQUFhOztJQWdCeEI7Ozs7OztPQU1HO0lBQ0gsVUFBVSxDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsT0FBTyxDQVFwQztJQUVELFdBQVcsQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLFVBQVUsR0FBRyxTQUFTLENBRWxEO0lBRUQsR0FBRyxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsT0FBTyxDQUUzQjtJQUVELE9BQU8sSUFBSSxPQUFPLENBRWpCO0lBRUQsVUFBVSxJQUFJLE1BQU0sQ0FFbkI7SUFNRDs7O09BR0c7SUFDRix3QkFBd0IsQ0FBQyxLQUFLLEVBQUUsS0FBSyxHQUFHLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksRUFBRSxNQUFNLEtBQUssT0FBTyxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FpQnRHO0lBRUQ7Ozs7T0FJRztJQUNGLGdDQUFnQyxDQUFDLEtBQUssRUFBRSxLQUFLLEdBQUcsTUFBTSxFQUFFLGFBQWEsRUFBRSxNQUFNLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQU9qRztJQUVELG9DQUFvQztJQUNuQyxlQUFlLElBQUksU0FBUyxDQUFDLENBQUMsTUFBTSxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBRWxEO0lBTUQsb0RBQW9EO0lBQ3BELFVBQVUsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLElBQUksQ0FHakM7SUFFRCxzRUFBc0U7SUFDdEUsWUFBWSxDQUFDLElBQUksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLFVBQVUsR0FBRyxJQUFJLENBR3JEO0lBRUQsa0VBQWtFO0lBQ2xFLFFBQVEsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLElBQUksQ0FFL0I7SUFFRCw4RUFBOEU7SUFDOUUsV0FBVyxDQUFDLElBQUksRUFBRSxVQUFVLEVBQUUsT0FBTyxFQUFFLFNBQVMsR0FBRyxJQUFJLENBSXREO0lBRUQsaURBQWlEO0lBQ2pELGFBQWEsQ0FBQyxJQUFJLEVBQUUsVUFBVSxHQUFHLElBQUksQ0FFcEM7SUFFRDs7O09BR0c7SUFDSCxnQkFBZ0IsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxVQUFVLEdBQUcsSUFBSSxDQWlCN0Q7SUFFRCxrRUFBa0U7SUFDbEUsYUFBYSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLFVBQVUsR0FBRyxJQUFJLENBRTFEO0lBRUQsMERBQTBEO0lBQzFELGlCQUFpQixDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsVUFBVSxHQUFHLFNBQVMsQ0FFeEQ7SUFFRCx3Q0FBd0M7SUFDeEMsZUFBZSxDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsR0FBRyxJQUFJLENBSXhDO0lBRUQsNkNBQTZDO0lBQzdDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FTM0I7SUFFRCxxRUFBcUU7SUFDckUsd0JBQXdCLENBQUMsSUFBSSxFQUFFLFVBQVUsR0FBRyxJQUFJLENBRS9DO0lBRUQsOEVBQThFO0lBQzlFLG1CQUFtQixDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsSUFBSSxDQUUxQztJQU1ELDBEQUEwRDtJQUMxRCxxQkFBcUIsQ0FBQyxRQUFRLEVBQUUsTUFBTSxHQUFHLFVBQVUsRUFBRSxDQWFwRDtJQUVELDZDQUE2QztJQUM3QyxpQkFBaUIsSUFBSSxNQUFNLENBTTFCO0lBRUQsd0VBQXdFO0lBQ3hFLHdCQUF3QixDQUFDLEtBQUssRUFBRSxNQUFNLEdBQUcsTUFBTSxFQUFFLENBYWhEO0lBRUQsbURBQW1EO0lBQ25ELDBCQUEwQixJQUFJLFVBQVUsR0FBRyxTQUFTLENBUW5EO0lBRUQsb0NBQW9DO0lBQ3BDLGFBQWEsSUFBSSxVQUFVLEVBQUUsQ0FXNUI7SUFFRCxvREFBb0Q7SUFDcEQsbUJBQW1CLElBQUksTUFBTSxFQUFFLENBRTlCO0lBRUQscUVBQXFFO0lBQ3JFLG9CQUFvQixDQUFDLFNBQVMsRUFBRSxNQUFNLEdBQUcsTUFBTSxHQUFHLFNBQVMsQ0FFMUQ7SUFFRCxvQ0FBb0M7SUFDcEMscUJBQXFCLENBQUMsUUFBUSxFQUFFLE1BQU0sR0FBRyxHQUFHLENBQUMsTUFBTSxDQUFDLEdBQUcsU0FBUyxDQUUvRDtJQU1ELDBFQUEwRTtJQUMxRSxpQkFBaUIsQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLFVBQVUsRUFBRSxDQVFuRDtJQUVELGdFQUFnRTtJQUNoRSxzQkFBc0IsQ0FBQyxXQUFXLEVBQUUsTUFBTSxHQUFHLE1BQU0sRUFBRSxDQVFwRDtJQUVELDhFQUE4RTtJQUM5RSx1QkFBdUIsQ0FBQyxVQUFVLEVBQUUsVUFBVSxHQUFHLE1BQU0sRUFBRSxDQVF4RDtJQUVELDREQUE0RDtJQUM1RCxpQkFBaUIsQ0FBQyxHQUFHLEVBQUUsVUFBVSxFQUFFLEdBQUcsVUFBVSxFQUFFLENBRWpEO0lBRUQsbUVBQW1FO0lBQ25FLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxNQUFNLEVBQUUsR0FBRyxVQUFVLEVBQUUsQ0FTakQ7SUFNRCw2RUFBNkU7SUFDN0UsUUFBUSxJQUFJO1FBQUUsT0FBTyxFQUFFLE1BQU0sQ0FBQztRQUFDLFNBQVMsRUFBRSxNQUFNLENBQUM7UUFBQyxLQUFLLEVBQUUsTUFBTSxDQUFDO1FBQUMsa0JBQWtCLEVBQUUsTUFBTSxDQUFBO0tBQUUsQ0FtQjVGO0lBRUQsMEVBQTBFO0lBQzFFLHFCQUFxQixJQUFJLE1BQU0sQ0FNOUI7SUFFRCx1REFBdUQ7SUFDdkQsV0FBVyxJQUFJLENBQUMsTUFBTSxFQUFFLFNBQVMsQ0FBQyxFQUFFLENBUW5DO0NBcURGIn0=

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

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