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

package/dest/messages/tx_resolver_service.d.ts

@@ -0,0 +1,28 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { TxHash } from '@aztec/stdlib/tx';
+/** Resolves transaction hashes into their on-chain context (note hashes, nullifiers, and mined position). */
+export declare class TxResolverService {
+    private readonly aztecNode;
+    constructor(aztecNode: AztecNode);
+    /**
+     * Resolves a list of tx hashes into their on-chain context.
+     *
+     * For each tx hash, looks up the corresponding tx effect and extracts its note hashes and nullifiers, and the
+     * position it was mined at. Returns `null` for tx hashes that are zero, not yet available, or in blocks beyond the
+     * anchor block.
+     */
+    resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(TxOnchainContext | null)[]>;
+}
+/** The onchain context of a tx: the position it was mined at, and the effects it produced. */
+export type TxOnchainContext = {
+    txHash: TxHash;
+    noteHashes: Fr[];
+    nullifiers: Fr[];
+    blockNumber: BlockNumber;
+    blockHash: BlockHash;
+    txIndexInBlock: number;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhfcmVzb2x2ZXJfc2VydmljZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21lc3NhZ2VzL3R4X3Jlc29sdmVyX3NlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsV0FBVyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbkUsT0FBTyxFQUFFLEVBQUUsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ3BELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3JELE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ2pFLE9BQU8sRUFBd0IsTUFBTSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFaEUsNkdBQTZHO0FBQzdHLHFCQUFhLGlCQUFpQjtJQUNoQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFBdEMsWUFBNkIsU0FBUyxFQUFFLFNBQVMsRUFBSTtJQUVyRDs7Ozs7O09BTUc7SUFDRyxVQUFVLENBQUMsUUFBUSxFQUFFLEVBQUUsRUFBRSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sR0FBRyxPQUFPLENBQUMsQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsRUFBRSxDQUFDLENBa0RoRztDQUNGO0FBRUQsOEZBQThGO0FBQzlGLE1BQU0sTUFBTSxnQkFBZ0IsR0FBRztJQUM3QixNQUFNLEVBQUUsTUFBTSxDQUFDO0lBQ2YsVUFBVSxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQ2pCLFVBQVUsRUFBRSxFQUFFLEVBQUUsQ0FBQztJQUNqQixXQUFXLEVBQUUsV0FBVyxDQUFDO0lBQ3pCLFNBQVMsRUFBRSxTQUFTLENBQUM7SUFDckIsY0FBYyxFQUFFLE1BQU0sQ0FBQztDQUN4QixDQUFDIn0=

package/dest/messages/tx_resolver_service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tx_resolver_service.d.ts","sourceRoot":"","sources":["../../src/messages/tx_resolver_service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAEnE,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAwB,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAEhE,6GAA6G;AAC7G,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAAtC,YAA6B,SAAS,EAAE,SAAS,EAAI;IAErD;;;;;;OAMG;IACG,UAAU,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,gBAAgB,GAAG,IAAI,CAAC,EAAE,CAAC,CAkDhG;CACF;AAED,8FAA8F;AAC9F,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}

package/dest/messages/tx_resolver_service.js

@@ -0,0 +1,61 @@
+import { uniqueBy } from '@aztec/foundation/collection';
+import { TxHash } from '@aztec/stdlib/tx';
+/** Resolves transaction hashes into their on-chain context (note hashes, nullifiers, and mined position). */ export class TxResolverService {
+    aztecNode;
+    constructor(aztecNode){
+        this.aztecNode = aztecNode;
+    }
+    /**
+   * Resolves a list of tx hashes into their on-chain context.
+   *
+   * For each tx hash, looks up the corresponding tx effect and extracts its note hashes and nullifiers, and the
+   * position it was mined at. Returns `null` for tx hashes that are zero, not yet available, or in blocks beyond the
+   * anchor block.
+   */ async resolveTxs(txHashes, anchorBlockNumber) {
+        const nonZeroTxHashes = txHashes.filter((h)=>!h.isZero()).map((h)=>TxHash.fromField(h));
+        const uniqueTxHashes = uniqueBy(nonZeroTxHashes, (h)=>h.toString());
+        const fetched = await Promise.all(uniqueTxHashes.map((h)=>this.aztecNode.getTxReceipt(h, {
+                includeTxEffect: true
+            })));
+        const txEffects = new Map(uniqueTxHashes.map((h, i)=>{
+            const receipt = fetched[i];
+            if (!receipt.isMined() || !receipt.txEffect) {
+                return [
+                    h.toString(),
+                    undefined
+                ];
+            }
+            return [
+                h.toString(),
+                {
+                    data: receipt.txEffect,
+                    l2BlockNumber: receipt.blockNumber,
+                    l2BlockHash: receipt.blockHash,
+                    txIndexInBlock: receipt.txIndexInBlock,
+                    slotNumber: receipt.slotNumber
+                }
+            ];
+        }).filter((entry)=>entry[1] !== undefined));
+        return txHashes.map((txHashField)=>{
+            const txHash = TxHash.fromField(txHashField);
+            const txEffect = txEffects.get(txHash.toString());
+            if (!txEffect || txEffect.l2BlockNumber > anchorBlockNumber) {
+                return null;
+            }
+            // Every tx has at least one nullifier (the first nullifier derived from the tx hash). Hitting this condition
+            // would mean a buggy node, but since consumers rely on nullifiers[0], the defensive check does no harm.
+            const data = txEffect.data;
+            if (data.nullifiers.length === 0) {
+                throw new Error(`Tx effect for ${txHash} has no nullifiers`);
+            }
+            return {
+                txHash: data.txHash,
+                noteHashes: data.noteHashes,
+                nullifiers: data.nullifiers,
+                blockNumber: txEffect.l2BlockNumber,
+                blockHash: txEffect.l2BlockHash,
+                txIndexInBlock: txEffect.txIndexInBlock
+            };
+        });
+    }
+}

package/dest/node/benchmarked_node.d.ts

@@ -0,0 +1,20 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/client';
+import type { NodeStats } from '@aztec/stdlib/tx';
+export interface Recording {
+    /** Closes the recording and returns what it saw. Reads served after this are not recorded. */
+    stop(): NodeStats;
+}
+/** An {@link AztecNode} wrapper that can report the reads it serves. */
+export interface BenchmarkedAztecNode extends AztecNode {
+    /**
+     * Opens a recording of the reads this wrapper serves, until {@link Recording.stop}. Recordings are independent, so
+     * several may run at once: one measuring a whole run sees the same reads as one measuring a single operation.
+     *
+     * Nothing is measured while none is open, which is what keeps a long-lived wrapper from accumulating a run's worth
+     * of timings nobody asked for.
+     */
+    startRecording(): Recording;
+}
+/** Wraps `node` so that the reads it answers can be recorded. */
+export declare function withRecording(node: AztecNode): BenchmarkedAztecNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmVuY2htYXJrZWRfbm9kZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL25vZGUvYmVuY2htYXJrZWRfbm9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUNqRSxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQWlCbEQsTUFBTSxXQUFXLFNBQVM7SUFDeEIsOEZBQThGO0lBQzlGLElBQUksSUFBSSxTQUFTLENBQUM7Q0FDbkI7QUFFRCx3RUFBd0U7QUFDeEUsTUFBTSxXQUFXLG9CQUFxQixTQUFRLFNBQVM7SUFDckQ7Ozs7OztPQU1HO0lBQ0gsY0FBYyxJQUFJLFNBQVMsQ0FBQztDQUM3QjtBQUVELGlFQUFpRTtBQUNqRSx3QkFBZ0IsYUFBYSxDQUFDLElBQUksRUFBRSxTQUFTLEdBQUcsb0JBQW9CLENBNEZuRSJ9

package/dest/node/benchmarked_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmarked_node.d.ts","sourceRoot":"","sources":["../../src/node/benchmarked_node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAiBlD,MAAM,WAAW,SAAS;IACxB,8FAA8F;IAC9F,IAAI,IAAI,SAAS,CAAC;CACnB;AAED,wEAAwE;AACxE,MAAM,WAAW,oBAAqB,SAAQ,SAAS;IACrD;;;;;;OAMG;IACH,cAAc,IAAI,SAAS,CAAC;CAC7B;AAED,iEAAiE;AACjE,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,oBAAoB,CA4FnE"}

package/dest/node/benchmarked_node.js

@@ -0,0 +1,94 @@
+import { Timer } from '@aztec/foundation/timer';
+/** Wraps `node` so that the reads it answers can be recorded. */ export function withRecording(node) {
+    // The stats of every recording currently open
+    const open = new Set();
+    // Round trip tracking
+    let inFlightCount = 0;
+    let currentRoundTripTimer = null;
+    let currentRoundTripMethods = [];
+    return new Proxy(node, {
+        get (target, prop) {
+            if (prop === 'startRecording') {
+                return ()=>{
+                    const stats = {
+                        perMethod: {},
+                        roundTrips: {
+                            roundTrips: 0,
+                            totalBlockingTime: 0,
+                            roundTripDurations: [],
+                            roundTripMethods: []
+                        }
+                    };
+                    open.add(stats);
+                    return {
+                        stop: ()=>{
+                            open.delete(stats);
+                            return stats;
+                        }
+                    };
+                };
+            }
+            const value = Reflect.get(target, prop);
+            if (typeof value !== 'function' || typeof prop !== 'string') {
+                return value;
+            }
+            return (...args)=>{
+                // With no recording open there is nobody to report to, so the read is left untimed.
+                if (open.size === 0) {
+                    return value.apply(target, args);
+                }
+                // Start of a new round trip batch?
+                if (inFlightCount === 0) {
+                    currentRoundTripTimer = new Timer();
+                    currentRoundTripMethods = [];
+                }
+                inFlightCount++;
+                currentRoundTripMethods.push(prop);
+                const callTimer = new Timer();
+                const result = value.apply(target, args);
+                // Handle completion - called when the call finishes (after Promise resolves)
+                const handleCompletion = ()=>{
+                    const callTime = callTimer.ms();
+                    for (const stats of open){
+                        timesFor(stats, prop).push(callTime);
+                    }
+                    inFlightCount--;
+                    // End of round trip batch - all concurrent calls completed
+                    if (inFlightCount === 0 && currentRoundTripTimer) {
+                        const roundTripTime = currentRoundTripTimer.ms();
+                        for (const { roundTrips } of open){
+                            roundTrips.roundTrips++;
+                            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 (isThenable(result)) {
+                    return result.then((resolved)=>{
+                        handleCompletion();
+                        return resolved;
+                    }, (error)=>{
+                        handleCompletion();
+                        throw error;
+                    });
+                } else {
+                    // Synchronous method - handle completion immediately
+                    handleCompletion();
+                    return result;
+                }
+            };
+        }
+    });
+}
+/** The times `stats` holds for `method`, added on first use. */ function timesFor(stats, method) {
+    return (stats.perMethod[method] ??= {
+        times: []
+    }).times;
+}
+/** Whether completion can be chained onto `value` with `.then`, which a promise from any implementation allows. */ function isThenable(value) {
+    return typeof value === 'object' && value !== null && 'then' in value && typeof value.then === 'function';
+}

package/dest/node/caching_aztec_node.d.ts

@@ -0,0 +1,24 @@
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type BenchmarkedAztecNode } from './benchmarked_node.js';
+/**
+ * An {@link AztecNode} wrapper that serves repeated reads from a cache it owns.
+ */
+export interface CachingAztecNode extends BenchmarkedAztecNode {
+    /** Clears the read cache. The owner calls this periodically to bound memory. Cached entries never go stale. */
+    wipeCache(): void;
+}
+/**
+ * Wraps `node`, serving repeated reads from a cache the wrapper owns. Consumers share cached reads by sharing the
+ * wrapper.
+ *
+ * Only hash-pinned reads are cached. A block hash names immutable content, so the same call can never correctly answer
+ * differently, and even an `undefined` witness or leaf index is kept as a non-membership fact. That makes the wrapper
+ * safe for any consumer, whatever its anchor block. Uncached methods, and reads that name a block any other way (see
+ * {@link hashReferenceOf}), pass straight through. A few entries below opt out even when hash-pinned, where the answer
+ * can still change, and the tag queries opt in only once the request also stops short of blocks yet to be produced
+ * (see {@link hasImmutableAnswer}).
+ *
+ * Wiping (see {@link CachingAztecNode.wipeCache}) bounds memory. Correctness does not depend on it.
+ */
+export declare function withCache(node: AztecNode): CachingAztecNode;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGluZ19henRlY19ub2RlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm9kZS9jYWNoaW5nX2F6dGVjX25vZGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxLQUFLLEVBQUUsU0FBUyxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFZakUsT0FBTyxFQUFFLEtBQUssb0JBQW9CLEVBQWlCLE1BQU0sdUJBQXVCLENBQUM7QUFFakY7O0dBRUc7QUFDSCxNQUFNLFdBQVcsZ0JBQWlCLFNBQVEsb0JBQW9CO0lBQzVELCtHQUErRztJQUMvRyxTQUFTLElBQUksSUFBSSxDQUFDO0NBQ25CO0FBRUQ7Ozs7Ozs7Ozs7OztHQVlHO0FBQ0gsd0JBQWdCLFNBQVMsQ0FBQyxJQUFJLEVBQUUsU0FBUyxHQUFHLGdCQUFnQixDQXdKM0QifQ==

package/dest/node/caching_aztec_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caching_aztec_node.d.ts","sourceRoot":"","sources":["../../src/node/caching_aztec_node.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAYjE,OAAO,EAAE,KAAK,oBAAoB,EAAiB,MAAM,uBAAuB,CAAC;AAEjF;;GAEG;AACH,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,+GAA+G;IAC/G,SAAS,IAAI,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,GAAG,gBAAgB,CAwJ3D"}

package/dest/node/caching_aztec_node.js

@@ -0,0 +1,267 @@
+import { BlockHash } from '@aztec/stdlib/block';
+import { withRecording } from './benchmarked_node.js';
+/**
+ * Wraps `node`, serving repeated reads from a cache the wrapper owns. Consumers share cached reads by sharing the
+ * wrapper.
+ *
+ * Only hash-pinned reads are cached. A block hash names immutable content, so the same call can never correctly answer
+ * differently, and even an `undefined` witness or leaf index is kept as a non-membership fact. That makes the wrapper
+ * safe for any consumer, whatever its anchor block. Uncached methods, and reads that name a block any other way (see
+ * {@link hashReferenceOf}), pass straight through. A few entries below opt out even when hash-pinned, where the answer
+ * can still change, and the tag queries opt in only once the request also stops short of blocks yet to be produced
+ * (see {@link hasImmutableAnswer}).
+ *
+ * Wiping (see {@link CachingAztecNode.wipeCache}) bounds memory. Correctness does not depend on it.
+ */ export function withCache(node) {
+    const cache = new AztecNodeCache();
+    // The recording wrapper sits below the cache, so a recording sees only the reads the node answered: a read served
+    // from the cache appears nowhere in it. Every read below goes to `source` rather than to `node`, and
+    // `startRecording` passes through this wrapper untouched.
+    const source = withRecording(node);
+    /** Runs `read` through `cache` when `block` pins a chain position by hash. Everything else goes to the node. */ const readCachedIfBlockIsHashPinned = (block, key, read, options)=>{
+        const blockHash = hashReferenceOf(block);
+        return blockHash === undefined ? read() : cache.fetch(key(blockHash.toString()), read, options);
+    };
+    const cachedReads = {
+        getBlock: (block, options)=>{
+            if (options?.includeL1PublishInfo || options?.includeAttestations) {
+                // These payloads keep changing after a block is fixed (its L1 publication status, its incoming committee
+                // attestations), so a repeat can correctly differ; read straight from the node.
+                return source.getBlock(block, options);
+            }
+            return readCachedIfBlockIsHashPinned(block, (blockHash)=>`block:${blockHash}:${keyPart(options)}`, ()=>source.getBlock(block, options), {
+                // PXE only asks for pinned blocks it has already observed, so an undefined answer means the node has not
+                // served the block yet, not that it never will.
+                shouldCache: (response)=>response !== undefined
+            });
+        },
+        getContract: (address, referenceBlock)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`contract:${blockHash}:${address.toString()}`, ()=>source.getContract(address, referenceBlock)),
+        getBlockHashMembershipWitness: (referenceBlock, blockHash)=>readCachedIfBlockIsHashPinned(referenceBlock, (referenceHash)=>`block-hash-membership-witness:${referenceHash}:${blockHash.toString()}`, ()=>source.getBlockHashMembershipWitness(referenceBlock, blockHash)),
+        getPublicDataWitness: (referenceBlock, leafSlot)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`public-data-witness:${blockHash}:${leafSlot.toString()}`, ()=>source.getPublicDataWitness(referenceBlock, leafSlot)),
+        getNoteHashMembershipWitness: (referenceBlock, noteHash)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`note-hash-membership-witness:${blockHash}:${noteHash.toString()}`, ()=>source.getNoteHashMembershipWitness(referenceBlock, noteHash)),
+        getNullifierMembershipWitness: (referenceBlock, nullifier)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`nullifier-membership-witness:${blockHash}:${nullifier.toString()}`, ()=>source.getNullifierMembershipWitness(referenceBlock, nullifier)),
+        getLowNullifierMembershipWitness: (referenceBlock, nullifier)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`low-nullifier-membership-witness:${blockHash}:${nullifier.toString()}`, ()=>source.getLowNullifierMembershipWitness(referenceBlock, nullifier)),
+        getL1ToL2MessageMembershipWitness: (referenceBlock, l1ToL2Message)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`l1-to-l2-message-membership-witness:${blockHash}:${l1ToL2Message.toString()}`, ()=>source.getL1ToL2MessageMembershipWitness(referenceBlock, l1ToL2Message)),
+        getPublicStorageAt: (referenceBlock, contractAddress, storageSlot)=>readCachedIfBlockIsHashPinned(referenceBlock, (blockHash)=>`public-storage:${blockHash}:${contractAddress.toString()}:${storageSlot.toString()}`, ()=>source.getPublicStorageAt(referenceBlock, contractAddress, storageSlot)),
+        findLeavesIndexes: (referenceBlock, treeId, leafValues)=>{
+            // Cached per leaf: only leaves without a cached result are fetched, in a single batched node call. The per-leaf
+            // keys don't fit single-key readCachedIfBlockIsHashPinned, so the hash gate is inline.
+            const referenceHash = hashReferenceOf(referenceBlock);
+            if (referenceHash === undefined) {
+                return source.findLeavesIndexes(referenceBlock, treeId, leafValues);
+            }
+            return readBatchedPerKey(cache, leafValues.map((leaf)=>`leaf-index:${referenceHash.toString()}:${treeId}:${leaf.toString()}`), (missing)=>source.findLeavesIndexes(referenceBlock, treeId, missing.map((i)=>leafValues[i])), {
+                method: 'findLeavesIndexes',
+                requested: 'leaves'
+            });
+        },
+        getPrivateLogsByTags: (query)=>{
+            if (!hasImmutableAnswer(query)) {
+                return source.getPrivateLogsByTags(query);
+            }
+            const keyPrefix = `private-logs:${privateLogsQueryKey(query)}`;
+            return readBatchedPerKey(cache, query.tags.map((tag)=>`${keyPrefix}:${tagQueryKey(tag)}`), (missing)=>source.getPrivateLogsByTags({
+                    ...query,
+                    tags: missing.map((i)=>query.tags[i])
+                }), {
+                method: 'getPrivateLogsByTags',
+                requested: 'tags'
+            });
+        },
+        getPublicLogsByTags: (query)=>{
+            if (!hasImmutableAnswer(query)) {
+                return source.getPublicLogsByTags(query);
+            }
+            const keyPrefix = `public-logs:${publicLogsQueryKey(query)}`;
+            return readBatchedPerKey(cache, query.tags.map((tag)=>`${keyPrefix}:${tagQueryKey(tag)}`), (missing)=>source.getPublicLogsByTags({
+                    ...query,
+                    tags: missing.map((i)=>query.tags[i])
+                }), {
+                method: 'getPublicLogsByTags',
+                requested: 'tags'
+            });
+        }
+    };
+    return new Proxy(source, {
+        get (target, prop) {
+            if (prop === 'wipeCache') {
+                return ()=>cache.wipe();
+            }
+            if (Object.hasOwn(cachedReads, prop)) {
+                return cachedReads[prop];
+            }
+            const value = Reflect.get(target, prop);
+            return typeof value === 'function' ? value.bind(target) : value;
+        }
+    });
+}
+/**
+ * Store of node read promises keyed by method and arguments.
+ *
+ * Holds no node reference of its own: it only memoizes promises handed to it by the {@link withCache} wrapper that
+ * owns it. Rejected promises are evicted so callers can retry. A settled value is kept unless the caller's
+ * `shouldCache` turns it away.
+ */ class AztecNodeCache {
+    cache = new Map();
+    /**
+   * Returns the cached promise for `key`, or runs `read` and caches the in-flight promise.
+   *
+   * `shouldCache` runs once the promise settles and answers whether its value is kept. Every settled value is kept by
+   * default. Callers waiting on a value that is then turned away still share the one in-flight read, so declining to
+   * keep a value costs nothing on concurrent reads.
+   */ fetch(key, read, { shouldCache } = {}) {
+        return this.#get(key) ?? this.#set(key, read(), shouldCache);
+    }
+    /**
+   * The cached promise for each of `keys`, `undefined` where there is none. For callers that batch their own misses
+   * rather than reading one key.
+   */ peekAll(keys) {
+        return keys.map((key)=>this.#get(key));
+    }
+    /**
+   * Clears the store.
+   */ wipe() {
+        this.cache.clear();
+    }
+    #get(key) {
+        return this.cache.get(key);
+    }
+    #set(key, promise, shouldCache) {
+        const evict = ()=>{
+            if (this.cache.get(key) === promise) {
+                this.cache.delete(key);
+            }
+        };
+        // A rejected read is evicted so callers can retry; a `shouldCache` that throws is treated the same way. The
+        // trailing catch keeps a throwing predicate from surfacing as an unhandled rejection on this detached promise.
+        promise.then((value)=>{
+            if (shouldCache && !shouldCache(value)) {
+                evict();
+            }
+        }, evict).catch(evict);
+        this.cache.set(key, promise);
+        return promise;
+    }
+}
+/**
+ * The block hash `block` pins to (a `BlockHash` or `{ hash }` reference), or `undefined` for every other way of naming
+ * a block.
+ *
+ * A number or a tag names a moving chain position, as does naming no block at all: a reorg can put a different block
+ * at the same number, and tags follow the growing chain. An `{ archive }` root is different, since it commits to every
+ * block hash up to its own block and so pins content as tightly as a hash. It stays uncached because no PXE read uses
+ * one: keeping an `undefined` answer as a non-membership fact is only sound because PXE pins blocks it has already
+ * seen, and that holds for the references PXE actually builds.
+ */ function hashReferenceOf(block) {
+    if (block instanceof BlockHash) {
+        return block;
+    }
+    if (typeof block === 'object' && block !== null && 'hash' in block) {
+        return block.hash;
+    }
+    return undefined;
+}
+/**
+ * Answers one result per entry of `keys`, taking whatever the cache already holds and fetching the rest in a single
+ * batched call. Each fetched result is cached under its own key, so a later call that overlaps this one fetches only
+ * the entries it has not seen, and a key repeated within `keys` is asked of the node once.
+ *
+ * `fetchMissing` receives the indexes still missing, in order, and must answer one result per requested index.
+ * `shortResponse` names the method and what it requests, for the error raised when it does not.
+ */ function readBatchedPerKey(cache, keys, fetchMissing, shortResponse) {
+    const cached = cache.peekAll(keys);
+    // One request per missing key rather than per missing position, so a key repeated in `keys` seeds a single entry
+    // that every position carrying it then reads.
+    const requestIndexByKey = new Map();
+    cached.forEach((result, index)=>{
+        if (result === undefined && !requestIndexByKey.has(keys[index])) {
+            requestIndexByKey.set(keys[index], index);
+        }
+    });
+    const fetchedByKey = new Map();
+    if (requestIndexByKey.size > 0) {
+        const requestedIndexes = [
+            ...requestIndexByKey.values()
+        ];
+        const batch = fetchMissing(requestedIndexes).then((fetched)=>{
+            if (fetched.length !== requestedIndexes.length) {
+                // Each entry is filled from the batch response by position. If the node returned fewer results than we asked
+                // for, the positions past the end would read undefined, which the cache keeps as a genuine answer, so a
+                // truncated response would be cached as fact. Rejecting the whole batch evicts those entries instead, so a
+                // retry re-fetches every one of them.
+                throw new Error(`${shortResponse.method} returned ${fetched.length} results for ${requestedIndexes.length} requested ` + `${shortResponse.requested}`);
+            }
+            return fetched;
+        });
+        [
+            ...requestIndexByKey.keys()
+        ].forEach((key, batchIndex)=>{
+            fetchedByKey.set(key, cache.fetch(key, ()=>batch.then((fetched)=>fetched[batchIndex])));
+        });
+    }
+    // Every position is answered: a cache hit, or the entry its key's request seeded just above.
+    return Promise.all(keys.map((key, index)=>cached[index] ?? fetchedByKey.get(key)));
+}
+/**
+ * Whether a tag query's answer can no longer change, and so can be cached.
+ *
+ * Two things would let it change, and the query has to rule out both. `referenceBlock` names the chain the answer
+ * belongs to, so the call fails once that block is gone rather than answering from a chain that reorged. `toBlock`
+ * stops the query below the tip, so blocks yet to be produced cannot add logs to the answer. Where the query starts
+ * does not matter: an open lower end reaches only blocks that are already behind it, which no longer move. PXE's tag
+ * queries get both from the `getAll*LogsByTags` helpers, which take them from the anchor block the query is pinned to.
+ */ function hasImmutableAnswer(query) {
+    return query.referenceBlock !== undefined && query.toBlock !== undefined;
+}
+/** Cache-key segment for the parts of a private tag query that every tag in it shares. */ function privateLogsQueryKey(query) {
+    const parts = {
+        ...sharedQueryKeyParts(query)
+    };
+    return Object.values(parts).map(keyPart).join(':');
+}
+/** Cache-key segment for the parts of a public tag query that every tag in it shares. */ function publicLogsQueryKey(query) {
+    const parts = {
+        ...sharedQueryKeyParts(query),
+        contractAddress: query.contractAddress
+    };
+    return Object.values(parts).map(keyPart).join(':');
+}
+/** The key parts {@link PrivateLogsQuery} and {@link PublicLogsQuery} have in common. */ function sharedQueryKeyParts(query) {
+    return {
+        referenceBlock: query.referenceBlock,
+        fromBlock: query.fromBlock,
+        toBlock: query.toBlock,
+        txHash: query.txHash,
+        includeEffects: query.includeEffects,
+        limitPerTag: query.limitPerTag
+    };
+}
+/**
+ * Cache-key segment for one tag entry, covering the pagination cursor as well as the tag: each page of a tag's stream
+ * is a read of its own, and a repeated query asks for the same pages in the same order.
+ */ function tagQueryKey(entry) {
+    return 'tag' in entry ? `${keyPart(entry.tag)}@${keyPart(entry.afterLog)}` : keyPart(entry);
+}
+/**
+ * Renders a call argument as a stable cache-key segment, via its own `toString` when it has one, else as JSON.
+ *
+ * Example: the options object `{ includeTransactions: true }` renders as `'{"includeTransactions":true}'`, and an
+ * absent optional argument as `'undefined'`.
+ */ function keyPart(value) {
+    if ([
+        'string',
+        'number',
+        'bigint',
+        'boolean'
+    ].includes(typeof value)) {
+        return String(value);
+    }
+    if (value && typeof value === 'object') {
+        const toString = value.toString;
+        if (toString && toString !== Object.prototype.toString) {
+            return toString.call(value);
+        }
+        return JSON.stringify(value, (_key, nested)=>typeof nested === 'bigint' ? nested.toString() : nested);
+    }
+    return String(value);
+}

package/dest/notes/note_service.d.ts

@@ -1,11 +1,13 @@
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { type InBlock } from '@aztec/stdlib/block';
 import { type AztecNode } from '@aztec/stdlib/interfaces/client';
 import { Note, NoteStatus } from '@aztec/stdlib/note';
-import type { BlockHeader, TxHash } from '@aztec/stdlib/tx';
-import type { AccessScopes } from '../access_scopes.js';
+import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { NoteValidationRequest } from '../contract_function_simulator/noir-structs/note_validation_request.js';
 import type { NoteStore } from '../storage/note_store/note_store.js';
 export declare class NoteService {
+    #private;
     private readonly noteStore;
     private readonly aztecNode;
     private readonly anchorBlockHeader;
@@ -18,9 +20,9 @@ export declare class NoteService {
      *
      * @param owner - The owner of the notes. If undefined, returns notes for all known owners.
      * @param status - The status of notes to fetch.
-     * @param scopes - The accounts whose notes we can access in this call. Currently optional and will default to all.
+     * @param scopes - The accounts whose notes we can access in this call. An empty list matches no notes.
      */
-    getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr, status: NoteStatus, scopes: AccessScopes): Promise<{
+    getNotes(contractAddress: AztecAddress, owner: AztecAddress | undefined, storageSlot: Fr, status: NoteStatus, scopes: AztecAddress[]): Promise<{
         contractAddress: AztecAddress;
         owner: AztecAddress;
         storageSlot: Fr;
@@ -43,7 +45,32 @@ export declare class NoteService {
      *
      * @param contractAddress - The contract whose notes should be checked and nullified.
      */
-    syncNoteNullifiers(contractAddress: AztecAddress, scopes: AccessScopes): Promise<void>;
-    validateAndStoreNote(contractAddress: AztecAddress, owner: AztecAddress, storageSlot: Fr, randomness: Fr, noteNonce: Fr, content: Fr[], noteHash: Fr, nullifier: Fr, txHash: TxHash, recipient: AztecAddress): Promise<void>;
+    syncNoteNullifiers(contractAddress: AztecAddress, scopes: AztecAddress[]): Promise<void>;
+    /**
+     * Validates and stores a batch of notes against the pre-fetched onchain context of their txs.
+     *
+     * For each request we must verify that:
+     *  - the note actually exists in the corresponding tx effect (and thus in the note hash tree), and
+     *  - the note has not already been nullified.
+     *
+     * Failing to do either would result in circuits getting either non-existent notes and failing to produce inclusion
+     * proofs for them, or getting nullified notes and producing duplicate nullifiers, both of which are catastrophic
+     * failure modes.
+     *
+     * Note that adding a note and removing it is *not* equivalent to never adding it in the first place. A nullifier
+     * emitted in a block that comes after note creation might result in the note being de-nullified by a chain reorg,
+     * so we must store both the note hash and nullifier block information.
+     *
+     * @param requests - The notes to validate and store.
+     * @param scope - The scope under which the notes are being stored.
+     * @param validationTxData - The onchain context of each request's tx, keyed by `TxHash.toString()`. Must contain
+     * entries for every request's txHash; missing entries are treated as a node bug and cause an error.
+     */
+    validateAndStoreNotes(requests: NoteValidationRequest[], scope: AztecAddress, validationTxData: ReadonlyMap<string, NoteValidationTxData>): Promise<void>;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZXMvbm90ZV9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUdoRSxPQUFPLEVBQUUsS0FBSyxTQUFTLEVBQWUsTUFBTSxpQ0FBaUMsQ0FBQztBQUM5RSxPQUFPLEVBQUUsSUFBSSxFQUFXLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRS9ELE9BQU8sS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUU1RCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN4RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUVyRSxxQkFBYSxXQUFXO0lBRXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBSnhCLFlBQ21CLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDNUI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNVLFFBQVEsQ0FDbkIsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksR0FBRyxTQUFTLEVBQy9CLFdBQVcsRUFBRSxFQUFFLEVBQ2YsTUFBTSxFQUFFLFVBQVUsRUFDbEIsTUFBTSxFQUFFLFlBQVk7Ozs7Ozs7Ozs7U0F5QnJCO0lBRUQ7Ozs7Ozs7Ozs7O09BV0c7SUFDVSxrQkFBa0IsQ0FBQyxlQUFlLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxZQUFZLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQXNDbEc7SUFFWSxvQkFBb0IsQ0FDL0IsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksRUFDbkIsV0FBVyxFQUFFLEVBQUUsRUFDZixVQUFVLEVBQUUsRUFBRSxFQUNkLFNBQVMsRUFBRSxFQUFFLEVBQ2IsT0FBTyxFQUFFLEVBQUUsRUFBRSxFQUNiLFFBQVEsRUFBRSxFQUFFLEVBQ1osU0FBUyxFQUFFLEVBQUUsRUFDYixNQUFNLEVBQUUsTUFBTSxFQUNkLFNBQVMsRUFBRSxZQUFZLEdBQ3RCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FzRWY7Q0FDRiJ9
+/** The onchain context of the tx a note validation request points at: where it was mined and its note hashes. */
+export type NoteValidationTxData = InBlock & {
+    noteHashes: Fr[];
+    txIndexInBlock: number;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90ZV9zZXJ2aWNlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbm90ZXMvbm90ZV9zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEtBQUssRUFBRSxZQUFZLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUNoRSxPQUFPLEVBQStCLEtBQUssT0FBTyxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFaEYsT0FBTyxFQUFFLEtBQUssU0FBUyxFQUFlLE1BQU0saUNBQWlDLENBQUM7QUFDOUUsT0FBTyxFQUFFLElBQUksRUFBVyxVQUFVLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUUvRCxPQUFPLEtBQUssRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVwRCxPQUFPLEtBQUssRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdFQUF3RSxDQUFDO0FBQ3BILE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHFDQUFxQyxDQUFDO0FBRXJFLHFCQUFhLFdBQVc7O0lBRXBCLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUztJQUMxQixPQUFPLENBQUMsUUFBUSxDQUFDLFNBQVM7SUFDMUIsT0FBTyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUI7SUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxLQUFLO0lBSnhCLFlBQ21CLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLFNBQVMsRUFBRSxTQUFTLEVBQ3BCLGlCQUFpQixFQUFFLFdBQVcsRUFDOUIsS0FBSyxFQUFFLE1BQU0sRUFDNUI7SUFFSjs7Ozs7Ozs7T0FRRztJQUNVLFFBQVEsQ0FDbkIsZUFBZSxFQUFFLFlBQVksRUFDN0IsS0FBSyxFQUFFLFlBQVksR0FBRyxTQUFTLEVBQy9CLFdBQVcsRUFBRSxFQUFFLEVBQ2YsTUFBTSxFQUFFLFVBQVUsRUFDbEIsTUFBTSxFQUFFLFlBQVksRUFBRTs7Ozs7Ozs7OztTQXlCdkI7SUFFRDs7Ozs7Ozs7Ozs7T0FXRztJQUNVLGtCQUFrQixDQUFDLGVBQWUsRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLFlBQVksRUFBRSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FxQnBHO0lBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7T0FtQkc7SUFDVSxxQkFBcUIsQ0FDaEMsUUFBUSxFQUFFLHFCQUFxQixFQUFFLEVBQ2pDLEtBQUssRUFBRSxZQUFZLEVBQ25CLGdCQUFnQixFQUFFLFdBQVcsQ0FBQyxNQUFNLEVBQUUsb0JBQW9CLENBQUMsR0FDMUQsT0FBTyxDQUFDLElBQUksQ0FBQyxDQWtHZjtDQVVGO0FBRUQsaUhBQWlIO0FBQ2pILE1BQU0sTUFBTSxvQkFBb0IsR0FBRyxPQUFPLEdBQUc7SUFDM0MsVUFBVSxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQ2pCLGNBQWMsRUFBRSxNQUFNLENBQUM7Q0FDeEIsQ0FBQyJ9

package/dest/notes/note_service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"note_service.d.ts","sourceRoot":"","sources":["../../src/notes/note_service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAW,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAErE,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,YACmB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EAC5B;IAEJ;;;;;;;;OAQG;IACU,QAAQ,CACnB,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,WAAW,EAAE,EAAE,EACf,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,YAAY;;;;;;;;;;SAyBrB;IAED;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAsClG;IAEY,oBAAoB,CAC/B,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,EAAE,EACf,UAAU,EAAE,EAAE,EACd,SAAS,EAAE,EAAE,EACb,OAAO,EAAE,EAAE,EAAE,EACb,QAAQ,EAAE,EAAE,EACZ,SAAS,EAAE,EAAE,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,YAAY,GACtB,OAAO,CAAC,IAAI,CAAC,CAsEf;CACF"}
+{"version":3,"file":"note_service.d.ts","sourceRoot":"","sources":["../../src/notes/note_service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAA+B,KAAK,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEhF,OAAO,EAAE,KAAK,SAAS,EAAe,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,IAAI,EAAW,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wEAAwE,CAAC;AACpH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAErE,qBAAa,WAAW;;IAEpB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,YACmB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,SAAS,EACpB,iBAAiB,EAAE,WAAW,EAC9B,KAAK,EAAE,MAAM,EAC5B;IAEJ;;;;;;;;OAQG;IACU,QAAQ,CACnB,eAAe,EAAE,YAAY,EAC7B,KAAK,EAAE,YAAY,GAAG,SAAS,EAC/B,WAAW,EAAE,EAAE,EACf,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,YAAY,EAAE;;;;;;;;;;SAyBvB;IAED;;;;;;;;;;;OAWG;IACU,kBAAkB,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBpG;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACU,qBAAqB,CAChC,QAAQ,EAAE,qBAAqB,EAAE,EACjC,KAAK,EAAE,YAAY,EACnB,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAC1D,OAAO,CAAC,IAAI,CAAC,CAkGf;CAUF;AAED,iHAAiH;AACjH,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG;IAC3C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC"}