@aztec/pxe 0.0.0-test.1 → 0.0.1-commit.001888fc

package/dest/contract_function_simulator/oracle/utility_execution_oracle.js

@@ -0,0 +1,440 @@
+import { Aes128 } from '@aztec/foundation/crypto/aes128';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { LogLevels, createLogger } from '@aztec/foundation/log';
+import { isProtocolContract } from '@aztec/protocol-contracts';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import { computeAddressSecret } from '@aztec/stdlib/keys';
+import { deriveEcdhSharedSecret } from '@aztec/stdlib/logs';
+import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+import { createContractLogger, logContractMessage } from '../../contract_logging.js';
+import { EventService } from '../../events/event_service.js';
+import { LogService } from '../../logs/log_service.js';
+import { NoteService } from '../../notes/note_service.js';
+import { ORACLE_VERSION } from '../../oracle_version.js';
+import { EventValidationRequest } from '../noir-structs/event_validation_request.js';
+import { LogRetrievalRequest } from '../noir-structs/log_retrieval_request.js';
+import { LogRetrievalResponse } from '../noir-structs/log_retrieval_response.js';
+import { MessageTxContext } from '../noir-structs/message_tx_context.js';
+import { NoteValidationRequest } from '../noir-structs/note_validation_request.js';
+import { UtilityContext } from '../noir-structs/utility_context.js';
+import { pickNotes } from '../pick_notes.js';
+import { MessageLoadOracleInputs } from './message_load_oracle_inputs.js';
+/**
+ * The oracle for an execution of utility contract functions.
+ */ export class UtilityExecutionOracle {
+    isMisc = true;
+    isUtility = true;
+    contractLogger;
+    offchainEffects = [];
+    contractAddress;
+    authWitnesses;
+    capsules;
+    anchorBlockHeader;
+    contractStore;
+    noteStore;
+    keyStore;
+    addressStore;
+    aztecNode;
+    recipientTaggingStore;
+    senderAddressBookStore;
+    capsuleStore;
+    privateEventStore;
+    messageContextService;
+    jobId;
+    logger;
+    scopes;
+    constructor(args){
+        this.contractAddress = args.contractAddress;
+        this.authWitnesses = args.authWitnesses;
+        this.capsules = args.capsules;
+        this.anchorBlockHeader = args.anchorBlockHeader;
+        this.contractStore = args.contractStore;
+        this.noteStore = args.noteStore;
+        this.keyStore = args.keyStore;
+        this.addressStore = args.addressStore;
+        this.aztecNode = args.aztecNode;
+        this.recipientTaggingStore = args.recipientTaggingStore;
+        this.senderAddressBookStore = args.senderAddressBookStore;
+        this.capsuleStore = args.capsuleStore;
+        this.privateEventStore = args.privateEventStore;
+        this.messageContextService = args.messageContextService;
+        this.jobId = args.jobId;
+        this.logger = args.log ?? createLogger('simulator:client_view_context');
+        this.scopes = args.scopes;
+    }
+    assertCompatibleOracleVersion(version) {
+        // TODO(F-416): Remove this hack on v5 when protocol contracts are redeployed.
+        // Protocol contracts/canonical contracts shipped with committed bytecode that cannot be changed. Assert they use
+        // the expected pinned version or the current one. We want to allow for both the pinned and the current versions
+        // because we want this code to work with both the pinned and unpinned version since some branches do not have the
+        // pinned contracts (like e.g. next)
+        const LEGACY_ORACLE_VERSION = 12;
+        if (isProtocolContract(this.contractAddress)) {
+            if (version !== LEGACY_ORACLE_VERSION && version !== ORACLE_VERSION) {
+                throw new Error(`Expected legacy oracle version ${LEGACY_ORACLE_VERSION} or current oracle version ${ORACLE_VERSION} for alpha payload contract at ${this.contractAddress}, got ${version}.`);
+            }
+            return;
+        }
+        if (version !== ORACLE_VERSION) {
+            throw new Error(`Incompatible oracle version. Expected version ${ORACLE_VERSION}, got ${version}.`);
+        }
+    }
+    getRandomField() {
+        return Fr.random();
+    }
+    getUtilityContext() {
+        return new UtilityContext(this.anchorBlockHeader, this.contractAddress);
+    }
+    /**
+   * Retrieve keys associated with a specific master public key and app address.
+   * @param pkMHash - The master public key hash.
+   * @returns A Promise that resolves to nullifier keys.
+   * @throws If the keys are not registered in the key store.
+   * @throws If scopes are defined and the account is not in the scopes.
+   */ async getKeyValidationRequest(pkMHash) {
+        // If scopes are defined, check that the key belongs to an account in the scopes.
+        if (this.scopes !== 'ALL_SCOPES' && this.scopes.length > 0) {
+            let hasAccess = false;
+            for(let i = 0; i < this.scopes.length && !hasAccess; i++){
+                if (await this.keyStore.accountHasKey(this.scopes[i], pkMHash)) {
+                    hasAccess = true;
+                }
+            }
+            if (!hasAccess) {
+                throw new Error(`Key validation request denied: no scoped account has a key with hash ${pkMHash.toString()}.`);
+            }
+        }
+        return this.keyStore.getKeyValidationRequest(pkMHash, this.contractAddress);
+    }
+    /**
+   * Fetches the index and sibling path of a leaf at a given block from the note hash tree.
+   * @param anchorBlockHash - The hash of a block that contains the note hash tree root in which to find the membership
+   * witness.
+   * @param noteHash - The note hash to find in the note hash tree.
+   * @returns The membership witness containing the leaf index and sibling path
+   */ getNoteHashMembershipWitness(anchorBlockHash, noteHash) {
+        return this.aztecNode.getNoteHashMembershipWitness(anchorBlockHash, noteHash);
+    }
+    /**
+   * Fetches the index and sibling path of a block hash in the archive tree.
+   *
+   * Block hashes are the leaves of the archive tree. Each time a new block is added to the chain,
+   * its block hash is appended as a new leaf to the archive tree.
+   *
+   * @param anchorBlockHash - The hash of a block that contains the archive tree root in which to find the membership
+   * witness.
+   * @param blockHash - The block hash to find in the archive tree.
+   * @returns The membership witness containing the leaf index and sibling path
+   */ getBlockHashMembershipWitness(anchorBlockHash, blockHash) {
+        return this.aztecNode.getBlockHashMembershipWitness(anchorBlockHash, blockHash);
+    }
+    /**
+   * Returns a nullifier membership witness for a given nullifier at a given block.
+   * @param blockHash - The block hash at which to get the index.
+   * @param nullifier - Nullifier we try to find witness for.
+   * @returns The nullifier membership witness (if found).
+   */ getNullifierMembershipWitness(blockHash, nullifier) {
+        return this.aztecNode.getNullifierMembershipWitness(blockHash, nullifier);
+    }
+    /**
+   * Returns a low nullifier membership witness for a given nullifier at a given block.
+   * @param blockHash - The block hash at which to get the index.
+   * @param nullifier - Nullifier we try to find the low nullifier witness for.
+   * @returns The low nullifier membership witness (if found).
+   * @remarks Low nullifier witness can be used to perform a nullifier non-inclusion proof by leveraging the "linked
+   * list structure" of leaves and proving that a lower nullifier is pointing to a bigger next value than the nullifier
+   * we are trying to prove non-inclusion for.
+   */ getLowNullifierMembershipWitness(blockHash, nullifier) {
+        return this.aztecNode.getLowNullifierMembershipWitness(blockHash, nullifier);
+    }
+    /**
+   * Returns a public data tree witness for a given leaf slot at a given block.
+   * @param blockHash - The block hash at which to get the index.
+   * @param leafSlot - The slot of the public data tree to get the witness for.
+   * @returns - The witness
+   */ getPublicDataWitness(blockHash, leafSlot) {
+        return this.aztecNode.getPublicDataWitness(blockHash, leafSlot);
+    }
+    /**
+   * Fetches a block header of a given block.
+   * @param blockNumber - The number of a block of which to get the block header.
+   * @returns Block extracted from a block with block number `blockNumber`.
+   */ async getBlockHeader(blockNumber) {
+        const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
+        if (blockNumber > anchorBlockNumber) {
+            throw new Error(`Block number ${blockNumber} is higher than current block ${anchorBlockNumber}`);
+        }
+        const block = await this.aztecNode.getBlock(blockNumber);
+        return block?.header;
+    }
+    /**
+   * Retrieve the public keys and partial address associated to a given address.
+   * @param account - The account address.
+   * @returns The public keys and partial address, or `undefined` if the account is not registered.
+   */ async tryGetPublicKeysAndPartialAddress(account) {
+        const completeAddress = await this.addressStore.getCompleteAddress(account);
+        if (!completeAddress) {
+            return undefined;
+        }
+        return {
+            publicKeys: completeAddress.publicKeys,
+            partialAddress: completeAddress.partialAddress
+        };
+    }
+    async getCompleteAddressOrFail(account) {
+        const completeAddress = await this.addressStore.getCompleteAddress(account);
+        if (!completeAddress) {
+            throw new Error(`No public key registered for address ${account}.
+        Register it by calling pxe.addAccount(...).\nSee docs for context: https://docs.aztec.network/developers/resources/debugging/aztecnr-errors#simulation-error-no-public-key-registered-for-address-0x0-register-it-by-calling-pxeregisterrecipient-or-pxeregisteraccount`);
+        }
+        return completeAddress;
+    }
+    /**
+   * Returns a contract instance associated with an address or throws if not found.
+   * @param address - Address.
+   * @returns A contract instance.
+   */ async getContractInstance(address) {
+        const instance = await this.contractStore.getContractInstance(address);
+        if (!instance) {
+            throw new Error(`No contract instance found for address ${address.toString()}`);
+        }
+        return instance;
+    }
+    /**
+   * Returns an auth witness for the given message hash. Checks on the list of transient witnesses
+   * for this transaction first, and falls back to the local database if not found.
+   * @param messageHash - Hash of the message to authenticate.
+   * @returns Authentication witness for the requested message hash.
+   */ getAuthWitness(messageHash) {
+        return Promise.resolve(this.authWitnesses.find((w)=>w.requestHash.equals(messageHash))?.witness);
+    }
+    /**
+   * Gets some notes for a contract address and storage slot.
+   * Returns a flattened array containing filtered notes.
+   *
+   * @remarks
+   * Check for pending notes with matching slot.
+   * Real notes coming from DB will have a leafIndex which
+   * represents their index in the note hash tree.
+   *
+   * @param owner - The owner of the notes. If undefined, returns notes for all owners.
+   * @param storageSlot - The storage slot.
+   * @param numSelects - The number of valid selects in selectBy and selectValues.
+   * @param selectBy - An array of indices of the fields to selects.
+   * @param selectValues - The values to match.
+   * @param selectComparators - The comparators to use to match values.
+   * @param sortBy - An array of indices of the fields to sort.
+   * @param sortOrder - The order of the corresponding index in sortBy. (1: DESC, 2: ASC, 0: Do nothing)
+   * @param limit - The number of notes to retrieve per query.
+   * @param offset - The starting index for pagination.
+   * @param status - The status of notes to fetch.
+   * @returns Array of note data.
+   */ async getNotes(owner, storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
+        const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
+        const dbNotes = await noteService.getNotes(this.contractAddress, owner, storageSlot, status, this.scopes);
+        return pickNotes(dbNotes, {
+            selects: selectByIndexes.slice(0, numSelects).map((index, i)=>({
+                    selector: {
+                        index,
+                        offset: selectByOffsets[i],
+                        length: selectByLengths[i]
+                    },
+                    value: selectValues[i],
+                    comparator: selectComparators[i]
+                })),
+            sorts: sortByIndexes.map((index, i)=>({
+                    selector: {
+                        index,
+                        offset: sortByOffsets[i],
+                        length: sortByLengths[i]
+                    },
+                    order: sortOrder[i]
+                })),
+            limit,
+            offset
+        });
+    }
+    /**
+   * Check if a nullifier exists in the nullifier tree.
+   * @param innerNullifier - The inner nullifier.
+   * @returns A boolean indicating whether the nullifier exists in the tree or not.
+   */ async checkNullifierExists(innerNullifier) {
+        const [nullifier, anchorBlockHash] = await Promise.all([
+            siloNullifier(this.contractAddress, innerNullifier),
+            this.anchorBlockHeader.hash()
+        ]);
+        const [leafIndex] = await this.aztecNode.findLeavesIndexes(anchorBlockHash, MerkleTreeId.NULLIFIER_TREE, [
+            nullifier
+        ]);
+        return leafIndex?.data !== undefined;
+    }
+    /**
+   * Fetches a message from the executionStore, given its key.
+   * @param contractAddress - Address of a contract by which the message was emitted.
+   * @param messageHash - Hash of the message.
+   * @param secret - Secret used to compute a nullifier.
+   * @dev Contract address and secret are only used to compute the nullifier to get non-nullified messages
+   * @returns The l1 to l2 membership witness (index of message in the tree and sibling path).
+   */ async getL1ToL2MembershipWitness(contractAddress, messageHash, secret) {
+        const [messageIndex, siblingPath] = await getNonNullifiedL1ToL2MessageWitness(this.aztecNode, contractAddress, messageHash, secret);
+        return new MessageLoadOracleInputs(messageIndex, siblingPath);
+    }
+    /**
+   * Read the public storage data.
+   * @param blockHash - The block hash to read storage at.
+   * @param contractAddress - The address to read storage from.
+   * @param startStorageSlot - The starting storage slot.
+   * @param numberOfElements - Number of elements to read from the starting storage slot.
+   */ async storageRead(blockHash, contractAddress, startStorageSlot, numberOfElements) {
+        const slots = Array(numberOfElements).fill(0).map((_, i)=>new Fr(startStorageSlot.value + BigInt(i)));
+        const values = await Promise.all(slots.map((storageSlot)=>this.aztecNode.getPublicStorageAt(blockHash, contractAddress, storageSlot)));
+        this.logger.debug(`Oracle storage read: slots=[${slots.map((slot)=>slot.toString()).join(', ')}] address=${contractAddress.toString()} values=[${values.join(', ')}]`);
+        return values;
+    }
+    /**
+   * Returns a per-contract logger whose output is prefixed with `contract_log::<name>(<addrAbbrev>)`.
+   */ async #getContractLogger() {
+        if (!this.contractLogger) {
+            // Purpose of instanceId is to distinguish logs from different instances of the same component. It makes sense
+            // to re-use jobId as instanceId here as executions of different PXE jobs are isolated.
+            this.contractLogger = await createContractLogger(this.contractAddress, (addr)=>this.contractStore.getDebugContractName(addr), {
+                instanceId: this.jobId
+            });
+        }
+        return this.contractLogger;
+    }
+    async log(level, message, fields) {
+        if (!LogLevels[level]) {
+            throw new Error(`Invalid log level: ${level}`);
+        }
+        const logger = await this.#getContractLogger();
+        logContractMessage(logger, LogLevels[level], message, fields);
+    }
+    async fetchTaggedLogs(pendingTaggedLogArrayBaseSlot) {
+        const logService = new LogService(this.aztecNode, this.anchorBlockHeader, this.keyStore, this.capsuleStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.logger.getBindings());
+        await logService.fetchTaggedLogs(this.contractAddress, pendingTaggedLogArrayBaseSlot, this.scopes);
+    }
+    /**
+   * Validates all note and event validation requests enqueued via `enqueue_note_for_validation` and
+   * `enqueue_event_for_validation`, inserting them into the note database and event store respectively, making them
+   * queryable via `get_notes` and `getPrivateEvents`.
+   *
+   * This automatically clears both validation request queues, so no further work needs to be done by the caller.
+   * @param contractAddress - The address of the contract that the logs are tagged for.
+   * @param noteValidationRequestsArrayBaseSlot - The base slot of capsule array containing note validation requests.
+   * @param eventValidationRequestsArrayBaseSlot - The base slot of capsule array containing event validation requests.
+   */ async validateAndStoreEnqueuedNotesAndEvents(contractAddress, noteValidationRequestsArrayBaseSlot, eventValidationRequestsArrayBaseSlot, maxNotePackedLen, maxEventSerializedLen) {
+        // TODO(#10727): allow other contracts to store notes
+        if (!this.contractAddress.equals(contractAddress)) {
+            throw new Error(`Got a note validation request from ${contractAddress}, expected ${this.contractAddress}`);
+        }
+        // We read all note and event validation requests and process them all concurrently. This makes the process much
+        // faster as we don't need to wait for the network round-trip.
+        const noteValidationRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, this.jobId)).map((fields)=>NoteValidationRequest.fromFields(fields, maxNotePackedLen));
+        const eventValidationRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, this.jobId)).map((fields)=>EventValidationRequest.fromFields(fields, maxEventSerializedLen));
+        const noteService = new NoteService(this.noteStore, this.aztecNode, this.anchorBlockHeader, this.jobId);
+        const noteStorePromises = noteValidationRequests.map((request)=>noteService.validateAndStoreNote(request.contractAddress, request.owner, request.storageSlot, request.randomness, request.noteNonce, request.content, request.noteHash, request.nullifier, request.txHash, request.recipient));
+        const eventService = new EventService(this.anchorBlockHeader, this.aztecNode, this.privateEventStore, this.jobId);
+        const eventStorePromises = eventValidationRequests.map((request)=>eventService.validateAndStoreEvent(request.contractAddress, request.eventTypeId, request.randomness, request.serializedEvent, request.eventCommitment, request.txHash, request.recipient));
+        await Promise.all([
+            ...noteStorePromises,
+            ...eventStorePromises
+        ]);
+        // Requests are cleared once we're done.
+        await this.capsuleStore.setCapsuleArray(contractAddress, noteValidationRequestsArrayBaseSlot, [], this.jobId);
+        await this.capsuleStore.setCapsuleArray(contractAddress, eventValidationRequestsArrayBaseSlot, [], this.jobId);
+    }
+    async bulkRetrieveLogs(contractAddress, logRetrievalRequestsArrayBaseSlot, logRetrievalResponsesArrayBaseSlot) {
+        // TODO(#10727): allow other contracts to process partial notes
+        if (!this.contractAddress.equals(contractAddress)) {
+            throw new Error(`Got a note validation request from ${contractAddress}, expected ${this.contractAddress}`);
+        }
+        // We read all log retrieval requests and process them all concurrently. This makes the process much faster as we
+        // don't need to wait for the network round-trip.
+        const logRetrievalRequests = (await this.capsuleStore.readCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, this.jobId)).map(LogRetrievalRequest.fromFields);
+        const logService = new LogService(this.aztecNode, this.anchorBlockHeader, this.keyStore, this.capsuleStore, this.recipientTaggingStore, this.senderAddressBookStore, this.addressStore, this.jobId, this.logger.getBindings());
+        const maybeLogRetrievalResponses = await logService.bulkRetrieveLogs(logRetrievalRequests);
+        // Requests are cleared once we're done.
+        await this.capsuleStore.setCapsuleArray(contractAddress, logRetrievalRequestsArrayBaseSlot, [], this.jobId);
+        // The responses are stored as Option<LogRetrievalResponse> in a second CapsuleArray.
+        await this.capsuleStore.setCapsuleArray(contractAddress, logRetrievalResponsesArrayBaseSlot, maybeLogRetrievalResponses.map(LogRetrievalResponse.toSerializedOption), this.jobId);
+    }
+    async utilityResolveMessageContexts(contractAddress, messageContextRequestsArrayBaseSlot, messageContextResponsesArrayBaseSlot) {
+        try {
+            if (!this.contractAddress.equals(contractAddress)) {
+                throw new Error(`Got a message context request from ${contractAddress}, expected ${this.contractAddress}`);
+            }
+            const requestCapsules = await this.capsuleStore.readCapsuleArray(contractAddress, messageContextRequestsArrayBaseSlot, this.jobId);
+            const txHashes = requestCapsules.map((fields, i)=>{
+                if (fields.length !== 1) {
+                    throw new Error(`Malformed message context request at index ${i}: expected 1 field (tx hash), got ${fields.length}`);
+                }
+                return fields[0];
+            });
+            const maybeMessageContexts = await this.messageContextService.resolveMessageContexts(txHashes, this.anchorBlockHeader.getBlockNumber());
+            // Leave response in response capsule array.
+            await this.capsuleStore.setCapsuleArray(contractAddress, messageContextResponsesArrayBaseSlot, maybeMessageContexts.map(MessageTxContext.toSerializedOption), this.jobId);
+        } finally{
+            await this.capsuleStore.setCapsuleArray(contractAddress, messageContextRequestsArrayBaseSlot, [], this.jobId);
+        }
+    }
+    storeCapsule(contractAddress, slot, capsule) {
+        if (!contractAddress.equals(this.contractAddress)) {
+            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+        }
+        this.capsuleStore.storeCapsule(this.contractAddress, slot, capsule, this.jobId);
+        return Promise.resolve();
+    }
+    async loadCapsule(contractAddress, slot) {
+        if (!contractAddress.equals(this.contractAddress)) {
+            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+        }
+        return(// TODO(#12425): On the following line, the pertinent capsule gets overshadowed by the transient one. Tackle this.
+        this.capsules.find((c)=>c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ?? await this.capsuleStore.loadCapsule(this.contractAddress, slot, this.jobId));
+    }
+    deleteCapsule(contractAddress, slot) {
+        if (!contractAddress.equals(this.contractAddress)) {
+            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+        }
+        this.capsuleStore.deleteCapsule(this.contractAddress, slot, this.jobId);
+        return Promise.resolve();
+    }
+    copyCapsule(contractAddress, srcSlot, dstSlot, numEntries) {
+        if (!contractAddress.equals(this.contractAddress)) {
+            // TODO(#10727): instead of this check that this.contractAddress is allowed to access the external DB
+            throw new Error(`Contract ${contractAddress} is not allowed to access ${this.contractAddress}'s PXE DB`);
+        }
+        return this.capsuleStore.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries, this.jobId);
+    }
+    // TODO(#11849): consider replacing this oracle with a pure Noir implementation of aes decryption.
+    aes128Decrypt(ciphertext, iv, symKey) {
+        const aes128 = new Aes128();
+        return aes128.decryptBufferCBC(ciphertext, iv, symKey);
+    }
+    /**
+   * Retrieves the shared secret for a given address and ephemeral public key.
+   * @param address - The address to get the secret for.
+   * @param ephPk - The ephemeral public key to get the secret for.
+   * @returns The secret for the given address.
+   */ async getSharedSecret(address, ephPk) {
+        // TODO(#12656): return an app-siloed secret
+        const recipientCompleteAddress = await this.getCompleteAddressOrFail(address);
+        const ivskM = await this.keyStore.getMasterSecretKey(recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey);
+        const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
+        return deriveEcdhSharedSecret(addressSecret, ephPk);
+    }
+    emitOffchainEffect(data) {
+        this.offchainEffects.push({
+            data,
+            contractAddress: this.contractAddress
+        });
+        return Promise.resolve();
+    }
+    /** Returns offchain effects collected during execution. */ getOffchainEffects() {
+        return this.offchainEffects;
+    }
+}

package/dest/contract_function_simulator/pick_notes.d.ts

@@ -0,0 +1,85 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Comparator, type Note } from '@aztec/stdlib/note';
+export interface PropertySelector {
+    index: number;
+    offset: number;
+    length: number;
+}
+/**
+ * Configuration for selecting values.
+ */
+export interface Select {
+    /**
+     * Selector of the field to select and match.
+     */
+    selector: PropertySelector;
+    /**
+     * Required value of the field.
+     */
+    value: Fr;
+    /**
+     * The comparator to use
+     */
+    comparator: Comparator;
+}
+/**
+ * The order to sort an array.
+ */
+export declare enum SortOrder {
+    NADA = 0,
+    DESC = 1,
+    ASC = 2
+}
+/**
+ * Configuration for sorting values.
+ */
+export interface Sort {
+    /**
+     * Selector of the field to sort.
+     */
+    selector: PropertySelector;
+    /**
+     * Order to sort the field.
+     */
+    order: SortOrder;
+}
+/**
+ * Options for picking items from an array of BasicNoteData.
+ */
+interface GetOptions {
+    /**
+     * Configurations for selecting items.
+     * Default: empty array.
+     */
+    selects?: Select[];
+    /**
+     * Configurations for sorting items.
+     * Default: empty array.
+     */
+    sorts?: Sort[];
+    /**
+     * The number of items to retrieve per query.
+     * Default: 0. No limit.
+     */
+    limit?: number;
+    /**
+     * The starting index for pagination.
+     * Default: 0.
+     */
+    offset?: number;
+}
+/**
+ * Data needed from to perform sort.
+ */
+interface ContainsNote {
+    /**
+     * The note.
+     */
+    note: Note;
+}
+/**
+ * Pick from a note array a number of notes that meet the criteria.
+ */
+export declare function pickNotes<T extends ContainsNote>(noteDatas: T[], { selects, sorts, limit, offset }: GetOptions): T[];
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGlja19ub3Rlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci9waWNrX25vdGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRCxPQUFPLEVBQUUsVUFBVSxFQUFFLEtBQUssSUFBSSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFM0QsTUFBTSxXQUFXLGdCQUFnQjtJQUMvQixLQUFLLEVBQUUsTUFBTSxDQUFDO0lBQ2QsTUFBTSxFQUFFLE1BQU0sQ0FBQztJQUNmLE1BQU0sRUFBRSxNQUFNLENBQUM7Q0FDaEI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyxNQUFNO0lBQ3JCOztPQUVHO0lBQ0gsUUFBUSxFQUFFLGdCQUFnQixDQUFDO0lBQzNCOztPQUVHO0lBQ0gsS0FBSyxFQUFFLEVBQUUsQ0FBQztJQUNWOztPQUVHO0lBQ0gsVUFBVSxFQUFFLFVBQVUsQ0FBQztDQUN4QjtBQUVEOztHQUVHO0FBQ0gsb0JBQVksU0FBUztJQUNuQixJQUFJLElBQUk7SUFDUixJQUFJLElBQUk7SUFDUixHQUFHLElBQUk7Q0FDUjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxXQUFXLElBQUk7SUFDbkI7O09BRUc7SUFDSCxRQUFRLEVBQUUsZ0JBQWdCLENBQUM7SUFDM0I7O09BRUc7SUFDSCxLQUFLLEVBQUUsU0FBUyxDQUFDO0NBQ2xCO0FBRUQ7O0dBRUc7QUFDSCxVQUFVLFVBQVU7SUFDbEI7OztPQUdHO0lBQ0gsT0FBTyxDQUFDLEVBQUUsTUFBTSxFQUFFLENBQUM7SUFDbkI7OztPQUdHO0lBQ0gsS0FBSyxDQUFDLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFDZjs7O09BR0c7SUFDSCxLQUFLLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDZjs7O09BR0c7SUFDSCxNQUFNLENBQUMsRUFBRSxNQUFNLENBQUM7Q0FDakI7QUFFRDs7R0FFRztBQUNILFVBQVUsWUFBWTtJQUNwQjs7T0FFRztJQUNILElBQUksRUFBRSxJQUFJLENBQUM7Q0FDWjtBQThDRDs7R0FFRztBQUNILHdCQUFnQixTQUFTLENBQUMsQ0FBQyxTQUFTLFlBQVksRUFDOUMsU0FBUyxFQUFFLENBQUMsRUFBRSxFQUNkLEVBQUUsT0FBWSxFQUFFLEtBQVUsRUFBRSxLQUFTLEVBQUUsTUFBVSxFQUFFLEVBQUUsVUFBVSxHQUM5RCxDQUFDLEVBQUUsQ0FJTCJ9

package/dest/contract_function_simulator/pick_notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick_notes.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/pick_notes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,gCAAgC,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAE3D,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;OAEG;IACH,KAAK,EAAE,EAAE,CAAC;IACV;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;GAEG;AACH,oBAAY,SAAS;IACnB,IAAI,IAAI;IACR,IAAI,IAAI;IACR,GAAG,IAAI;CACR;AAED;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB;;OAEG;IACH,QAAQ,EAAE,gBAAgB,CAAC;IAC3B;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;CAClB;AAED;;GAEG;AACH,UAAU,UAAU;IAClB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,UAAU,YAAY;IACpB;;OAEG;IACH,IAAI,EAAE,IAAI,CAAC;CACZ;AA8CD;;GAEG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,YAAY,EAC9C,SAAS,EAAE,CAAC,EAAE,EACd,EAAE,OAAY,EAAE,KAAU,EAAE,KAAS,EAAE,MAAU,EAAE,EAAE,UAAU,GAC9D,CAAC,EAAE,CAIL"}

package/dest/contract_function_simulator/pick_notes.js

@@ -0,0 +1,51 @@
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { Comparator } from '@aztec/stdlib/note';
+/**
+ * The order to sort an array.
+ */ export var SortOrder = /*#__PURE__*/ function(SortOrder) {
+    SortOrder[SortOrder["NADA"] = 0] = "NADA";
+    SortOrder[SortOrder["DESC"] = 1] = "DESC";
+    SortOrder[SortOrder["ASC"] = 2] = "ASC";
+    return SortOrder;
+}({});
+const selectPropertyFromPackedNoteContent = (noteData, selector)=>{
+    const noteValueBuffer = noteData[selector.index].toBuffer();
+    const noteValue = noteValueBuffer.subarray(selector.offset, selector.offset + selector.length);
+    return Fr.fromBuffer(noteValue);
+};
+const selectNotes = (noteDatas, selects)=>noteDatas.filter((noteData)=>selects.every(({ selector, value, comparator })=>{
+            const noteValueFr = selectPropertyFromPackedNoteContent(noteData.note.items, selector);
+            const comparatorSelector = {
+                [Comparator.EQ]: ()=>noteValueFr.equals(value),
+                [Comparator.NEQ]: ()=>!noteValueFr.equals(value),
+                [Comparator.LT]: ()=>noteValueFr.lt(value),
+                [Comparator.LTE]: ()=>noteValueFr.lt(value) || noteValueFr.equals(value),
+                [Comparator.GT]: ()=>!noteValueFr.lt(value) && !noteValueFr.equals(value),
+                [Comparator.GTE]: ()=>!noteValueFr.lt(value)
+            };
+            return comparatorSelector[comparator]();
+        }));
+const sortNotes = (a, b, sorts, level = 0)=>{
+    if (sorts[level] === undefined) {
+        return 0;
+    }
+    const { selector, order } = sorts[level];
+    if (order === 0) {
+        return 0;
+    }
+    const aValue = selectPropertyFromPackedNoteContent(a, selector);
+    const bValue = selectPropertyFromPackedNoteContent(b, selector);
+    const dir = order === 1 ? [
+        -1,
+        1
+    ] : [
+        1,
+        -1
+    ];
+    return aValue.toBigInt() === bValue.toBigInt() ? sortNotes(a, b, sorts, level + 1) : aValue.toBigInt() > bValue.toBigInt() ? dir[0] : dir[1];
+};
+/**
+ * Pick from a note array a number of notes that meet the criteria.
+ */ export function pickNotes(noteDatas, { selects = [], sorts = [], limit = 0, offset = 0 }) {
+    return selectNotes(noteDatas, selects).sort((a, b)=>sortNotes(a.note.items, b.note.items, sorts)).slice(offset, limit ? offset + limit : undefined);
+}

package/dest/contract_function_simulator/proxied_contract_data_source.d.ts

@@ -0,0 +1,6 @@
+import type { ContractOverrides } from '@aztec/stdlib/tx';
+import type { ContractStore } from '../storage/contract_store/contract_store.js';
+export declare class ProxiedContractStoreFactory {
+    static create(contractStore: ContractStore, overrides?: ContractOverrides): ContractStore;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJveGllZF9jb250cmFjdF9kYXRhX3NvdXJjZS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnRyYWN0X2Z1bmN0aW9uX3NpbXVsYXRvci9wcm94aWVkX2NvbnRyYWN0X2RhdGFfc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sS0FBSyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFFMUQsT0FBTyxLQUFLLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFPakYscUJBQWEsMkJBQTJCO0lBQ3RDLE1BQU0sQ0FBQyxNQUFNLENBQUMsYUFBYSxFQUFFLGFBQWEsRUFBRSxTQUFTLENBQUMsRUFBRSxpQkFBaUIsaUJBcUV4RTtDQUNGIn0=

package/dest/contract_function_simulator/proxied_contract_data_source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxied_contract_data_source.d.ts","sourceRoot":"","sources":["../../src/contract_function_simulator/proxied_contract_data_source.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAOjF,qBAAa,2BAA2B;IACtC,MAAM,CAAC,MAAM,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,iBAAiB,iBAqExE;CACF"}