fuel-vm 0.66.3

FuelVM interpreter.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

use alloc::{
    vec,
    vec::Vec,
};

use fuel_asm::{
    RegId,
    op,
};
use fuel_tx::{
    ConsensusParameters,
    Finalizable,
    GasCosts,
    Script,
    TransactionBuilder,
    field::ReceiptsRoot,
};

use crate::{
    prelude::{
        Interpreter,
        IntoChecked,
    },
    state::ProgramState,
};

#[test]
fn receipts_are_produced_correctly_with_stepping() {
    let script = vec![
        op::movi(0x20, 1234),
        op::log(0x20, RegId::ZERO, RegId::ZERO, RegId::ZERO),
        op::ret(RegId::ONE),
    ]
    .into_iter()
    .collect();

    let params = ConsensusParameters::standard();
    let tx = TransactionBuilder::script(script, Vec::new())
        .script_gas_limit(1_000_000)
        .maturity(Default::default())
        .add_fee_input()
        .finalize()
        .into_checked(Default::default(), &params)
        .expect("failed to check tx")
        .into_ready(0, &GasCosts::default(), params.fee_params(), None)
        .expect("failed to ready tx");

    let mut vm = Interpreter::<_, _, Script>::with_memory_storage();
    vm.transact(tx.clone()).expect("panicked");
    let receipts_without_debugger = vm.receipts().to_vec();
    let receipts_root_without_debugger = vm.transaction().receipts_root();

    let mut vm = Interpreter::<_, _, Script>::with_memory_storage();
    vm.set_single_stepping(true);
    let mut t = *vm.transact(tx).expect("panicked").state();
    loop {
        match t {
            ProgramState::Return(_)
            | ProgramState::ReturnData(_)
            | ProgramState::Revert(_) => {
                break;
            }
            ProgramState::RunProgram(_) => {
                t = vm.resume().expect("panicked");
            }
            ProgramState::VerifyPredicate(_) => {
                unreachable!("no predicates in this test")
            }
        }
    }
    let receipts_with_debugger = vm.receipts();
    let receipts_root_with_debugger = vm.transaction().receipts_root();

    assert_eq!(receipts_without_debugger, receipts_with_debugger);
    assert_eq!(receipts_root_without_debugger, receipts_root_with_debugger);
}