feat: calls to non-existent contracts in the AVM simulator return failure

yarn-project/simulator/src/avm/avm_simulator.test.ts

@@ -188,6 +188,27 @@ describe('AVM simulator: transpiled Noir contracts', () => {
 
     expect(results.reverted).toBe(false);
   });
+
+  it('execution of a non-existent contract immediately reverts', async () => {
+    const context = initContext();
+    const startGas = { l2Gas: context.machineState.l2GasLeft, daGas: context.machineState.daGasLeft };
+    const results = await new AvmSimulator(context).execute();
+
+    expect(results.reverted).toBe(true);
+    expect(results.output).toEqual([]);
+    expect(results.gasLeft).toEqual(startGas);
+  });
+
+  it('execution of a non-existent contract immediately reverts', async () => {
+    const context = initContext();
+    const startGas = { l2Gas: context.machineState.l2GasLeft, daGas: context.machineState.daGasLeft };
+    const results = await new AvmSimulator(context).execute();
+
+    expect(results.reverted).toBe(true);
+    expect(results.output).toEqual([]);
+    expect(results.gasLeft).toEqual(startGas);
+  });
+
   it('addition', async () => {
     const calldata: Fr[] = [new Fr(1), new Fr(2)];
     const context = initContext({ env: initExecutionEnvironment({ calldata }) });
@@ -891,6 +912,7 @@ describe('AVM simulator: transpiled Noir contracts', () => {
         environment: AvmExecutionEnvironment,
         nestedTrace: PublicSideEffectTraceInterface,
         isStaticCall: boolean = false,
+        exists: boolean = true,
       ) => {
         expect(trace.traceNestedCall).toHaveBeenCalledTimes(1);
         expect(trace.traceNestedCall).toHaveBeenCalledWith(
@@ -900,17 +922,32 @@ describe('AVM simulator: transpiled Noir contracts', () => {
             contractCallDepth: new Fr(1), // top call is depth 0, nested is depth 1
             globals: environment.globals, // just confirming that nested env looks roughly right
             isStaticCall: isStaticCall,
-            // TODO(7121): can't check calldata like this since it is modified on environment construction
-            // with AvmContextInputs. These should eventually go away.
-            //calldata: expect.arrayContaining(environment.calldata), // top-level call forwards args
+            // top-level calls forward args in these tests,
+            // but nested calls in these tests use public_dispatch, so selector is inserted as first arg
+            calldata: expect.arrayContaining([/*selector=*/ expect.anything(), ...environment.calldata]),
           }),
           /*startGasLeft=*/ expect.anything(),
-          /*bytecode=*/ expect.anything(),
+          /*bytecode=*/ exists ? expect.anything() : undefined,
           /*avmCallResults=*/ expect.anything(), // we don't have the NESTED call's results to check
           /*functionName=*/ expect.anything(),
         );
       };
 
+      it(`Nested call to non-existent contract `, async () => {
+        const calldata = [value0, value1];
+        const context = createContext(calldata);
+        const callBytecode = getAvmTestContractBytecode('nested_call_to_add');
+
+        const nestedTrace = mock<PublicSideEffectTraceInterface>();
+        mockTraceFork(trace, nestedTrace);
+
+        const results = await new AvmSimulator(context).executeBytecode(callBytecode);
+        expect(results.reverted).toBe(true);
+        expect(results.output).toEqual([]);
+
+        expectTracedNestedCall(context.environment, nestedTrace, /*isStaticCall=*/ false, /*exists=*/ false);
+      });
+
       it(`Nested call`, async () => {
         const calldata = [value0, value1];
         const context = createContext(calldata);

yarn-project/simulator/src/avm/avm_simulator.ts

@@ -18,8 +18,8 @@ import { AvmMachineState } from './avm_machine_state.js';
 import { isAvmBytecode } from './bytecode_utils.js';
 import {
   AvmExecutionError,
+  AvmRevertReason,
   InvalidProgramCounterError,
-  NoBytecodeForContractError,
   revertReasonFromExceptionalHalt,
   revertReasonFromExplicitRevert,
 } from './errors.js';
@@ -83,10 +83,24 @@ export class AvmSimulator {
   public async execute(): Promise<AvmContractCallResult> {
     const bytecode = await this.context.persistableState.getBytecode(this.context.environment.address);
 
-    // This assumes that we will not be able to send messages to accounts without code
-    // Pending classes and instances impl details
     if (!bytecode) {
-      throw new NoBytecodeForContractError(this.context.environment.address);
+      // revert without consuming any gas
+      const message = `No bytecode found at: ${this.context.environment.address}. Reverting...`;
+      const revertReason = new AvmRevertReason(
+        message,
+        /*failingFunction=*/ {
+          contractAddress: this.context.environment.address,
+          functionSelector: this.context.environment.functionSelector,
+        },
+        /*noirCallStack=*/ [],
+      );
+      this.log.warn(message);
+      return new AvmContractCallResult(
+        /*reverted=*/ true,
+        /*output=*/ [],
+        /*gasLeft=*/ this.context.machineState.gasLeft,
+        revertReason,
+      );
     }
 
     return await this.executeBytecode(bytecode);

yarn-project/simulator/src/avm/opcodes/external_calls.test.ts

@@ -58,6 +58,42 @@ describe('External Calls', () => {
       expect(inst.serialize()).toEqual(buf);
     });
 
+    it('Call to non-existent bytecode returns failure', async () => {
+      const gasOffset = 0;
+      const l2Gas = 2e6;
+      const daGas = 3e6;
+      const addrOffset = 2;
+      const addr = new Fr(123456n);
+      const argsOffset = 3;
+      const args = [new Field(1), new Field(2), new Field(3)];
+      const argsSize = args.length;
+      const argsSizeOffset = 20;
+      const successOffset = 6;
+
+      const { l2GasLeft: initialL2Gas, daGasLeft: initialDaGas } = context.machineState;
+
+      context.machineState.memory.set(0, new Field(l2Gas));
+      context.machineState.memory.set(1, new Field(daGas));
+      context.machineState.memory.set(2, new Field(addr));
+      context.machineState.memory.set(argsSizeOffset, new Uint32(argsSize));
+      context.machineState.memory.setSlice(3, args);
+
+      const instruction = new Call(/*indirect=*/ 0, gasOffset, addrOffset, argsOffset, argsSizeOffset, successOffset);
+      await instruction.execute(context);
+
+      const successValue = context.machineState.memory.get(successOffset);
+      expect(successValue).toEqual(new Uint1(0n)); // failure, contract non-existent!
+
+      const retValue = context.machineState.nestedReturndata;
+      expect(retValue).toEqual([]);
+
+      // should only charge gas for the call instruction itself
+      // (all gas allocated to the nested call should be refunded)
+      const callGasCost = instruction.gasCost(argsSize);
+      expect(context.machineState.l2GasLeft).toEqual(initialL2Gas - callGasCost.l2Gas);
+      expect(context.machineState.daGasLeft).toEqual(initialDaGas - callGasCost.daGas);
+    });
+
     it('Should execute a call correctly', async () => {
       const gasOffset = 0;
       const l2Gas = 2e6;

yarn-project/simulator/src/avm/opcodes/instruction.ts

@@ -94,7 +94,7 @@ export abstract class Instruction {
    * Computes gas cost for the instruction based on its base cost and memory operations.
    * @returns Gas cost.
    */
-  protected gasCost(dynMultiplier: number = 0): Gas {
+  public gasCost(dynMultiplier: number = 0): Gas {
     const baseGasCost = getBaseGasCost(this.opcode);
     const dynGasCost = mulGas(getDynamicGasCost(this.opcode), dynMultiplier);
     return sumGas(baseGasCost, dynGasCost);