@aztec/pxe 0.0.1-commit.c31f2472 → 0.0.1-commit.c52d6e7

package/dest/tagging/recipient_sync/load_private_logs_for_sender_recipient_pair.js

@@ -1,99 +0,0 @@
-import { UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN } from '../constants.js';
-import { findHighestIndexes } from './utils/find_highest_indexes.js';
-import { loadLogsForRange } from './utils/load_logs_for_range.js';
-/**
- * Loads private logs for `app` and  sender-recipient pair defined by `secret` and updates the highest aged and
- * finalized indexes in the db. At most load logs from blocks up to and including `anchorBlockNumber`.
- *
- * @dev This function can be safely executed "in parallel" for other sender-recipient pairs because the data in
- * in the tagging data provider is indexed by the secret and hence completely disjoint.
- */ export async function loadPrivateLogsForSenderRecipientPair(secret, app, aztecNode, taggingStore, anchorBlockNumber, anchorBlockHash, jobId) {
-    // # Explanation of how the algorithm works
-    // When we perform the sync we will look at logs that correspond to the tagging index range
-    // (highestAgedIndex, highestFinalizedIndex + WINDOW_LEN]
-    //
-    // highestAgedIndex is the highest index that was used in a tx that is included in a block at least
-    //                  `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds ago.
-    // highestFinalizedIndex is the highest index that was used in a tx that is included in a finalized block.
-    //
-    // "(" denotes an open end of the range - the index is not included in the range.
-    // "]" denotes a closed end of the range - the index is included in the range.
-    //
-    // ## Explanation of highestAgedIndex
-    //
-    // highestAgedIndex is chosen such that for all tagging indexes `i <= highestAgedIndex` we know that no new logs can
-    // ever appear.
-    //
-    // This relies on the "maximum inclusion timestamp" rule enforced by the kernel and rollup circuits:
-    // - a transaction's maximum inclusion timestamp is at most `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds after
-    //   the timestamp of its anchor block; and
-    // - a rollup only includes transactions whose inclusion timestamp is >= the L2 block's timestamp.
-    //
-    // Suppose some device used index `I` in a transaction anchored to block `B_N` at time `N`, and that block is now at
-    // least `MAX_INCLUDE_BY_TIMESTAMP_DURATION` seconds in the past. Then there is no possibility of any *other* device
-    // trying to use an index <= `I` while anchoring to a *newer* block than `B_N` because if we were anchoring to
-    // a newer block than `B_N` then we would already have seen the log with index `I` and hence the device would have
-    // chosen a larger index.
-    //    If that *other* device would anchor to a block older than `B_N` then that tx could never be included in a block
-    // because it would already have been expired.
-    //
-    // Therefore, once we see that index `I` has been used in a block that is at least `MAX_INCLUDE_BY_TIMESTAMP_DURATION`
-    // seconds old, we can safely stop syncing logs for all indexes <= `I` and set highestAgedIndex = `I`.
-    //
-    // ## Explanation of the upper bound `highestFinalizedIndex + WINDOW_LEN`
-    //
-    // When a sender chooses a tagging index, they will select an index that is at most `WINDOW_LEN` greater than
-    // the highest finalized index. If that index was already used, they will throw an error. For this reason we
-    // don't have to look further than `highestFinalizedIndex + WINDOW_LEN`.
-    let finalizedBlockNumber, currentTimestamp;
-    {
-        const [l2Tips, latestBlockHeader] = await Promise.all([
-            aztecNode.getL2Tips(),
-            aztecNode.getBlockHeader('latest')
-        ]);
-        if (!latestBlockHeader) {
-            throw new Error('Node failed to return latest block header when syncing logs');
-        }
-        [finalizedBlockNumber, currentTimestamp] = [
-            l2Tips.finalized.block.number,
-            latestBlockHeader.globalVariables.timestamp
-        ];
-    }
-    let start, end;
-    {
-        const currentHighestAgedIndex = await taggingStore.getHighestAgedIndex(secret, jobId);
-        const currentHighestFinalizedIndex = await taggingStore.getHighestFinalizedIndex(secret, jobId);
-        // We don't want to include the highest aged index so we start from `currentHighestAgedIndex + 1` (or 0 if not set)
-        start = currentHighestAgedIndex === undefined ? 0 : currentHighestAgedIndex + 1;
-        // The highest index a sender can choose is "highest finalized index + window length" but given that
-        // `loadLogsForRange` expects an exclusive `end` we add 1.
-        end = (currentHighestFinalizedIndex ?? 0) + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1;
-    }
-    const logs = [];
-    while(true){
-        // Get private logs with their block timestamps and corresponding tagging indexes
-        const privateLogsWithIndexes = await loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber, anchorBlockHash);
-        if (privateLogsWithIndexes.length === 0) {
-            break;
-        }
-        logs.push(...privateLogsWithIndexes.map(({ log })=>log));
-        const { highestAgedIndex, highestFinalizedIndex } = findHighestIndexes(privateLogsWithIndexes, currentTimestamp, finalizedBlockNumber);
-        // Store updates in data provider and update local variables
-        if (highestAgedIndex !== undefined) {
-            await taggingStore.updateHighestAgedIndex(secret, highestAgedIndex, jobId);
-        }
-        if (highestFinalizedIndex === undefined) {
-            break;
-        }
-        if (highestAgedIndex !== undefined && highestAgedIndex > highestFinalizedIndex) {
-            // This is just a sanity check as this should never happen.
-            throw new Error('Highest aged index lower than highest finalized index invariant violated');
-        }
-        await taggingStore.updateHighestFinalizedIndex(secret, highestFinalizedIndex, jobId);
-        // For the next iteration we want to look only at indexes for which we have not attempted to load logs yet while
-        // ensuring that we do not look further than WINDOW_LEN ahead of the highest finalized index.
-        start = end;
-        end = highestFinalizedIndex + UNFINALIZED_TAGGING_INDEXES_WINDOW_LEN + 1; // `end` is exclusive so we add 1.
-    }
-    return logs;
-}

package/dest/tagging/recipient_sync/utils/load_logs_for_range.d.ts

@@ -1,15 +0,0 @@
-import type { BlockNumber } from '@aztec/foundation/branded-types';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockHash } from '@aztec/stdlib/block';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { DirectionalAppTaggingSecret, TxScopedL2Log } from '@aztec/stdlib/logs';
-/**
- * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
- * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
- * exclusive.
- */
-export declare function loadLogsForRange(secret: DirectionalAppTaggingSecret, app: AztecAddress, aztecNode: AztecNode, start: number, end: number, anchorBlockNumber: BlockNumber, anchorBlockHash: BlockHash): Promise<Array<{
-    log: TxScopedL2Log;
-    taggingIndex: number;
-}>>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9hZF9sb2dzX2Zvcl9yYW5nZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvcmVjaXBpZW50X3N5bmMvdXRpbHMvbG9hZF9sb2dzX2Zvcl9yYW5nZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNuRSxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNyRCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSwyQkFBMkIsRUFBVSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUs3Rjs7OztHQUlHO0FBQ0gsd0JBQXNCLGdCQUFnQixDQUNwQyxNQUFNLEVBQUUsMkJBQTJCLEVBQ25DLEdBQUcsRUFBRSxZQUFZLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLEtBQUssRUFBRSxNQUFNLEVBQ2IsR0FBRyxFQUFFLE1BQU0sRUFDWCxpQkFBaUIsRUFBRSxXQUFXLEVBQzlCLGVBQWUsRUFBRSxTQUFTLEdBQ3pCLE9BQU8sQ0FBQyxLQUFLLENBQUM7SUFBRSxHQUFHLEVBQUUsYUFBYSxDQUFDO0lBQUMsWUFBWSxFQUFFLE1BQU0sQ0FBQTtDQUFFLENBQUMsQ0FBQyxDQTBCOUQifQ==

package/dest/tagging/recipient_sync/utils/load_logs_for_range.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"load_logs_for_range.d.ts","sourceRoot":"","sources":["../../../../src/tagging/recipient_sync/utils/load_logs_for_range.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,2BAA2B,EAAU,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAK7F;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,2BAA2B,EACnC,GAAG,EAAE,YAAY,EACjB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,iBAAiB,EAAE,WAAW,EAC9B,eAAe,EAAE,SAAS,GACzB,OAAO,CAAC,KAAK,CAAC;IAAE,GAAG,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CA0B9D"}

package/dest/tagging/recipient_sync/utils/load_logs_for_range.js

@@ -1,32 +0,0 @@
-import { SiloedTag, Tag } from '@aztec/stdlib/logs';
-import { getAllPrivateLogsByTags } from '../../get_all_logs_by_tags.js';
-/**
- * Gets private logs with their corresponding block timestamps and tagging indexes for the given index range, `app` and
- * `secret`. At most load logs from blocks up to and including `anchorBlockNumber`. `start` is inclusive and `end` is
- * exclusive.
- */ export async function loadLogsForRange(secret, app, aztecNode, start, end, anchorBlockNumber, anchorBlockHash) {
-    // Derive tags for the window
-    const preTags = Array(end - start).fill(0).map((_, i)=>({
-            secret,
-            index: start + i
-        }));
-    const siloedTags = await Promise.all(preTags.map((preTag)=>Tag.compute(preTag))).then((tags)=>Promise.all(tags.map((tag)=>SiloedTag.compute(tag, app))));
-    // We use the utility function below to retrieve all logs for the tags across all pages, so we don't need to handle
-    // pagination here.
-    const logs = await getAllPrivateLogsByTags(aztecNode, siloedTags, anchorBlockHash);
-    // Pair logs with their corresponding tagging indexes
-    const logsWithIndexes = [];
-    for(let i = 0; i < logs.length; i++){
-        const logsForTag = logs[i];
-        const taggingIndex = preTags[i].index;
-        for (const log of logsForTag){
-            if (log.blockNumber <= anchorBlockNumber) {
-                logsWithIndexes.push({
-                    log,
-                    taggingIndex
-                });
-            }
-        }
-    }
-    return logsWithIndexes;
-}

package/dest/tagging/sender_sync/utils/get_status_change_of_pending.d.ts

@@ -1,11 +0,0 @@
-import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { TxHash } from '@aztec/stdlib/tx';
-/**
- * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
- * dropped.
- */
-export declare function getStatusChangeOfPending(pending: TxHash[], aztecNode: AztecNode): Promise<{
-    txHashesToFinalize: TxHash[];
-    txHashesToDrop: TxHash[];
-}>;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3RhZ2dpbmcvc2VuZGVyX3N5bmMvdXRpbHMvZ2V0X3N0YXR1c19jaGFuZ2Vfb2ZfcGVuZGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sa0JBQWtCLENBQUM7QUFFcEQ7OztHQUdHO0FBQ0gsd0JBQXNCLHdCQUF3QixDQUM1QyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQ2pCLFNBQVMsRUFBRSxTQUFTLEdBQ25CLE9BQU8sQ0FBQztJQUFFLGtCQUFrQixFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQUMsY0FBYyxFQUFFLE1BQU0sRUFBRSxDQUFBO0NBQUUsQ0FBQyxDQXlCckUifQ==

package/dest/tagging/sender_sync/utils/get_status_change_of_pending.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get_status_change_of_pending.d.ts","sourceRoot":"","sources":["../../../../src/tagging/sender_sync/utils/get_status_change_of_pending.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,MAAM,EAAY,MAAM,kBAAkB,CAAC;AAEpD;;;GAGG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC;IAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAyBrE"}

package/dest/tagging/sender_sync/utils/get_status_change_of_pending.js

@@ -1,29 +0,0 @@
-import { TxStatus } from '@aztec/stdlib/tx';
-/**
- * Based on receipts obtained from `aztecNode` returns which pending transactions changed their status to finalized or
- * dropped.
- */ export async function getStatusChangeOfPending(pending, aztecNode) {
-    // Get receipts for all pending tx hashes.
-    const receipts = await Promise.all(pending.map((pendingTxHash)=>aztecNode.getTxReceipt(pendingTxHash)));
-    const txHashesToFinalize = [];
-    const txHashesToDrop = [];
-    for(let i = 0; i < receipts.length; i++){
-        const receipt = receipts[i];
-        const txHash = pending[i];
-        if (receipt.status === TxStatus.FINALIZED && receipt.hasExecutionSucceeded()) {
-            // Tx has been included in a block and the corresponding block is finalized --> we mark the indexes as
-            // finalized.
-            txHashesToFinalize.push(txHash);
-        } else if (receipt.isDropped() || receipt.hasExecutionReverted()) {
-            // Tx was dropped or reverted --> we drop the corresponding pending indexes.
-            // TODO(#17615): Don't drop pending indexes corresponding to non-revertible phases.
-            txHashesToDrop.push(txHash);
-        } else {
-        // Tx is still pending, not yet finalized, or was mined successfully but not yet finalized --> we don't do anything.
-        }
-    }
-    return {
-        txHashesToFinalize,
-        txHashesToDrop
-    };
-}

package/src/contract_function_simulator/benchmarked_node.ts

@@ -1,103 +0,0 @@
-import { Timer } from '@aztec/foundation/timer';
-import type { AztecNode } from '@aztec/stdlib/interfaces/client';
-import type { NodeStats, RoundTripStats } from '@aztec/stdlib/tx';
-
-/*
- * Proxy generator for an AztecNode that tracks the time taken for each RPC call and the number of round trips (actual
- * blocking waits for node responses).
- *
- * A round trip is counted when we transition from 0 to 1 in-flight calls, and ends when all concurrent calls complete.
- * This means parallel calls in Promise.all count as a single round trip.
- *
- * Note that batching of RPC calls in `safe_json_rpc_client.ts` could affect the round trip counts but in places we
- * currently use this information we do not even use HTTP as we have direct access to the Aztec Node instance in TS
- * (i.e. not running against external node) so this is not a problem for now.
- *
- * If you want to use this against external node and the info gets skewed by batching you can set the `maxBatchSize`
- * value in `safe_json_rpc_client.ts` to 1 (the main motivation for batching was to get around parallel http requests
- * limits in web browsers which is not a problem when debugging in node.js).
- */
-export type BenchmarkedNode = AztecNode & { getStats(): NodeStats };
-
-export class BenchmarkedNodeFactory {
-  static create(node: AztecNode): BenchmarkedNode {
-    // Per-method call stats
-    const perMethod: Partial<Record<keyof AztecNode, { times: number[] }>> = {};
-
-    // Round trip tracking
-    let inFlightCount = 0;
-    let currentRoundTripTimer: Timer | null = null;
-    let currentRoundTripMethods: string[] = [];
-    const roundTrips: RoundTripStats = {
-      roundTrips: 0,
-      totalBlockingTime: 0,
-      roundTripDurations: [],
-      roundTripMethods: [],
-    };
-
-    return new Proxy(node, {
-      get(target, prop: keyof BenchmarkedNode) {
-        if (prop === 'getStats') {
-          return (): NodeStats => {
-            return { perMethod, roundTrips };
-          };
-        } else {
-          return function (...args: any[]) {
-            // Track per-method stats
-            if (!perMethod[prop]) {
-              perMethod[prop] = { times: [] };
-            }
-
-            // Start of a new round trip batch?
-            if (inFlightCount === 0) {
-              roundTrips.roundTrips++;
-              currentRoundTripTimer = new Timer();
-              currentRoundTripMethods = [];
-            }
-            inFlightCount++;
-            currentRoundTripMethods.push(prop);
-
-            const callTimer = new Timer();
-            const result = (target[prop] as any).apply(target, args);
-
-            // Handle completion - called when the call finishes (after Promise resolves)
-            const handleCompletion = () => {
-              const callTime = callTimer.ms();
-              perMethod[prop]!.times.push(callTime);
-
-              inFlightCount--;
-
-              // End of round trip batch - all concurrent calls completed
-              if (inFlightCount === 0 && currentRoundTripTimer) {
-                const roundTripTime = currentRoundTripTimer.ms();
-                roundTrips.totalBlockingTime += roundTripTime;
-                roundTrips.roundTripDurations.push(roundTripTime);
-                roundTrips.roundTripMethods.push(currentRoundTripMethods);
-                currentRoundTripTimer = null;
-                currentRoundTripMethods = [];
-              }
-            };
-
-            // If the result is a Promise, chain the completion handler
-            if (result && typeof result.then === 'function') {
-              return result.then(
-                (value: any) => {
-                  handleCompletion();
-                  return value;
-                },
-                (error: any) => {
-                  handleCompletion();
-                  throw error;
-                },
-              );
-            } else {
-              // Synchronous method - handle completion immediately
-              handleCompletion();
-              return result;
-            }
-          };
-        }
-      },
-    }) as BenchmarkedNode;
-  }
-}