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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use fuel_asm::{
    RegId,
    Word,
};
use fuel_tx::PanicReason;
use fuel_types::BlobId;

use crate::{
    error::IoResult,
    interpreter::{
        contract::blob_size,
        memory::copy_from_storage_zero_fill,
    },
    storage::{
        BlobData,
        InterpreterStorage,
    },
};

use super::{
    GetRegMut,
    Interpreter,
    Memory,
    SystemRegisters,
    WriteRegKey,
    internal::inc_pc,
    split_registers,
};

impl<M, S, Tx, Ecal, V> Interpreter<M, S, Tx, Ecal, V>
where
    M: Memory,
    S: InterpreterStorage,
    <S as InterpreterStorage>::DataError: From<S::DataError>,
{
    pub(crate) fn blob_size(
        &mut self,
        dst: RegId,
        blob_id_ptr: Word,
    ) -> IoResult<(), S::DataError> {
        let gas_cost = self
            .interpreter_params
            .gas_costs
            .bsiz()
            .map_err(PanicReason::from)?;
        self.gas_charge(gas_cost.base())?;

        let blob_id = BlobId::from(self.memory.as_ref().read_bytes(blob_id_ptr)?);

        let size = blob_size(&self.storage, &blob_id)?;

        self.dependent_gas_charge_without_base(gas_cost, size as Word)?;
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(dst)?];
        *result = size as Word;
        inc_pc(pc);
        Ok(())
    }

    pub(crate) fn blob_load_data(
        &mut self,
        dst_ptr: Word,
        blob_id_ptr: Word,
        blob_offset: Word,
        len: Word,
    ) -> IoResult<(), S::DataError> {
        let gas_cost = self
            .interpreter_params
            .gas_costs
            .bldd()
            .map_err(PanicReason::from)?;
        self.gas_charge(gas_cost.base())?;

        let blob_id = BlobId::from(self.memory.as_ref().read_bytes(blob_id_ptr)?);
        let owner = self.ownership_registers();

        let blob_len = blob_size(&self.storage, &blob_id)?;
        let charge_len = len.max(blob_len as Word);
        self.dependent_gas_charge_without_base(gas_cost, charge_len)?;

        copy_from_storage_zero_fill::<BlobData, _>(
            self.memory.as_mut(),
            owner,
            &self.storage,
            dst_ptr,
            len,
            &blob_id,
            blob_offset,
            blob_len,
            PanicReason::BlobNotFound,
        )?;

        inc_pc(self.registers.pc_mut());
        Ok(())
    }
}