anchor.diff:      99    = ?call(call_contract,   Acc1, RemC, call, word, {IdC, 99}),
       RemC2 = ?call(create_contract, Acc1, remote_call, {}, #{amount => 100}),
       77    = ?call(call_contract,   Acc1, RemC2, staged_call, word, {IdC, RemC, 77}),
  +    ok.
  +
  +sophia_vm_interaction(Cfg) ->
  +    state(aect_test_utils:new_state()),
  +    ForkHeight    = ?config(fork_height, Cfg),
  +    RomaHeight    = ForkHeight - 1,
  +    MinervaHeight = ForkHeight + 1,
  +    Acc           = ?call(new_account, 10000000),
  +    RomaSpec      = #{height => RomaHeight, vm_version => ?VM_AEVM_SOPHIA_1,
  +                      amount => 100},
  +    MinervaSpec   = #{height => MinervaHeight, vm_version => ?VM_AEVM_SOPHIA_2,
  +                      amount => 100},
  +    {ok, IdCode}  = compile_contract_vsn(identity, ?AESOPHIA_1),
  +    {ok, RemCode} = compile_contract_vsn(remote_call, ?AESOPHIA_1),
  +
  +    %% Create contracts on both side of the fork
  +    IdCRoma     = ?call(create_contract_with_code, Acc, IdCode, {}, RomaSpec),
  +    RemCRoma    = ?call(create_contract_with_code, Acc, RemCode, {}, RomaSpec),
  +    IdCMinerva  = ?call(create_contract_with_code, Acc, IdCode, {}, MinervaSpec),
  +    RemCMinerva = ?call(create_contract_with_code, Acc, RemCode, {}, MinervaSpec),
  +
  +    %% Check that we cannot create contracts with vm1 after the fork
  +    BadSpec    = RomaSpec#{height => MinervaHeight},
  +    {error, illegal_vm_version} = ?call(fail_create_contract_with_code, Acc, IdCode, {}, BadSpec),
  +
  +    MinervaCallSpec = #{height => MinervaHeight},
  +
  +    %% Call directly VM1
  +    42 = ?call(call_contract, Acc, IdCRoma,    main, word, 42, MinervaCallSpec),
  +    43 = ?call(call_contract, Acc, IdCMinerva, main, word, 43, MinervaCallSpec),
  +
  +    %% Call VM1 -> VM1 and VM2 -> VM1
  +    98 = ?call(call_contract, Acc, RemCRoma, call, word, {IdCRoma, 98},
  +               MinervaCallSpec),
  +    99 = ?call(call_contract, Acc, RemCMinerva, call, word, {IdCRoma, 99},
  +               MinervaCallSpec),
  +
  +    %% Call VM2 -> VM1 -> VM1
  +    77 = ?call(call_contract, Acc, RemCMinerva, staged_call, word,
  +               {IdCRoma, RemCRoma, 77}, MinervaCallSpec),
  +
  +    %% Fail calling VM1 -> VM2
  +    {error, _} = ?call(call_contract, Acc, RemCRoma, call, word,
  +                       {IdCMinerva, 98}, MinervaCallSpec),
  +
  +    %% Fail calling VM2 -> VM1 -> VM2
  +    {error, _} = ?call(call_contract, Acc, RemCMinerva, staged_call, word,
  +                       {IdCRoma, RemCMinerva, 77}, MinervaCallSpec),
       ok.
   
   sophia_exploits(_Cfg) ->
  
positive.code: create_tx(Owner, Spec0, State) ->
      Spec = maps:merge(
          #{ abi_version => aect_test_utils:latest_sophia_abi_version()
           , vm_version  => vm_version()
           , fee         => 1000000
           , deposit     => 10
           , amount      => 200
  
negative.code: groups() ->
      [ {aevm_1, [sequence], ?ALL_TESTS}
      , {aevm_2, [sequence], ?ALL_TESTS}
      , {vm_interaction, [], [sophia_vm_interaction
                              ]}
      , {transactions, [], [ create_contract
                           , create_contract_init_error
                           , create_contract_init_error_the_invalid_instruction
  