@aztec/simulator 0.0.0-test.0

package/dest/private/unconstrained_execution_oracle.js

@@ -0,0 +1,258 @@
+import { Aes128 } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { applyStringFormatting, createLogger } from '@aztec/foundation/log';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { siloNullifier } from '@aztec/stdlib/hash';
+import { TypedOracle } from './acvm/index.js';
+import { pickNotes } from './pick_notes.js';
+/**
+ * The oracle for an unconstrained function execution.
+ */ export class UnconstrainedExecutionOracle extends TypedOracle {
+    contractAddress;
+    authWitnesses;
+    capsules;
+    executionDataProvider;
+    log;
+    scopes;
+    constructor(contractAddress, /** List of transient auth witnesses to be used during this simulation */ authWitnesses, capsules, executionDataProvider, log = createLogger('simulator:client_view_context'), scopes){
+        super(), this.contractAddress = contractAddress, this.authWitnesses = authWitnesses, this.capsules = capsules, this.executionDataProvider = executionDataProvider, this.log = log, this.scopes = scopes;
+    }
+    getBlockNumber() {
+        return this.executionDataProvider.getBlockNumber();
+    }
+    getContractAddress() {
+        return Promise.resolve(this.contractAddress);
+    }
+    getChainId() {
+        return Promise.resolve(this.executionDataProvider.getChainId().then((id)=>new Fr(id)));
+    }
+    getVersion() {
+        return Promise.resolve(this.executionDataProvider.getVersion().then((v)=>new Fr(v)));
+    }
+    /**
+   * 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.
+   */ getKeyValidationRequest(pkMHash) {
+        return this.executionDataProvider.getKeyValidationRequest(pkMHash, this.contractAddress);
+    }
+    /**
+   * Fetches the index and sibling path of a leaf at a given block from a given tree.
+   * @param blockNumber - The block number at which to get the membership witness.
+   * @param treeId - Id of the tree to get the sibling path from.
+   * @param leafValue - The leaf value
+   * @returns The index and sibling path concatenated [index, sibling_path]
+   */ getMembershipWitness(blockNumber, treeId, leafValue) {
+        return this.executionDataProvider.getMembershipWitness(blockNumber, treeId, leafValue);
+    }
+    /**
+   * Returns a nullifier membership witness for a given nullifier at a given block.
+   * @param blockNumber - The block number at which to get the index.
+   * @param nullifier - Nullifier we try to find witness for.
+   * @returns The nullifier membership witness (if found).
+   */ async getNullifierMembershipWitness(blockNumber, nullifier) {
+        return await this.executionDataProvider.getNullifierMembershipWitness(blockNumber, nullifier);
+    }
+    /**
+   * Returns a low nullifier membership witness for a given nullifier at a given block.
+   * @param blockNumber - The block number 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.
+   */ async getLowNullifierMembershipWitness(blockNumber, nullifier) {
+        return await this.executionDataProvider.getLowNullifierMembershipWitness(blockNumber, nullifier);
+    }
+    /**
+   * Returns a public data tree witness for a given leaf slot at a given block.
+   * @param blockNumber - The block number at which to get the index.
+   * @param leafSlot - The slot of the public data tree to get the witness for.
+   * @returns - The witness
+   */ async getPublicDataTreeWitness(blockNumber, leafSlot) {
+        return await this.executionDataProvider.getPublicDataTreeWitness(blockNumber, 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 block = await this.executionDataProvider.getBlock(blockNumber);
+        if (!block) {
+            return undefined;
+        }
+        return block.header;
+    }
+    /**
+   * Retrieve the complete address associated to a given address.
+   * @param account - The account address.
+   * @returns A complete address associated with the input address.
+   * @throws An error if the account is not registered in the database.
+   */ getCompleteAddress(account) {
+        return this.executionDataProvider.getCompleteAddress(account);
+    }
+    /**
+   * Returns a contract instance associated with an address or throws if not found.
+   * @param address - Address.
+   * @returns A contract instance.
+   */ getContractInstance(address) {
+        return this.executionDataProvider.getContractInstance(address);
+    }
+    /**
+   * 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 ?? this.executionDataProvider.getAuthWitness(messageHash));
+    }
+    /**
+   * 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 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(storageSlot, numSelects, selectByIndexes, selectByOffsets, selectByLengths, selectValues, selectComparators, sortByIndexes, sortByOffsets, sortByLengths, sortOrder, limit, offset, status) {
+        const dbNotes = await this.executionDataProvider.getNotes(this.contractAddress, 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 = await siloNullifier(this.contractAddress, innerNullifier);
+        const index = await this.executionDataProvider.getNullifierIndex(nullifier);
+        return index !== undefined;
+    }
+    /**
+   * Fetches a message from the executionDataProvider, 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) {
+        return await this.executionDataProvider.getL1ToL2MembershipWitness(contractAddress, messageHash, secret);
+    }
+    /**
+   * Read the public storage data.
+   * @param contractAddress - The address to read storage from.
+   * @param startStorageSlot - The starting storage slot.
+   * @param blockNumber - The block number to read storage at.
+   * @param numberOfElements - Number of elements to read from the starting storage slot.
+   */ async storageRead(contractAddress, startStorageSlot, blockNumber, numberOfElements) {
+        const values = [];
+        for(let i = 0n; i < numberOfElements; i++){
+            const storageSlot = new Fr(startStorageSlot.value + i);
+            const value = await this.executionDataProvider.getPublicStorageAt(blockNumber, contractAddress, storageSlot);
+            this.log.debug(`Oracle storage read: slot=${storageSlot.toString()} address-${contractAddress.toString()} value=${value}`);
+            values.push(value);
+        }
+        return values;
+    }
+    debugLog(message, fields) {
+        // TODO(#10558) Remove this check once the debug log is fixed
+        if (message.startsWith('Context.note_hashes, after pushing new note hash:')) {
+            return;
+        }
+        this.log.verbose(`${applyStringFormatting(message, fields)}`, {
+            module: `${this.log.module}:debug_log`
+        });
+    }
+    /**
+   * Returns the tagging secret for a given sender and recipient pair, siloed to the current contract address.
+   * Includes the next index to be used used for tagging with this secret.
+   * For this to work, the ivsk_m of the sender must be known.
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A tagging secret that can be used to tag notes.
+   */ async getIndexedTaggingSecretAsSender(sender, recipient) {
+        return await this.executionDataProvider.getIndexedTaggingSecretAsSender(this.contractAddress, sender, recipient);
+    }
+    async syncNotes() {
+        const taggedLogsByRecipient = await this.executionDataProvider.syncTaggedLogs(this.contractAddress, await this.executionDataProvider.getBlockNumber(), this.scopes);
+        for (const [recipient, taggedLogs] of taggedLogsByRecipient.entries()){
+            await this.executionDataProvider.processTaggedLogs(taggedLogs, AztecAddress.fromString(recipient));
+        }
+        await this.executionDataProvider.removeNullifiedNotes(this.contractAddress);
+    }
+    async deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient) {
+        // TODO(#10727): allow other contracts to deliver notes
+        if (!this.contractAddress.equals(contractAddress)) {
+            throw new Error(`Got a note delivery request from ${contractAddress}, expected ${this.contractAddress}`);
+        }
+        await this.executionDataProvider.deliverNote(contractAddress, storageSlot, nonce, content, noteHash, nullifier, txHash, recipient);
+    }
+    getLogByTag(tag) {
+        return this.executionDataProvider.getLogByTag(tag);
+    }
+    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`);
+        }
+        return this.executionDataProvider.storeCapsule(this.contractAddress, slot, capsule);
+    }
+    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 this.capsules.find((c)=>c.contractAddress.equals(contractAddress) && c.storageSlot.equals(slot))?.data ?? await this.executionDataProvider.loadCapsule(this.contractAddress, slot);
+    }
+    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`);
+        }
+        return this.executionDataProvider.deleteCapsule(this.contractAddress, slot);
+    }
+    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.executionDataProvider.copyCapsule(this.contractAddress, srcSlot, dstSlot, numEntries);
+    }
+    // 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);
+    }
+}

package/dest/public/avm/avm_context.d.ts

@@ -0,0 +1,41 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AvmExecutionEnvironment } from './avm_execution_environment.js';
+import { type Gas } from './avm_gas.js';
+import { AvmMachineState } from './avm_machine_state.js';
+import type { AvmSimulator } from './avm_simulator.js';
+import type { AvmPersistableStateManager } from './journal/journal.js';
+/**
+ * An execution context includes the information necessary to initiate AVM
+ * execution along with all state maintained by the AVM throughout execution.
+ */
+export declare class AvmContext {
+    persistableState: AvmPersistableStateManager;
+    environment: AvmExecutionEnvironment;
+    machineState: AvmMachineState;
+    /**
+     * Create a new AVM context
+     * @param persistableState - Manages world state and accrued substate during execution - (caching, fetching, tracing)
+     * @param environment - Contains constant variables provided by the kernel
+     * @param machineState - VM state that is modified on an instruction-by-instruction basis
+     * @returns new AvmContext instance
+     */
+    constructor(persistableState: AvmPersistableStateManager, environment: AvmExecutionEnvironment, machineState: AvmMachineState);
+    provideSimulator?: (ctx: this) => Promise<AvmSimulator>;
+    /**
+     * Prepare a new AVM context that will be ready for an external/nested call
+     * - Fork the world state journal
+     * - Derive a machine state from the current state
+     *   - E.g., gas metering is preserved but pc is reset
+     * - Derive an execution environment from the caller/parent
+     *   - Alter address
+     *
+     * @param address - The contract instance to initialize a context for
+     * @param calldata - Data/arguments for nested call
+     * @param allocatedGas - Gas allocated for the nested call
+     * @param callType - Type of call (CALL or STATICCALL)
+     * @returns new AvmContext instance
+     */
+    createNestedContractCallContext(address: AztecAddress, calldata: Fr[], allocatedGas: Gas, callType: 'CALL' | 'STATICCALL'): Promise<AvmContext>;
+}
+//# sourceMappingURL=avm_context.d.ts.map

package/dest/public/avm/avm_context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_context.d.ts","sourceRoot":"","sources":["../../../src/public/avm/avm_context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,KAAK,GAAG,EAAgB,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAEvE;;;GAGG;AACH,qBAAa,UAAU;IASZ,gBAAgB,EAAE,0BAA0B;IAC5C,WAAW,EAAE,uBAAuB;IACpC,YAAY,EAAE,eAAe;IAVtC;;;;;;OAMG;gBAEM,gBAAgB,EAAE,0BAA0B,EAC5C,WAAW,EAAE,uBAAuB,EACpC,YAAY,EAAE,eAAe;IAK/B,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;IAE/D;;;;;;;;;;;;;OAaG;IACU,+BAA+B,CAC1C,OAAO,EAAE,YAAY,EACrB,QAAQ,EAAE,EAAE,EAAE,EACd,YAAY,EAAE,GAAG,EACjB,QAAQ,EAAE,MAAM,GAAG,YAAY,GAC9B,OAAO,CAAC,UAAU,CAAC;CAUvB"}

package/dest/public/avm/avm_context.js

@@ -0,0 +1,44 @@
+import { gasToGasLeft } from './avm_gas.js';
+import { AvmMachineState } from './avm_machine_state.js';
+/**
+ * An execution context includes the information necessary to initiate AVM
+ * execution along with all state maintained by the AVM throughout execution.
+ */ export class AvmContext {
+    persistableState;
+    environment;
+    machineState;
+    /**
+   * Create a new AVM context
+   * @param persistableState - Manages world state and accrued substate during execution - (caching, fetching, tracing)
+   * @param environment - Contains constant variables provided by the kernel
+   * @param machineState - VM state that is modified on an instruction-by-instruction basis
+   * @returns new AvmContext instance
+   */ constructor(persistableState, environment, machineState){
+        this.persistableState = persistableState;
+        this.environment = environment;
+        this.machineState = machineState;
+    }
+    // This is needed to break a dependency cycle created by the CALL opcode,
+    // which needs to create a new simulator but cannot depend directly on AvmSimulator.
+    provideSimulator;
+    /**
+   * Prepare a new AVM context that will be ready for an external/nested call
+   * - Fork the world state journal
+   * - Derive a machine state from the current state
+   *   - E.g., gas metering is preserved but pc is reset
+   * - Derive an execution environment from the caller/parent
+   *   - Alter address
+   *
+   * @param address - The contract instance to initialize a context for
+   * @param calldata - Data/arguments for nested call
+   * @param allocatedGas - Gas allocated for the nested call
+   * @param callType - Type of call (CALL or STATICCALL)
+   * @returns new AvmContext instance
+   */ async createNestedContractCallContext(address, calldata, allocatedGas, callType) {
+        const deriveFn = callType === 'CALL' ? this.environment.deriveEnvironmentForNestedCall : this.environment.deriveEnvironmentForNestedStaticCall;
+        const newExecutionEnvironment = deriveFn.call(this.environment, address, calldata);
+        const forkedWorldState = await this.persistableState.fork();
+        const machineState = AvmMachineState.fromState(gasToGasLeft(allocatedGas));
+        return new AvmContext(forkedWorldState, newExecutionEnvironment, machineState);
+    }
+}

package/dest/public/avm/avm_contract_call_result.d.ts

@@ -0,0 +1,30 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { SimulationError } from '@aztec/stdlib/errors';
+import { Gas } from '@aztec/stdlib/gas';
+import type { Gas as AvmGas } from './avm_gas.js';
+import type { AvmRevertReason } from './errors.js';
+/**
+ * Results of an contract call's execution in the AVM.
+ */
+export declare class AvmContractCallResult {
+    reverted: boolean;
+    output: Fr[];
+    gasLeft: AvmGas;
+    revertReason?: AvmRevertReason | undefined;
+    constructor(reverted: boolean, output: Fr[], gasLeft: AvmGas, revertReason?: AvmRevertReason | undefined);
+    toString(): string;
+    finalize(): AvmFinalizedCallResult;
+}
+/**
+ * Similar to AvmContractCallResult, but with a SimulationError and standard Gas
+ * which are useful for consumption external to core AVM simulation.
+ */
+export declare class AvmFinalizedCallResult {
+    reverted: boolean;
+    output: Fr[];
+    gasLeft: Gas;
+    revertReason?: SimulationError | undefined;
+    constructor(reverted: boolean, output: Fr[], gasLeft: Gas, revertReason?: SimulationError | undefined);
+    toString(): string;
+}
+//# sourceMappingURL=avm_contract_call_result.d.ts.map

package/dest/public/avm/avm_contract_call_result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_contract_call_result.d.ts","sourceRoot":"","sources":["../../../src/public/avm/avm_contract_call_result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AAKxC,OAAO,KAAK,EAAE,GAAG,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;GAEG;AACH,qBAAa,qBAAqB;IAEvB,QAAQ,EAAE,OAAO;IACjB,MAAM,EAAE,EAAE,EAAE;IACZ,OAAO,EAAE,MAAM;IACf,YAAY,CAAC;gBAHb,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,EAAE,EAAE,EACZ,OAAO,EAAE,MAAM,EACf,YAAY,CAAC,6BAAiB;IAGvC,QAAQ,IAAI,MAAM;IAQlB,QAAQ,IAAI,sBAAsB;CAInC;AAED;;;GAGG;AACH,qBAAa,sBAAsB;IAExB,QAAQ,EAAE,OAAO;IACjB,MAAM,EAAE,EAAE,EAAE;IACZ,OAAO,EAAE,GAAG;IACZ,YAAY,CAAC;gBAHb,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,EAAE,EAAE,EACZ,OAAO,EAAE,GAAG,EACZ,YAAY,CAAC,6BAAiB;IAGvC,QAAQ,IAAI,MAAM;CAOnB"}

package/dest/public/avm/avm_contract_call_result.js

@@ -0,0 +1,50 @@
+import { Gas } from '@aztec/stdlib/gas';
+import { inspect } from 'util';
+import { createSimulationError } from '../../common/errors.js';
+/**
+ * Results of an contract call's execution in the AVM.
+ */ export class AvmContractCallResult {
+    reverted;
+    output;
+    gasLeft;
+    revertReason;
+    constructor(reverted, output, gasLeft, revertReason){
+        this.reverted = reverted;
+        this.output = output;
+        this.gasLeft = gasLeft;
+        this.revertReason = revertReason;
+    }
+    toString() {
+        let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+        if (this.revertReason) {
+            resultsStr += `, revertReason: ${this.revertReason}`;
+        }
+        return resultsStr;
+    }
+    finalize() {
+        const revertReason = this.revertReason ? createSimulationError(this.revertReason, this.output) : undefined;
+        return new AvmFinalizedCallResult(this.reverted, this.output, Gas.from(this.gasLeft), revertReason);
+    }
+}
+/**
+ * Similar to AvmContractCallResult, but with a SimulationError and standard Gas
+ * which are useful for consumption external to core AVM simulation.
+ */ export class AvmFinalizedCallResult {
+    reverted;
+    output;
+    gasLeft;
+    revertReason;
+    constructor(reverted, output, gasLeft, revertReason){
+        this.reverted = reverted;
+        this.output = output;
+        this.gasLeft = gasLeft;
+        this.revertReason = revertReason;
+    }
+    toString() {
+        let resultsStr = `reverted: ${this.reverted}, output: ${this.output}, gasLeft: ${inspect(this.gasLeft)}`;
+        if (this.revertReason) {
+            resultsStr += `, revertReason: ${this.revertReason}`;
+        }
+        return resultsStr;
+    }
+}

package/dest/public/avm/avm_execution_environment.d.ts

@@ -0,0 +1,21 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GlobalVariables } from '@aztec/stdlib/tx';
+/**
+ * Contains variables that remain constant during AVM execution
+ * These variables are provided by the public kernel circuit
+ */
+export declare class AvmExecutionEnvironment {
+    readonly address: AztecAddress;
+    readonly sender: AztecAddress;
+    readonly contractCallDepth: Fr;
+    readonly transactionFee: Fr;
+    readonly globals: GlobalVariables;
+    readonly isStaticCall: boolean;
+    readonly calldata: Fr[];
+    constructor(address: AztecAddress, sender: AztecAddress, contractCallDepth: Fr, transactionFee: Fr, globals: GlobalVariables, isStaticCall: boolean, calldata: Fr[]);
+    private deriveEnvironmentForNestedCallInternal;
+    deriveEnvironmentForNestedCall(targetAddress: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment;
+    deriveEnvironmentForNestedStaticCall(targetAddress: AztecAddress, calldata: Fr[]): AvmExecutionEnvironment;
+}
+//# sourceMappingURL=avm_execution_environment.d.ts.map

package/dest/public/avm/avm_execution_environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_execution_environment.d.ts","sourceRoot":"","sources":["../../../src/public/avm/avm_execution_environment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD;;;GAGG;AACH,qBAAa,uBAAuB;aAEhB,OAAO,EAAE,YAAY;aACrB,MAAM,EAAE,YAAY;aACpB,iBAAiB,EAAE,EAAE;aACrB,cAAc,EAAE,EAAE;aAClB,OAAO,EAAE,eAAe;aACxB,YAAY,EAAE,OAAO;aACrB,QAAQ,EAAE,EAAE,EAAE;gBANd,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,YAAY,EACpB,iBAAiB,EAAE,EAAE,EACrB,cAAc,EAAE,EAAE,EAClB,OAAO,EAAE,eAAe,EACxB,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,EAAE,EAAE;IAGhC,OAAO,CAAC,sCAAsC;IAYvC,8BAA8B,CAAC,aAAa,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,uBAAuB;IAIpG,oCAAoC,CAAC,aAAa,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,EAAE,GAAG,uBAAuB;CAGlH"}

package/dest/public/avm/avm_execution_environment.js

@@ -0,0 +1,31 @@
+import { Fr } from '@aztec/foundation/fields';
+/**
+ * Contains variables that remain constant during AVM execution
+ * These variables are provided by the public kernel circuit
+ */ export class AvmExecutionEnvironment {
+    address;
+    sender;
+    contractCallDepth;
+    transactionFee;
+    globals;
+    isStaticCall;
+    calldata;
+    constructor(address, sender, contractCallDepth, transactionFee, globals, isStaticCall, calldata){
+        this.address = address;
+        this.sender = sender;
+        this.contractCallDepth = contractCallDepth;
+        this.transactionFee = transactionFee;
+        this.globals = globals;
+        this.isStaticCall = isStaticCall;
+        this.calldata = calldata;
+    }
+    deriveEnvironmentForNestedCallInternal(targetAddress, calldata, isStaticCall) {
+        return new AvmExecutionEnvironment(/*address=*/ targetAddress, /*sender=*/ this.address, this.contractCallDepth.add(Fr.ONE), this.transactionFee, this.globals, isStaticCall, calldata);
+    }
+    deriveEnvironmentForNestedCall(targetAddress, calldata) {
+        return this.deriveEnvironmentForNestedCallInternal(targetAddress, calldata, /*isStaticCall=*/ false);
+    }
+    deriveEnvironmentForNestedStaticCall(targetAddress, calldata) {
+        return this.deriveEnvironmentForNestedCallInternal(targetAddress, calldata, /*isStaticCall=*/ true);
+    }
+}

package/dest/public/avm/avm_gas.d.ts

@@ -0,0 +1,60 @@
+import { TypeTag } from './avm_memory_types.js';
+import { Opcode } from './serialization/instruction_serialization.js';
+/** Gas counters in L1, L2, and DA. */
+export type Gas = {
+    l2Gas: number;
+    daGas: number;
+};
+/** Maps a Gas struct to gasLeft properties. */
+export declare function gasToGasLeft(gas: Gas): {
+    l2GasLeft: number;
+    daGasLeft: number;
+};
+/** Maps gasLeft properties to a gas struct. */
+export declare function gasLeftToGas(gasLeft: {
+    l2GasLeft: number;
+    daGasLeft: number;
+}): {
+    l2Gas: number;
+    daGas: number;
+};
+/** Creates a new instance with all values set to zero except the ones set. */
+export declare function makeGas(gasCost: Partial<Gas>): {
+    l2Gas: number;
+    daGas: number;
+};
+/** Sums together multiple instances of Gas. */
+export declare function sumGas(...gases: Partial<Gas>[]): Gas;
+/** Multiplies a gas instance by a scalar. */
+export declare function mulGas(gas: Partial<Gas>, scalar: number): {
+    l2Gas: number;
+    daGas: number;
+};
+/** Zero gas across all gas dimensions. */
+export declare const EmptyGas: Gas;
+/** Dimensions of gas usage: L1, L2, and DA. */
+export declare const GAS_DIMENSIONS: readonly ["l2Gas", "daGas"];
+/** Returns the fixed base gas cost for a given opcode. */
+export declare function getBaseGasCost(opcode: Opcode): Gas;
+export declare function getDynamicGasCost(opcode: Opcode): Gas;
+/** Returns the gas cost associated with the memory operations performed. */
+export declare function getMemoryGasCost(args: {
+    reads?: number;
+    writes?: number;
+    indirect?: number;
+}): {
+    l2Gas: number;
+    daGas: number;
+};
+/** Constants used in base cost calculations. */
+export declare const GAS_COST_CONSTANTS: {
+    MEMORY_READ: number;
+    MEMORY_INDIRECT_READ_PENALTY: number;
+    MEMORY_WRITE: number;
+};
+/** Returns gas cost for an operation on a given type tag based on the base cost per byte. */
+export declare function getGasCostForTypeTag(tag: TypeTag, baseCost: Gas): {
+    l2Gas: number;
+    daGas: number;
+};
+//# sourceMappingURL=avm_gas.d.ts.map

package/dest/public/avm/avm_gas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avm_gas.d.ts","sourceRoot":"","sources":["../../../src/public/avm/avm_gas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGhD,OAAO,EAAE,MAAM,EAAE,MAAM,8CAA8C,CAAC;AAEtE,sCAAsC;AACtC,MAAM,MAAM,GAAG,GAAG;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG;;;EAEpC;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE;;;EAE7E;AAED,8EAA8E;AAC9E,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC;;;EAE5C;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,GAAG,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAQ9C;AAED,6CAA6C;AAC7C,wBAAgB,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,MAAM;;;EAEvD;AAED,0CAA0C;AAC1C,eAAO,MAAM,QAAQ,EAAE,GAGtB,CAAC;AAMF,+CAA+C;AAC/C,eAAO,MAAM,cAAc,6BAA8B,CAAC;AAuF1D,0DAA0D;AAC1D,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAElD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAErD;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE;;;EAQ5F;AAED,gDAAgD;AAChD,eAAO,MAAM,kBAAkB;;;;CAI9B,CAAC;AAEF,6FAA6F;AAC7F,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG;;;EAE/D"}