/home/marten/fuel/fuel-vm/fuel-asm/src/op.rs

Source
//! Definitions and implementations for each unique instruction type, one for each
//! unique `Opcode` variant.

use super::{
    wideint::{
        CompareArgs,
        DivArgs,
        MathArgs,
        MulArgs,
    },
    CheckRegId,
    GMArgs,
    GTFArgs,
    Imm12,
    Imm18,
    Instruction,
    RegId,
};

// Here we re-export the generated instruction types and constructors, but extend them
// with `gm_args` and `gtf_args` short-hand constructors below to take their `GMArgs` and
// `GTFArgs` values respectively.
#[doc(inline)]
pub use super::_op::*;

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl GM {
    /// Construct a `GM` instruction from its arguments.
    pub fn from_args(ra: RegId, args: GMArgs) -> Self {
        Self::new(ra, Imm18::new(args as _))
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl GTF {
    /// Construct a `GTF` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, args: GTFArgs) -> Self {
        Self::new(ra, rb, Imm12::new(args as _))
    }
}

/// Construct a `GM` instruction from its arguments.
pub fn gm_args<A: CheckRegId>(ra: A, args: GMArgs) -> Instruction {
    Instruction::GM(GM::from_args(ra.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `GM` instruction from its arguments.
    pub fn gm_args(ra: u8, args: GMArgs) -> typescript::Instruction {
        Instruction::GM(GM::from_args(ra.check(), args)).into()
    }
};

/// Construct a `GM` instruction from its arguments.
pub fn gtf_args<A: CheckRegId, B: CheckRegId>(
    ra: A,
    rb: B,
    args: GTFArgs,
) -> Instruction {
    Instruction::GTF(GTF::from_args(ra.check(), rb.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `GM` instruction from its arguments.
    pub fn gtf_args(ra: u8, rb: u8, args: GTFArgs) -> typescript::Instruction {
        Instruction::GTF(GTF::from_args(ra.check(), rb.check(), args)).into()
    }
};

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WDCM {
    /// Construct a `WDCM` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: CompareArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WQCM {
    /// Construct a `WQCM` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: CompareArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WDOP {
    /// Construct a `WDOP` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: MathArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WQOP {
    /// Construct a `WQOP` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: MathArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WDML {
    /// Construct a `WDML` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: MulArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WQML {
    /// Construct a `WQML` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: MulArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WDDV {
    /// Construct a `WDDV` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: DivArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl WQDV {
    /// Construct a `WQDV` instruction from its arguments.
    pub fn from_args(ra: RegId, rb: RegId, rc: RegId, args: DivArgs) -> Self {
        Self::new(ra, rb, rc, args.to_imm())
    }
}

/// Construct a `WDCM` instruction from its arguments.
pub fn wdcm_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: CompareArgs,
) -> Instruction {
    Instruction::WDCM(WDCM::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WDCM` instruction from its arguments.
    pub fn wdcm_args(
        ra: u8,
        rb: u8,
        rc: u8,
        args: CompareArgs,
    ) -> typescript::Instruction {
        crate::op::wdcm_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WQCM` instruction from its arguments.
pub fn wqcm_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: CompareArgs,
) -> Instruction {
    Instruction::WQCM(WQCM::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WQCM` instruction from its arguments.
    pub fn wqcm_args(
        ra: u8,
        rb: u8,
        rc: u8,
        args: CompareArgs,
    ) -> typescript::Instruction {
        crate::op::wqcm_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WDOP` instruction from its arguments.
pub fn wdop_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: MathArgs,
) -> Instruction {
    Instruction::WDOP(WDOP::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WDOP` instruction from its arguments.
    pub fn wdop_args(ra: u8, rb: u8, rc: u8, args: MathArgs) -> typescript::Instruction {
        crate::op::wdop_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WQOP` instruction from its arguments.
pub fn wqop_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: MathArgs,
) -> Instruction {
    Instruction::WQOP(WQOP::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WQOP` instruction from its arguments.
    pub fn wqop_args(ra: u8, rb: u8, rc: u8, args: MathArgs) -> typescript::Instruction {
        crate::op::wqop_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WDML` instruction from its arguments.
pub fn wdml_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: MulArgs,
) -> Instruction {
    Instruction::WDML(WDML::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WDML` instruction from its arguments.
    pub fn wdml_args(ra: u8, rb: u8, rc: u8, args: MulArgs) -> typescript::Instruction {
        crate::op::wdml_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WQML` instruction from its arguments.
pub fn wqml_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: MulArgs,
) -> Instruction {
    Instruction::WQML(WQML::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WQML` instruction from its arguments.
    pub fn wqml_args(ra: u8, rb: u8, rc: u8, args: MulArgs) -> typescript::Instruction {
        crate::op::wqml_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WDDV` instruction from its arguments.
pub fn wddv_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: DivArgs,
) -> Instruction {
    Instruction::WDDV(WDDV::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WDDV` instruction from its arguments.
    pub fn wddv_args(ra: u8, rb: u8, rc: u8, args: DivArgs) -> typescript::Instruction {
        crate::op::wddv_args(ra, rb, rc, args).into()
    }
};

/// Construct a `WQDV` instruction from its arguments.
pub fn wqdv_args<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
    ra: A,
    rb: B,
    rc: C,
    args: DivArgs,
) -> Instruction {
    Instruction::WQDV(WQDV::from_args(ra.check(), rb.check(), rc.check(), args))
}

#[cfg(feature = "typescript")]
const _: () = {
    use super::*;

    #[wasm_bindgen::prelude::wasm_bindgen]
    /// Construct a `WQDV` instruction from its arguments.
    pub fn wqdv_args(ra: u8, rb: u8, rc: u8, args: DivArgs) -> typescript::Instruction {
        crate::op::wqdv_args(ra, rb, rc, args).into()
    }
};

/home/marten/fuel/fuel-vm/fuel-asm/src/panic_reason.rs

Source
use core::fmt;

macro_rules! enum_from {
    (
        $(#[$meta:meta])* $vis:vis enum $name:ident {
            $($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)*
        }
    ) => {
        $(#[$meta])*
        $vis enum $name {
            $($(#[$vmeta])* $vname $(= $val)?,)*
        }

        impl From<u8> for $name {
            fn from(v: u8) -> Self {
                match v {
                    $(x if x == $name::$vname as u8 => $name::$vname,)*
                    _ => $name::UnknownPanicReason,
                }
            }
        }
    }
}

enum_from! {
    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumIter)]
    #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    #[repr(u8)]
    #[non_exhaustive]
    /// Panic reason representation for the interpreter.
    pub enum PanicReason {
        #[default]
        /// The byte can't be mapped to any known `PanicReason`.
        UnknownPanicReason = 0x00,
        /// Found `RVRT` instruction.
        Revert = 0x01,
        /// Execution ran out of gas.
        OutOfGas = 0x02,
        /// The transaction validity is violated.
        TransactionValidity = 0x03,
        /// Attempt to write outside interpreter memory boundaries.
        MemoryOverflow = 0x04,
        /// Overflow while executing arithmetic operation.
        /// These errors are ignored using the WRAPPING flag.
        ArithmeticOverflow = 0x05,
        /// Designed contract was not found in the storage.
        ContractNotFound = 0x06,
        /// Memory ownership rules are violated.
        MemoryOwnership = 0x07,
        /// The asset ID balance isn't enough for the instruction.
        NotEnoughBalance = 0x08,
        /// The interpreter is expected to be in internal context.
        ExpectedInternalContext = 0x09,
        /// The queried asset ID was not found in the state.
        AssetIdNotFound = 0x0a,
        /// The provided input is not found in the transaction.
        InputNotFound = 0x0b,
        /// The provided output is not found in the transaction.
        OutputNotFound = 0x0c,
        /// The provided witness is not found in the transaction.
        WitnessNotFound = 0x0d,
        /// The transaction maturity is not valid for this request.
        TransactionMaturity = 0x0e,
        /// The metadata identifier is invalid.
        InvalidMetadataIdentifier = 0x0f,
        /// The call structure is not valid.
        MalformedCallStructure = 0x10,
        /// The provided register does not allow write operations.
        ReservedRegisterNotWritable = 0x11,
        /// The execution resulted in an erroneous state of the interpreter.
        InvalidFlags = 0x12,
        /// The provided immediate value is not valid for this instruction.
        InvalidImmediateValue = 0x13,
        /// The provided transaction input is not of type `Coin`.
        ExpectedCoinInput = 0x14,
        /// `ECAL` instruction failed.
        EcalError = 0x15,
        /// Two segments of the interpreter memory should not intersect for write operations.
        MemoryWriteOverlap = 0x16,
        /// The requested contract is not listed in the transaction inputs.
        ContractNotInInputs = 0x17,
        /// The internal asset ID balance overflowed with the provided instruction.
        InternalBalanceOverflow = 0x18,
        /// The maximum allowed contract size is violated.
        ContractMaxSize = 0x19,
        /// This instruction expects the stack area to be unallocated for this call.
        ExpectedUnallocatedStack = 0x1a,
        /// The maximum allowed number of static contracts was reached for this transaction.
        MaxStaticContractsReached = 0x1b,
        /// The requested transfer amount cannot be zero.
        TransferAmountCannotBeZero = 0x1c,
        /// The provided transaction output should be of type `Variable`.
        ExpectedOutputVariable = 0x1d,
        /// The expected context of the stack parent is internal.
        ExpectedParentInternalContext = 0x1e,
        /// The predicate returned non `1`. The `1` means successful verification
        /// of the predicate, all other values means unsuccessful.
        PredicateReturnedNonOne = 0x1f,
        /// The contract ID is already deployed and can't be overwritten.
        ContractIdAlreadyDeployed = 0x20,
        /// The loaded contract mismatch expectations.
        ContractMismatch = 0x21,
        /// Attempting to send message data longer than `MAX_MESSAGE_DATA_LENGTH`
        MessageDataTooLong = 0x22,
        /// Mathematically invalid arguments where given to an arithmetic instruction.
        /// For instance, division by zero produces this.
        /// These errors are ignored using the UNSAFEMATH flag.
        ArithmeticError = 0x23,
        /// The contract instruction is not allowed in predicates.
        ContractInstructionNotAllowed = 0x24,
        /// Transfer of zero coins is not allowed.
        TransferZeroCoins = 0x25,
        /// Attempted to execute an invalid instruction
        InvalidInstruction = 0x26,
        /// Memory outside $is..$ssp range is not executable
        MemoryNotExecutable = 0x27,
        /// The policy is not set.
        PolicyIsNotSet = 0x28,
        /// The policy is not found across policies.
        PolicyNotFound = 0x29,
        /// Receipt context is full
        TooManyReceipts = 0x2a,
        /// Balance of a contract overflowed
        BalanceOverflow = 0x2b,
        /// Block height value is invalid, typically because it is too large
        InvalidBlockHeight = 0x2c,
        /// Attempt to use sequential memory instructions with too large slot count,
        /// typically because it cannot fit into usize
        TooManySlots = 0x2d,
        /// Caller of this internal context is also expected to be internal,
        /// i.e. $fp->$fp must be non-zero.
        ExpectedNestedCaller = 0x2e,
        /// During memory growth, the stack overlapped with the heap
        MemoryGrowthOverlap = 0x2f,
        /// Attempting to read or write uninitialized memory.
        /// Also occurs when boundary crosses from stack to heap.
        UninitalizedMemoryAccess = 0x30,
        /// Overriding consensus parameters is not allowed.
        OverridingConsensusParameters = 0x31,
        /// The storage doesn't know about the hash of the state transition bytecode.
        UnknownStateTransactionBytecodeRoot = 0x32,
        /// Overriding the state transition bytecode is not allowed.
        OverridingStateTransactionBytecode = 0x33,
        /// The bytecode is already uploaded and cannot be uploaded again.
        BytecodeAlreadyUploaded = 0x34,
        /// The part of the bytecode is not sequentially connected to the previous parts.
        ThePartIsNotSequentiallyConnected = 0x35,
        /// The requested blob is not found.
        BlobNotFound = 0x36,
        /// The blob was already
        BlobIdAlreadyUploaded = 0x37,
        /// Active gas costs do not define the cost for this instruction.
        GasCostNotDefined = 0x38,
    }
}

impl fmt::Display for PanicReason {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{self:?}")
    }
}

impl From<core::array::TryFromSliceError> for PanicReason {
    fn from(_: core::array::TryFromSliceError) -> Self {
        Self::MemoryOverflow
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use strum::IntoEnumIterator;

    #[test]
    fn test_u8_panic_reason_round_trip() {
        let last_known_panic_reason: u8 = PanicReason::iter().last().unwrap() as u8 + 1;
        let reason = PanicReason::from(0);
        assert_eq!(reason, PanicReason::UnknownPanicReason);

        for i in 1..last_known_panic_reason {
            let reason = PanicReason::from(i);
            let i2 = reason as u8;
            assert_eq!(i, i2);
        }
        for i in last_known_panic_reason..=255 {
            let reason = PanicReason::from(i);
            let i2 = reason as u8;
            assert_eq!(PanicReason::UnknownPanicReason as u8, i2);
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-asm/src/panic_instruction.rs

Source
use core::fmt;

use crate::{
    Instruction,
    PanicReason,
    RawInstruction,
    Word,
};

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
/// Describe a panic reason with the instruction that generated it
pub struct PanicInstruction {
    #[canonical(skip)]
    reason: PanicReason,
    instruction: RawInstruction,
}

impl PanicInstruction {
    /// Represents an error described by a reason and an instruction.
    pub const fn error(reason: PanicReason, instruction: RawInstruction) -> Self {
        Self {
            reason,
            instruction,
        }
    }

    /// Underlying panic reason
    pub const fn reason(&self) -> &PanicReason {
        &self.reason
    }

    /// Underlying instruction
    pub const fn instruction(&self) -> &RawInstruction {
        &self.instruction
    }
}

/// Helper struct to debug-format a `RawInstruction` in `PanicInstruction::fmt`.
struct InstructionDbg(RawInstruction);
impl fmt::Debug for InstructionDbg {
    /// Formats like this: `MOVI { dst: 32, val: 32 } (bytes: 72 80 00 20)`}`
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match Instruction::try_from(self.0) {
            Ok(instr) => write!(f, "{:?}", instr)?,
            Err(_) => write!(f, "Unknown")?,
        };
        write!(f, " (bytes: ")?;
        for (i, byte) in self.0.to_be_bytes().iter().enumerate() {
            if i != 0 {
                write!(f, " ")?;
            }
            write!(f, "{:02x}", byte)?;
        }
        write!(f, ")")
    }
}

impl fmt::Debug for PanicInstruction {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("PanicInstruction")
            .field("reason", &self.reason)
            .field("instruction", &InstructionDbg(self.instruction))
            .finish()
    }
}

#[cfg(feature = "typescript")]
#[wasm_bindgen::prelude::wasm_bindgen]
impl PanicInstruction {
    /// Represents an error described by a reason and an instruction.
    #[wasm_bindgen(constructor)]
    pub fn error_typescript(reason: PanicReason, instruction: RawInstruction) -> Self {
        Self::error(reason, instruction)
    }

    /// Underlying panic reason
    #[wasm_bindgen(js_name = reason)]
    pub fn reason_typescript(&self) -> PanicReason {
        *self.reason()
    }

    /// Underlying instruction
    #[wasm_bindgen(js_name = instruction)]
    pub fn instruction_typescript(&self) -> RawInstruction {
        *self.instruction()
    }
}

const WORD_SIZE: usize = core::mem::size_of::<Word>();
const REASON_OFFSET: Word = (WORD_SIZE * 8 - 8) as Word;
const INSTR_OFFSET: Word = REASON_OFFSET - (Instruction::SIZE * 8) as Word;

impl From<PanicInstruction> for Word {
    fn from(r: PanicInstruction) -> Word {
        let reason = Word::from(r.reason as u8);
        let instruction = Word::from(r.instruction);
        (reason << REASON_OFFSET) | (instruction << INSTR_OFFSET)
    }
}

impl From<Word> for PanicInstruction {
    #[allow(clippy::cast_possible_truncation)]
    fn from(val: Word) -> Self {
        // Safe to cast as we've shifted the 8 MSB.
        let reason_u8 = (val >> REASON_OFFSET) as u8;
        // Cast to truncate in order to remove the `reason` bits.
        let instruction = (val >> INSTR_OFFSET) as u32;
        let reason = PanicReason::from(reason_u8);
        Self {
            reason,
            instruction,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::op;
    use fuel_types::canonical::Serialize;

    #[test]
    fn canonical_serialization_ignores_panic_reason() {
        let revert_panic_instruction =
            PanicInstruction::error(PanicReason::Revert, op::noop().into());
        let out_of_gas_panic_instruction =
            PanicInstruction::error(PanicReason::OutOfGas, op::noop().into());
        assert_eq!(
            revert_panic_instruction.to_bytes(),
            out_of_gas_panic_instruction.to_bytes()
        );
    }
}

/home/marten/fuel/fuel-vm/fuel-asm/src/args.rs

Source
pub mod wideint;

/// 12-bits immediate value type
type Immediate12 = u16;

/// 18-bits immediate value type
type Immediate18 = u32;

crate::enum_try_from! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumIter)]
    #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
    #[repr(u8)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    /// Argument list for GM (get metadata) instruction
    /// The VM is the only who should match this struct, and it *MUST* always perform
    /// exhaustive match so all offered variants are covered.
    pub enum GMArgs {
        /// Get if caller is external.
        IsCallerExternal = 0x01,

        /// Get caller's contract ID.
        GetCaller = 0x02,

        /// Get index of current predicate.
        GetVerifyingPredicate = 0x03,

        /// Get the Chain ID this VM is operating within
        GetChainId = 0x04,

        /// Get memory address where the transaction is located
        TxStart = 0x05,

        /// Get memory address of base asset ID
        BaseAssetId = 0x06,
    },
    Immediate18
}

impl From<GMArgs> for Immediate18 {
    fn from(args: GMArgs) -> Self {
        args as Immediate18
    }
}

crate::enum_try_from! {
    /// Argument list for GTF (get tx fields) instruction
    /// The VM is the only who should match this struct, and it *MUST* always perform
    /// exhaustive match so all offered variants are covered.
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumIter)]
    #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
    #[repr(u16)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    pub enum GTFArgs {
        /// Set `$rA` to `tx.type`
        Type = 0x001,

        /// Set `$rA` to `tx.scriptGasLimit`
        ScriptGasLimit = 0x002,

        /// Set `$rA` to `tx.scriptLength`
        ScriptLength = 0x003,

        /// Set `$rA` to `tx.scriptDataLength`
        ScriptDataLength = 0x004,

        /// Set `$rA` to `tx.inputsCount`
        ScriptInputsCount = 0x005,

        /// Set `$rA` to `tx.outputsCount`
        ScriptOutputsCount = 0x006,

        /// Set `$rA` to `tx.witnessesCount`
        ScriptWitnessesCount = 0x007,

        /// Set `$rA` to `Memory address of tx.script`
        Script = 0x009,

        /// Set `$rA` to `Memory address of tx.scriptData`
        ScriptData = 0x00A,

        /// Set `$rA` to `Memory address of tx.inputs[$rB]`
        ScriptInputAtIndex = 0x00B,

        /// Set `$rA` to `Memory address of t.outputs[$rB]`
        ScriptOutputAtIndex = 0x00C,

        /// Set `$rA` to `Memory address of tx.witnesses[$rB]`
        ScriptWitnessAtIndex = 0x00D,

        /// Set `$rA` to size of the transaction in memory, in bytes
        TxLength = 0x00E,

        /// Set `$rA` to `tx.bytecodeWitnessIndex`
        CreateBytecodeWitnessIndex = 0x101,

        /// Set `$rA` to `tx.storageSlotsCount`
        CreateStorageSlotsCount = 0x102,

        /// Set `$rA` to `tx.inputsCount`
        CreateInputsCount = 0x103,

        /// Set `$rA` to `tx.outputsCount`
        CreateOutputsCount = 0x104,

        /// Set `$rA` to `tx.witnessesCount`
        CreateWitnessesCount = 0x105,

        /// Set `$rA` to `Memory address of tx.salt`
        CreateSalt = 0x106,

        /// Set `$rA` to `Memory address of tx.storageSlots[$rB]`
        CreateStorageSlotAtIndex = 0x107,

        /// Set `$rA` to `Memory address of tx.inputs[$rB]`
        CreateInputAtIndex = 0x108,

        /// Set `$rA` to `Memory address of t.outputs[$rB]`
        CreateOutputAtIndex = 0x109,

        /// Set `$rA` to `Memory address of tx.witnesses[$rB]`
        CreateWitnessAtIndex = 0x10A,

        /// Set `$rA` to `tx.inputs[$rB].type`
        InputType = 0x200,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].txID`
        InputCoinTxId = 0x201,

        /// Set `$rA` to `tx.inputs[$rB].outputIndex`
        InputCoinOutputIndex = 0x202,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].owner`
        InputCoinOwner = 0x203,

        /// Set `$rA` to `tx.inputs[$rB].amount`
        InputCoinAmount = 0x204,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].asset_id`
        InputCoinAssetId = 0x205,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].txPointer`
        InputCoinTxPointer = 0x206,

        /// Set `$rA` to `tx.inputs[$rB].witnessIndex`
        InputCoinWitnessIndex = 0x207,

        /// Set `$rA` to `tx.inputs[$rB].predicateLength`
        InputCoinPredicateLength = 0x209,

        /// Set `$rA` to `tx.inputs[$rB].predicateDataLength`
        InputCoinPredicateDataLength = 0x20A,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
        InputCoinPredicate = 0x20B,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
        InputCoinPredicateData = 0x20C,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
        InputCoinPredicateGasUsed = 0x20D,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].txID`
        InputContractTxId = 0x220,

        /// Set `$rA` to `tx.inputs[$rB].outputIndex`
        InputContractOutputIndex = 0x221,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].contractID`
        InputContractId = 0x225,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].sender`
        InputMessageSender = 0x240,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].recipient`
        InputMessageRecipient = 0x241,

        /// Set `$rA` to `tx.inputs[$rB].amount`
        InputMessageAmount = 0x242,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].nonce`
        InputMessageNonce = 0x243,

        /// Set `$rA` to `tx.inputs[$rB].witnessIndex`
        InputMessageWitnessIndex = 0x244,

        /// Set `$rA` to `tx.inputs[$rB].dataLength`
        InputMessageDataLength = 0x245,

        /// Set `$rA` to `tx.inputs[$rB].predicateLength`
        InputMessagePredicateLength = 0x246,

        /// Set `$rA` to `tx.inputs[$rB].predicateDataLength`
        InputMessagePredicateDataLength = 0x247,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].data`
        InputMessageData = 0x248,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].predicate`
        InputMessagePredicate = 0x249,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateData`
        InputMessagePredicateData = 0x24A,

        /// Set `$rA` to `Memory address of tx.inputs[$rB].predicateGasUsed`
        InputMessagePredicateGasUsed = 0x24B,

        /// Set `$rA` to `tx.outputs[$rB].type`
        OutputType = 0x300,

        /// Set `$rA` to `Memory address of tx.outputs[$rB].to`
        OutputCoinTo = 0x301,

        /// Set `$rA` to `tx.outputs[$rB].amount`
        OutputCoinAmount = 0x302,

        /// Set `$rA` to `Memory address of tx.outputs[$rB].asset_id`
        OutputCoinAssetId = 0x303,

        /// Set `$rA` to `tx.outputs[$rB].inputIndex`
        OutputContractInputIndex = 0x304,

        /// Set `$rA` to `Memory address of tx.outputs[$rB].contractID`
        OutputContractCreatedContractId = 0x307,

        /// Set `$rA` to `Memory address of tx.outputs[$rB].stateRoot`
        OutputContractCreatedStateRoot = 0x308,

        /// Set `$rA` to `tx.witnesses[$rB].dataLength`
        WitnessDataLength = 0x400,

        /// Set `$rA` to `Memory address of tx.witnesses[$rB].data`
        WitnessData = 0x401,

        /// Set `$rA` to `tx.policyTypes`
        PolicyTypes = 0x500,

        /// Set `$rA` to `tx.policies[0x00].gasPrice`
        PolicyTip = 0x501,

        /// Set `$rA` to `tx.policies[count_ones(0b11 & tx.policyTypes) - 1].witnessLimit`
        PolicyWitnessLimit = 0x502,

        /// Set `$rA` to `tx.policies[count_ones(0b111 & tx.policyTypes) - 1].maturity`
        PolicyMaturity = 0x503,

        /// Set `$rA` to `tx.policies[count_ones(0b1111 & tx.policyTypes) - 1].maxFee`
        PolicyMaxFee = 0x504,
    },
    Immediate12
}

impl From<GTFArgs> for Immediate12 {
    fn from(args: GTFArgs) -> Self {
        args as Immediate12
    }
}

#[test]
#[cfg(feature = "std")]
fn encode_gm_args() {
    let args = vec![
        GMArgs::IsCallerExternal,
        GMArgs::GetCaller,
        GMArgs::GetVerifyingPredicate,
        GMArgs::GetChainId,
        GMArgs::TxStart,
        GMArgs::BaseAssetId,
    ];

    args.into_iter().for_each(|a| {
        let imm = a as Immediate18;
        let a_p = GMArgs::try_from(imm).expect("failed to convert GMArgs");

        assert_eq!(a, a_p);
    });
}

#[test]
#[cfg(feature = "std")]
fn encode_gtf_args() {
    let args = vec![
        GTFArgs::Type,
        GTFArgs::ScriptGasLimit,
        GTFArgs::ScriptLength,
        GTFArgs::ScriptDataLength,
        GTFArgs::ScriptInputsCount,
        GTFArgs::ScriptOutputsCount,
        GTFArgs::ScriptWitnessesCount,
        GTFArgs::Script,
        GTFArgs::ScriptData,
        GTFArgs::ScriptInputAtIndex,
        GTFArgs::ScriptOutputAtIndex,
        GTFArgs::ScriptWitnessAtIndex,
        GTFArgs::CreateBytecodeWitnessIndex,
        GTFArgs::CreateStorageSlotsCount,
        GTFArgs::CreateInputsCount,
        GTFArgs::CreateOutputsCount,
        GTFArgs::CreateWitnessesCount,
        GTFArgs::CreateSalt,
        GTFArgs::CreateStorageSlotAtIndex,
        GTFArgs::CreateInputAtIndex,
        GTFArgs::CreateOutputAtIndex,
        GTFArgs::CreateWitnessAtIndex,
        GTFArgs::InputType,
        GTFArgs::InputCoinTxId,
        GTFArgs::InputCoinOutputIndex,
        GTFArgs::InputCoinOwner,
        GTFArgs::InputCoinAmount,
        GTFArgs::InputCoinAssetId,
        GTFArgs::InputCoinTxPointer,
        GTFArgs::InputCoinWitnessIndex,
        GTFArgs::InputCoinPredicateLength,
        GTFArgs::InputCoinPredicateDataLength,
        GTFArgs::InputCoinPredicate,
        GTFArgs::InputCoinPredicateData,
        GTFArgs::InputCoinPredicateGasUsed,
        GTFArgs::InputContractId,
        GTFArgs::InputMessageSender,
        GTFArgs::InputMessageRecipient,
        GTFArgs::InputMessageAmount,
        GTFArgs::InputMessageNonce,
        GTFArgs::InputMessageWitnessIndex,
        GTFArgs::InputMessageDataLength,
        GTFArgs::InputMessagePredicateLength,
        GTFArgs::InputMessagePredicateDataLength,
        GTFArgs::InputMessageData,
        GTFArgs::InputMessagePredicate,
        GTFArgs::InputMessagePredicateData,
        GTFArgs::InputMessagePredicateGasUsed,
        GTFArgs::OutputType,
        GTFArgs::OutputCoinTo,
        GTFArgs::OutputCoinAmount,
        GTFArgs::OutputCoinAssetId,
        GTFArgs::OutputContractInputIndex,
        GTFArgs::OutputContractCreatedContractId,
        GTFArgs::OutputContractCreatedStateRoot,
        GTFArgs::WitnessDataLength,
        GTFArgs::WitnessData,
        GTFArgs::PolicyTypes,
        GTFArgs::PolicyTip,
        GTFArgs::PolicyWitnessLimit,
        GTFArgs::PolicyMaturity,
        GTFArgs::PolicyMaxFee,
    ];

    args.into_iter().for_each(|a| {
        let imm = a as Immediate12;
        let a_p = GTFArgs::try_from(imm).expect("failed to convert GTFArgs");

        assert_eq!(a, a_p);
    });
}

/home/marten/fuel/fuel-vm/fuel-asm/src/lib.rs

Source
//! FuelVM instruction and opcodes representation.

#![cfg_attr(docsrs, feature(doc_auto_cfg))]
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(feature = "std", doc = include_str!("../README.md"))]
#![deny(
    clippy::arithmetic_side_effects,
    clippy::cast_sign_loss,
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
    clippy::string_slice
)]
#![deny(missing_docs)]
#![deny(unsafe_code)]
#![deny(unused_crate_dependencies)]

#[cfg(feature = "alloc")]
extern crate alloc;

mod args;
mod panic_instruction;
// This is `pub` to make documentation for the private `impl_instructions!` macro more
// accessible.
#[macro_use]
pub mod macros;
pub mod op;
mod pack;
mod panic_reason;
mod unpack;

#[cfg(test)]
mod encoding_tests;

#[doc(no_inline)]
pub use args::{
    wideint,
    GMArgs,
    GTFArgs,
};

/// Register ID type
pub type RegisterId = usize;

/// Register value type
pub type Word = u64;

pub use panic_instruction::PanicInstruction;
pub use panic_reason::PanicReason;

/// Represents a 6-bit register ID, guaranteed to be masked by construction.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
pub struct RegId(u8);

/// Represents a 6-bit immediate value, guaranteed to be masked by construction.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
pub struct Imm06(u8);

/// Represents a 12-bit immediate value, guaranteed to be masked by construction.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
pub struct Imm12(u16);

/// Represents a 18-bit immediate value, guaranteed to be masked by construction.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
pub struct Imm18(u32);

/// Represents a 24-bit immediate value, guaranteed to be masked by construction.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
pub struct Imm24(u32);

/// An instruction in its raw, packed, unparsed representation.
pub type RawInstruction = u32;

/// Given opcode doesn't exist, or is the reserved part of
/// the instruction (i.e. space outside arguments) is non-zero.
#[derive(Debug, Eq, PartialEq)]
pub struct InvalidOpcode;

bitflags::bitflags! {
    /// Possible values for the FLAG instruction.
    /// See https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/index.md#flags
    pub struct Flags: Word {
        /// If set, arithmetic errors result in setting $err instead of panicking.
        /// This includes cases where result of a computation is undefined, like
        /// division by zero. Arithmetic overflows still cause a panic, but that be
        /// controlled with [`Flags::WRAPPING`].
        const UNSAFEMATH = 0x01;
        /// If set, arithmetic overflows result in setting $of instead of panicking.
        const WRAPPING = 0x02;
    }
}
/// Type is convertible to a [`RegId`]
pub trait CheckRegId {
    /// Convert to a [`RegId`], or panic
    fn check(self) -> RegId;
}

impl CheckRegId for RegId {
    fn check(self) -> RegId {
        self
    }
}

impl CheckRegId for u8 {
    fn check(self) -> RegId {
        RegId::new_checked(self).expect("CheckRegId was given invalid RegId")
    }
}

// Defines the `Instruction` and `Opcode` types, along with an `op` module declaring a
// unique type for each opcode's instruction variant. For a detailed explanation of how
// this works, see the `fuel_asm::macros` module level documentation.
impl_instructions! {
    "Adds two registers."
    0x10 ADD add [dst: RegId lhs: RegId rhs: RegId]
    "Bitwise ANDs two registers."
    0x11 AND and [dst: RegId lhs: RegId rhs: RegId]
    "Divides two registers."
    0x12 DIV div [dst: RegId lhs: RegId rhs: RegId]
    "Compares two registers for equality."
    0x13 EQ eq [dst: RegId lhs: RegId rhs: RegId]
    "Raises one register to the power of another."
    0x14 EXP exp [dst: RegId lhs: RegId rhs: RegId]
    "Compares two registers for greater-than."
    0x15 GT gt [dst: RegId lhs: RegId rhs: RegId]
    "Compares two registers for less-than."
    0x16 LT lt [dst: RegId lhs: RegId rhs: RegId]
    "The integer logarithm of a register."
    0x17 MLOG mlog [dst: RegId lhs: RegId rhs: RegId]
    "The integer root of a register."
    0x18 MROO mroo [dst: RegId lhs: RegId rhs: RegId]
    "Modulo remainder of two registers."
    0x19 MOD mod_ [dst: RegId lhs: RegId rhs: RegId]
    "Copy from one register to another."
    0x1A MOVE move_ [dst: RegId src: RegId]
    "Multiplies two registers."
    0x1B MUL mul [dst: RegId lhs: RegId rhs: RegId]
    "Bitwise NOT a register."
    0x1C NOT not [dst: RegId arg: RegId]
    "Bitwise ORs two registers."
    0x1D OR or [dst: RegId lhs: RegId rhs: RegId]
    "Left shifts a register by a register."
    0x1E SLL sll [dst: RegId lhs: RegId rhs: RegId]
    "Right shifts a register by a register."
    0x1F SRL srl [dst: RegId lhs: RegId rhs: RegId]
    "Subtracts two registers."
    0x20 SUB sub [dst: RegId lhs: RegId rhs: RegId]
    "Bitwise XORs two registers."
    0x21 XOR xor [dst: RegId lhs: RegId rhs: RegId]
    "Fused multiply-divide with arbitrary precision intermediate step."
    0x22 MLDV mldv [dst: RegId mul_lhs: RegId mul_rhs: RegId divisor: RegId]

    "Return from context."
    0x24 RET ret [value: RegId]
    "Return from context with data."
    0x25 RETD retd [addr: RegId len: RegId]
    "Allocate a number of bytes from the heap."
    0x26 ALOC aloc [bytes: RegId]
    "Clear a variable number of bytes in memory."
    0x27 MCL mcl [dst_addr: RegId len: RegId]
    "Copy a variable number of bytes in memory."
    0x28 MCP mcp [dst_addr: RegId src_addr: RegId len: RegId]
    "Compare bytes in memory."
    0x29 MEQ meq [result: RegId lhs_addr: RegId rhs_addr: RegId len: RegId]
    "Get block header hash for height."
    0x2A BHSH bhsh [dst: RegId heigth: RegId]
    "Get current block height."
    0x2B BHEI bhei [dst: RegId]
    "Burns `amount` coins of the asset ID created from `sub_id` for the current contract."
    0x2C BURN burn [amount: RegId sub_id_addr: RegId]
    "Call a contract."
    0x2D CALL call [target_struct: RegId fwd_coins: RegId asset_id_addr: RegId fwd_gas: RegId]
    "Copy contract code for a contract."
    0x2E CCP ccp [dst_addr: RegId contract_id_addr: RegId offset: RegId len: RegId]
    "Get code root of a contract."
    0x2F CROO croo [dst_addr: RegId contract_id_addr: RegId]
    "Get code size of a contract."
    0x30 CSIZ csiz [dst: RegId contract_id_addr: RegId]
    "Get current block proposer's address."
    0x31 CB cb [dst: RegId]
    "Load code as executable either from contract, blob, or memory."
    0x32 LDC ldc [src_addr: RegId offset: RegId len: RegId mode: Imm06]
    "Log an event."
    0x33 LOG log [a: RegId b: RegId c: RegId d: RegId]
    "Log data."
    0x34 LOGD logd [a: RegId b: RegId addr: RegId len: RegId]
    "Mints `amount` coins of the asset ID created from `sub_id` for the current contract."
    0x35 MINT mint [amount: RegId sub_id_addr: RegId]
    "Halt execution, reverting state changes and returning a value."
    0x36 RVRT rvrt [value: RegId]
    "Clear a series of slots from contract storage."
    0x37 SCWQ scwq [key_addr: RegId status: RegId lenq: RegId]
    "Load a word from contract storage."
    0x38 SRW srw [dst: RegId status: RegId key_addr: RegId]
    "Load a series of 32 byte slots from contract storage."
    0x39 SRWQ srwq [dst_addr: RegId status: RegId key_addr:RegId lenq: RegId]
    "Store a word in contract storage."
    0x3A SWW sww [key_addr: RegId status: RegId value: RegId]
    "Store a series of 32 byte slots in contract storage."
    0x3B SWWQ swwq [key_addr: RegId status: RegId src_addr: RegId lenq: RegId]
    "Transfer coins to a contract unconditionally."
    0x3C TR tr [contract_id_addr: RegId amount: RegId asset_id_addr: RegId]
    "Transfer coins to a variable output."
    0x3D TRO tro [contract_id_addr: RegId output_index: RegId amount: RegId asset_id_addr: RegId]
    "The 64-byte public key (x, y) recovered from 64-byte signature on 32-byte message hash."
    0x3E ECK1 eck1 [dst_addr: RegId sig_addr: RegId msg_hash_addr: RegId]
    "The 64-byte Secp256r1 public key (x, y) recovered from 64-byte signature on 32-byte message hash."
    0x3F ECR1 ecr1 [dst_addr: RegId sig_addr: RegId msg_hash_addr: RegId]
    "Verify ED25519 public key and signature match a message."
    0x40 ED19 ed19 [pub_key_addr: RegId sig_addr: RegId msg_addr: RegId msg_len: RegId]
    "The keccak-256 hash of a slice."
    0x41 K256 k256 [dst_addr: RegId src_addr: RegId len: RegId]
    "The SHA-2-256 hash of a slice."
    0x42 S256 s256 [dst_addr: RegId src_addr: RegId len: RegId]
    "Get timestamp of block at given height."
    0x43 TIME time [dst: RegId heigth: RegId]

    "Performs no operation."
    0x47 NOOP noop []
    "Set flag register to a register."
    0x48 FLAG flag [value: RegId]
    "Get the balance of contract of an asset ID."
    0x49 BAL bal [dst: RegId asset_id_addr: RegId contract_id_addr: RegId]
    "Dynamic jump."
    0x4A JMP jmp [abs_target: RegId]
    "Conditional dynamic jump."
    0x4B JNE jne [abs_target: RegId lhs: RegId rhs: RegId]
    "Send a message to recipient address with call abi, coins, and output."
    0x4C SMO smo [recipient_addr: RegId data_addr: RegId data_len: RegId coins: RegId]

    "Adds a register and an immediate value."
    0x50 ADDI addi [dst: RegId lhs: RegId rhs: Imm12]
    "Bitwise ANDs a register and an immediate value."
    0x51 ANDI andi [dst: RegId lhs: RegId rhs: Imm12]
    "Divides a register and an immediate value."
    0x52 DIVI divi [dst: RegId lhs: RegId rhs: Imm12]
    "Raises one register to the power of an immediate value."
    0x53 EXPI expi [dst: RegId lhs: RegId rhs: Imm12]
    "Modulo remainder of a register and an immediate value."
    0x54 MODI modi [dst: RegId lhs: RegId rhs: Imm12]
    "Multiplies a register and an immediate value."
    0x55 MULI muli [dst: RegId lhs: RegId rhs: Imm12]
    "Bitwise ORs a register and an immediate value."
    0x56 ORI ori [dst: RegId lhs: RegId rhs: Imm12]
    "Left shifts a register by an immediate value."
    0x57 SLLI slli [dst: RegId lhs: RegId rhs: Imm12]
    "Right shifts a register by an immediate value."
    0x58 SRLI srli [dst: RegId lhs: RegId rhs: Imm12]
    "Subtracts a register and an immediate value."
    0x59 SUBI subi [dst: RegId lhs: RegId rhs: Imm12]
    "Bitwise XORs a register and an immediate value."
    0x5A XORI xori [dst: RegId lhs: RegId rhs: Imm12]
    "Conditional jump."
    0x5B JNEI jnei [cond_lhs: RegId cond_rhs: RegId abs_target: Imm12]
    "A byte is loaded from the specified address offset by an immediate value."
    0x5C LB lb [dst: RegId addr: RegId offset: Imm12]
    "A word is loaded from the specified address offset by an immediate value."
    0x5D LW lw [dst: RegId addr: RegId offset: Imm12]
    "Write the least significant byte of a register to memory."
    0x5E SB sb [addr: RegId value: RegId offset: Imm12]
    "Write a register to memory."
    0x5F SW sw [addr: RegId value: RegId offset: Imm12]
    "Copy an immediate number of bytes in memory."
    0x60 MCPI mcpi [dst_addr: RegId src_addr: RegId len: Imm12]
    "Get transaction fields."
    0x61 GTF gtf [dst: RegId arg: RegId selector: Imm12]

    "Clear an immediate number of bytes in memory."
    0x70 MCLI mcli [addr: RegId count: Imm18]
    "Get metadata from memory."
    0x71 GM gm [dst: RegId selector: Imm18]
    "Copy immediate value into a register"
    0x72 MOVI movi [dst: RegId val: Imm18]
    "Conditional jump against zero."
    0x73 JNZI jnzi [cond_nz: RegId abs_target: Imm18]
    "Unconditional dynamic relative jump forwards, with a constant offset."
    0x74 JMPF jmpf [dynamic: RegId fixed: Imm18]
    "Unconditional dynamic relative jump backwards, with a constant offset."
    0x75 JMPB jmpb [dynamic: RegId fixed: Imm18]
    "Dynamic relative jump forwards, conditional against zero, with a constant offset."
    0x76 JNZF jnzf [cond_nz: RegId dynamic: RegId fixed: Imm12]
    "Dynamic relative jump backwards, conditional against zero, with a constant offset."
    0x77 JNZB jnzb [cond_nz: RegId dynamic: RegId fixed: Imm12]
    "Dynamic relative jump forwards, conditional on comparsion, with a constant offset."
    0x78 JNEF jnef [cond_lhs: RegId cond_rhs: RegId dynamic: RegId fixed: Imm06]
    "Dynamic relative jump backwards, conditional on comparsion, with a constant offset."
    0x79 JNEB jneb [cond_lhs: RegId cond_rhs: RegId dynamic: RegId fixed: Imm06]

    "Jump."
    0x90 JI ji [abs_target: Imm24]
    "Extend the current call frame's stack by an immediate value."
    0x91 CFEI cfei [amount: Imm24]
    "Shrink the current call frame's stack by an immediate value."
    0x92 CFSI cfsi [amount: Imm24]
    "Extend the current call frame's stack"
    0x93 CFE cfe [amount: RegId]
    "Shrink the current call frame's stack"
    0x94 CFS cfs [amount: RegId]
    "Push a bitmask-selected set of registers in range 16..40 to the stack."
    0x95 PSHL pshl [bitmask: Imm24]
    "Push a bitmask-selected set of registers in range 40..64 to the stack."
    0x96 PSHH pshh [bitmask: Imm24]
    "Pop a bitmask-selected set of registers in range 16..40 to the stack."
    0x97 POPL popl [bitmask: Imm24]
    "Pop a bitmask-selected set of registers in range 40..64 to the stack."
    0x98 POPH poph [bitmask: Imm24]

    "Compare 128bit integers"
    0xa0 WDCM wdcm [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Compare 256bit integers"
    0xa1 WQCM wqcm [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Simple 128bit operations"
    0xa2 WDOP wdop [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Simple 256bit operations"
    0xa3 WQOP wqop [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Multiply 128bit"
    0xa4 WDML wdml [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Multiply 256bit"
    0xa5 WQML wqml [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Divide 128bit"
    0xa6 WDDV wddv [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Divide 256bit"
    0xa7 WQDV wqdv [dst: RegId lhs: RegId rhs: RegId flags: Imm06]
    "Fused multiply-divide 128bit"
    0xa8 WDMD wdmd [dst: RegId mul_lhs: RegId mul_rhs: RegId divisor: RegId]
    "Fused multiply-divide 256bit"
    0xa9 WQMD wqmd [dst: RegId mul_lhs: RegId mul_rhs: RegId divisor: RegId]
    "AddMod 128bit"
    0xaa WDAM wdam [dst: RegId add_lhs: RegId add_rhs: RegId modulo: RegId]
    "AddMod 256bit"
    0xab WQAM wqam [dst: RegId add_lhs: RegId add_rhs: RegId modulo: RegId]
    "MulMod 128bit"
    0xac WDMM wdmm [dst: RegId mul_lhs: RegId mul_rhs: RegId modulo: RegId]
    "MulMod 256bit"
    0xad WQMM wqmm [dst: RegId mul_lhs: RegId mul_rhs: RegId modulo: RegId]

    "Call external function"
    0xb0 ECAL ecal [a: RegId b: RegId c: RegId d: RegId]

    "Get blob size"
    0xba BSIZ bsiz [dst: RegId blob_id_ptr: RegId]
    "Load blob as data"
    0xbb BLDD bldd [dst_ptr: RegId blob_id_ptr: RegId offset: RegId len: RegId]
}

impl Instruction {
    /// Size of an instruction in bytes
    pub const SIZE: usize = core::mem::size_of::<Instruction>();

    /// Convenience method for converting to bytes
    pub fn to_bytes(self) -> [u8; 4] {
        self.into()
    }
}

#[cfg(feature = "typescript")]
mod typescript {
    /// Representation of a single instruction for the interpreter.
    ///
    /// The opcode is represented in the tag (variant), or may be retrieved in the
    /// form of an `Opcode` byte using the `opcode` method.
    ///
    /// The register and immediate data associated with the instruction is represented
    /// within an inner unit type wrapper around the 3 remaining bytes.
    #[derive(Clone, Eq, Hash, PartialEq)]
    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
    #[wasm_bindgen::prelude::wasm_bindgen]
    pub struct Instruction(Box<crate::Instruction>);

    impl Instruction {
        pub fn new(instruction: crate::Instruction) -> Self {
            Self(Box::new(instruction))
        }
    }

    #[wasm_bindgen::prelude::wasm_bindgen]
    impl Instruction {
        /// Convenience method for converting to bytes
        pub fn to_bytes(&self) -> Vec<u8> {
            use core::ops::Deref;
            self.deref().to_bytes().to_vec()
        }

        /// Size of an instruction in bytes
        pub fn size() -> usize {
            crate::Instruction::SIZE
        }
    }

    impl core::ops::Deref for Instruction {
        type Target = crate::Instruction;

        fn deref(&self) -> &crate::Instruction {
            self.0.as_ref()
        }
    }

    impl core::ops::DerefMut for Instruction {
        fn deref_mut(&mut self) -> &mut crate::Instruction {
            self.0.as_mut()
        }
    }

    impl core::borrow::Borrow<crate::Instruction> for Instruction {
        fn borrow(&self) -> &crate::Instruction {
            self.0.as_ref()
        }
    }

    impl core::borrow::BorrowMut<crate::Instruction> for Instruction {
        fn borrow_mut(&mut self) -> &mut crate::Instruction {
            self.0.as_mut()
        }
    }
}

impl RegId {
    /// Received balance for this context.
    pub const BAL: Self = Self(0x0B);
    /// Remaining gas in the context.
    pub const CGAS: Self = Self(0x0A);
    /// Error codes for particular operations.
    pub const ERR: Self = Self(0x08);
    /// Flags register.
    pub const FLAG: Self = Self(0x0F);
    /// Frame pointer. Memory address of beginning of current call frame.
    pub const FP: Self = Self(0x06);
    /// Remaining gas globally.
    pub const GGAS: Self = Self(0x09);
    /// Heap pointer. Memory address below the current bottom of the heap (points to free
    /// memory).
    pub const HP: Self = Self(0x07);
    /// Instructions start. Pointer to the start of the currently-executing code.
    pub const IS: Self = Self(0x0C);
    /// Contains overflow/underflow of addition, subtraction, and multiplication.
    pub const OF: Self = Self(0x02);
    /// Contains one (1), for convenience.
    pub const ONE: Self = Self(0x01);
    /// The program counter. Memory address of the current instruction.
    pub const PC: Self = Self(0x03);
    /// Return value or pointer.
    pub const RET: Self = Self(0x0D);
    /// Return value length in bytes.
    pub const RETL: Self = Self(0x0E);
    /// Stack pointer. Memory address on top of current writable stack area (points to
    /// free memory).
    pub const SP: Self = Self(0x05);
    /// Stack start pointer. Memory address of bottom of current writable stack area.
    pub const SSP: Self = Self(0x04);
    /// Smallest writable register.
    pub const WRITABLE: Self = Self(0x10);
    /// Contains zero (0), for convenience.
    pub const ZERO: Self = Self(0x00);

    /// Construct a register ID from the given value.
    ///
    /// The given value will be masked to 6 bits.
    pub const fn new(u: u8) -> Self {
        Self(u & 0b_0011_1111)
    }

    /// A const alternative to the `Into<u8>` implementation.
    pub const fn to_u8(self) -> u8 {
        self.0
    }
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl RegId {
    /// Construct a register ID from the given value.
    ///
    /// Returns `None` if the value is outside the 6-bit value range.
    pub fn new_checked(u: u8) -> Option<RegId> {
        let r = Self::new(u);
        (r.0 == u).then_some(r)
    }
}

#[cfg(feature = "typescript")]
#[wasm_bindgen::prelude::wasm_bindgen]
impl RegId {
    /// Received balance for this context.
    pub fn bal() -> Self {
        Self::BAL
    }

    /// Remaining gas in the context.
    pub fn cgas() -> Self {
        Self::CGAS
    }

    /// Error codes for particular operations.
    pub fn err() -> Self {
        Self::ERR
    }

    /// Flags register.
    pub fn flag() -> Self {
        Self::FLAG
    }

    /// Frame pointer. Memory address of beginning of current call frame.
    pub fn fp() -> Self {
        Self::FP
    }

    /// Remaining gas globally.
    pub fn ggas() -> Self {
        Self::GGAS
    }

    /// Heap pointer. Memory address below the current bottom of the heap (points to free
    /// memory).
    pub fn hp() -> Self {
        Self::HP
    }

    /// Instructions start. Pointer to the start of the currently-executing code.
    pub fn is() -> Self {
        Self::IS
    }

    /// Contains overflow/underflow of addition, subtraction, and multiplication.
    pub fn of() -> Self {
        Self::OF
    }

    /// Contains one (1), for convenience.
    pub fn one() -> Self {
        Self::ONE
    }

    /// The program counter. Memory address of the current instruction.
    pub fn pc() -> Self {
        Self::PC
    }

    /// Return value or pointer.
    pub fn ret() -> Self {
        Self::RET
    }

    /// Return value length in bytes.
    pub fn retl() -> Self {
        Self::RETL
    }

    /// Stack pointer. Memory address on top of current writable stack area (points to
    /// free memory).
    pub fn sp() -> Self {
        Self::SP
    }

    /// Stack start pointer. Memory address of bottom of current writable stack area.
    pub fn spp() -> Self {
        Self::SSP
    }

    /// Smallest writable register.
    pub fn writable() -> Self {
        Self::WRITABLE
    }

    /// Contains zero (0), for convenience.
    pub fn zero() -> Self {
        Self::ZERO
    }

    /// Construct a register ID from the given value.
    ///
    /// The given value will be masked to 6 bits.
    #[wasm_bindgen(constructor)]
    pub fn new_typescript(u: u8) -> Self {
        Self::new(u)
    }

    /// A const alternative to the `Into<u8>` implementation.
    #[wasm_bindgen(js_name = to_u8)]
    pub fn to_u8_typescript(self) -> u8 {
        self.to_u8()
    }
}

impl Imm06 {
    /// Max value for the type
    pub const MAX: Self = Self(0b_0011_1111);

    /// Construct an immediate value.
    ///
    /// The given value will be masked to 6 bits.
    pub const fn new(u: u8) -> Self {
        Self(u & Self::MAX.0)
    }

    /// Construct an immediate value.
    ///
    /// Returns `None` if the value is outside the 6-bit value range.
    pub fn new_checked(u: u8) -> Option<Self> {
        let imm = Self::new(u);
        (imm.0 == u).then_some(imm)
    }

    /// A const alternative to the `Into<u8>` implementation.
    pub const fn to_u8(self) -> u8 {
        self.0
    }
}

impl Imm12 {
    /// Max value for the type
    pub const MAX: Self = Self(0b_0000_1111_1111_1111);

    /// Construct an immediate value.
    ///
    /// The given value will be masked to 12 bits.
    pub const fn new(u: u16) -> Self {
        Self(u & Self::MAX.0)
    }

    /// Construct an immediate value.
    ///
    /// Returns `None` if the value is outside the 12-bit value range.
    pub fn new_checked(u: u16) -> Option<Self> {
        let imm = Self::new(u);
        (imm.0 == u).then_some(imm)
    }

    /// A const alternative to the `Into<u16>` implementation.
    pub const fn to_u16(self) -> u16 {
        self.0
    }
}

impl Imm18 {
    /// Max value for the type
    pub const MAX: Self = Self(0b_0000_0000_0000_0011_1111_1111_1111_1111);

    /// Construct an immediate value.
    ///
    /// The given value will be masked to 18 bits.
    pub const fn new(u: u32) -> Self {
        Self(u & Self::MAX.0)
    }

    /// Construct an immediate value.
    ///
    /// Returns `None` if the value is outside the 18-bit value range.
    pub fn new_checked(u: u32) -> Option<Self> {
        let imm = Self::new(u);
        (imm.0 == u).then_some(imm)
    }

    /// A const alternative to the `Into<u32>` implementation.
    pub const fn to_u32(self) -> u32 {
        self.0
    }
}

impl Imm24 {
    /// Max value for the type
    pub const MAX: Self = Self(0b_0000_0000_1111_1111_1111_1111_1111_1111);

    /// Construct an immediate value.
    ///
    /// The given value will be masked to 24 bits.
    pub const fn new(u: u32) -> Self {
        Self(u & Self::MAX.0)
    }

    /// Construct an immediate value.
    ///
    /// Returns `None` if the value is outside the 24-bit value range.
    pub fn new_checked(u: u32) -> Option<Self> {
        let imm = Self::new(u);
        (imm.0 == u).then_some(imm)
    }

    /// A const alternative to the `Into<u32>` implementation.
    pub const fn to_u32(self) -> u32 {
        self.0
    }
}

impl Opcode {
    /// Check if the opcode is allowed for predicates.
    ///
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/index.md#predicate-verification>
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/instruction-set.md#contract-instructions>
    #[allow(clippy::match_like_matches_macro)]
    pub fn is_predicate_allowed(&self) -> bool {
        use Opcode::*;
        match self {
            ADD | AND | DIV | EQ | EXP | GT | LT | MLOG | MROO | MOD | MOVE | MUL
            | NOT | OR | SLL | SRL | SUB | XOR | WDCM | WQCM | WDOP | WQOP | WDML
            | WQML | WDDV | WQDV | WDMD | WQMD | WDAM | WQAM | WDMM | WQMM | PSHH
            | PSHL | POPH | POPL | RET | ALOC | MCL | MCP | MEQ | ECK1 | ECR1 | ED19
            | K256 | S256 | NOOP | FLAG | ADDI | ANDI | DIVI | EXPI | MODI | MULI
            | MLDV | ORI | SLLI | SRLI | SUBI | XORI | JNEI | LB | LW | SB | SW
            | MCPI | MCLI | GM | MOVI | JNZI | JI | JMP | JNE | JMPF | JMPB | JNZF
            | JNZB | JNEF | JNEB | CFEI | CFSI | CFE | CFS | GTF | LDC | BSIZ | BLDD => {
                true
            }
            _ => false,
        }
    }
}

// Direct conversions

impl From<u8> for RegId {
    fn from(u: u8) -> Self {
        RegId::new(u)
    }
}

impl From<u8> for Imm06 {
    fn from(u: u8) -> Self {
        Imm06::new(u)
    }
}

impl From<u16> for Imm12 {
    fn from(u: u16) -> Self {
        Imm12::new(u)
    }
}

impl From<u32> for Imm18 {
    fn from(u: u32) -> Self {
        Imm18::new(u)
    }
}

impl From<u32> for Imm24 {
    fn from(u: u32) -> Self {
        Imm24::new(u)
    }
}

impl From<RegId> for u8 {
    fn from(RegId(u): RegId) -> Self {
        u
    }
}

impl From<Imm06> for u8 {
    fn from(Imm06(u): Imm06) -> Self {
        u
    }
}

impl From<Imm12> for u16 {
    fn from(Imm12(u): Imm12) -> Self {
        u
    }
}

impl From<Imm18> for u32 {
    fn from(Imm18(u): Imm18) -> Self {
        u
    }
}

impl From<Imm24> for u32 {
    fn from(Imm24(u): Imm24) -> Self {
        u
    }
}

// Lossless, convenience conversions

impl From<RegId> for usize {
    fn from(r: RegId) -> usize {
        u8::from(r).into()
    }
}

impl From<Imm06> for u16 {
    fn from(imm: Imm06) -> Self {
        u8::from(imm).into()
    }
}

impl From<Imm06> for u32 {
    fn from(imm: Imm06) -> Self {
        u8::from(imm).into()
    }
}

impl From<Imm06> for u64 {
    fn from(imm: Imm06) -> Self {
        u8::from(imm).into()
    }
}

impl From<Imm06> for u128 {
    fn from(imm: Imm06) -> Self {
        u8::from(imm).into()
    }
}

impl From<Imm12> for u32 {
    fn from(imm: Imm12) -> Self {
        u16::from(imm).into()
    }
}

impl From<Imm12> for u64 {
    fn from(imm: Imm12) -> Self {
        u16::from(imm).into()
    }
}

impl From<Imm12> for u128 {
    fn from(imm: Imm12) -> Self {
        u16::from(imm).into()
    }
}

impl From<Imm18> for u64 {
    fn from(imm: Imm18) -> Self {
        u32::from(imm).into()
    }
}

impl From<Imm18> for u128 {
    fn from(imm: Imm18) -> Self {
        u32::from(imm).into()
    }
}

impl From<Imm24> for u64 {
    fn from(imm: Imm24) -> Self {
        u32::from(imm).into()
    }
}

impl From<Imm24> for u128 {
    fn from(imm: Imm24) -> Self {
        u32::from(imm).into()
    }
}

impl From<Opcode> for u8 {
    fn from(op: Opcode) -> Self {
        op as u8
    }
}

impl From<Instruction> for RawInstruction {
    fn from(inst: Instruction) -> Self {
        RawInstruction::from_be_bytes(inst.into())
    }
}

impl core::convert::TryFrom<RawInstruction> for Instruction {
    type Error = InvalidOpcode;

    fn try_from(u: RawInstruction) -> Result<Self, Self::Error> {
        Self::try_from(u.to_be_bytes())
    }
}

// Index slices with `RegId`

impl<T> core::ops::Index<RegId> for [T]
where
    [T]: core::ops::Index<usize, Output = T>,
{
    type Output = T;

    fn index(&self, ix: RegId) -> &Self::Output {
        &self[usize::from(ix)]
    }
}

impl<T> core::ops::IndexMut<RegId> for [T]
where
    [T]: core::ops::IndexMut<usize, Output = T>,
{
    fn index_mut(&mut self, ix: RegId) -> &mut Self::Output {
        &mut self[usize::from(ix)]
    }
}

// Collect instructions into bytes or halfwords

#[cfg(feature = "alloc")]
impl core::iter::FromIterator<Instruction> for alloc::vec::Vec<u8> {
    fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self {
        iter.into_iter().flat_map(Instruction::to_bytes).collect()
    }
}

#[cfg(feature = "alloc")]
impl core::iter::FromIterator<Instruction> for alloc::vec::Vec<u32> {
    fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self {
        iter.into_iter().map(u32::from).collect()
    }
}

/// Given an iterator yielding bytes, produces an iterator yielding `Instruction`s.
///
/// This function assumes each consecutive 4 bytes aligns with an instruction.
///
/// The produced iterator yields an `Err` in the case that an instruction fails to parse
/// from 4 consecutive bytes.
pub fn from_bytes<I>(bs: I) -> impl Iterator<Item = Result<Instruction, InvalidOpcode>>
where
    I: IntoIterator<Item = u8>,
{
    let mut iter = bs.into_iter();
    core::iter::from_fn(move || {
        let a = iter.next()?;
        let b = iter.next()?;
        let c = iter.next()?;
        let d = iter.next()?;
        Some(Instruction::try_from([a, b, c, d]))
    })
}

/// Given an iterator yielding u32s (i.e. "half words" or "raw instructions"), produces an
/// iterator yielding `Instruction`s.
///
/// This function assumes each consecutive 4 bytes aligns with an instruction.
///
/// The produced iterator yields an `Err` in the case that an instruction fails to parse.
pub fn from_u32s<I>(us: I) -> impl Iterator<Item = Result<Instruction, InvalidOpcode>>
where
    I: IntoIterator<Item = u32>,
{
    us.into_iter().map(Instruction::try_from)
}

// Short-hand, `panic!`ing constructors for the short-hand instruction construtors (e.g
// op::add).

fn check_imm06(u: u8) -> Imm06 {
    Imm06::new_checked(u)
        .unwrap_or_else(|| panic!("Value `{u}` out of range for 6-bit immediate"))
}

fn check_imm12(u: u16) -> Imm12 {
    Imm12::new_checked(u)
        .unwrap_or_else(|| panic!("Value `{u}` out of range for 12-bit immediate"))
}

fn check_imm18(u: u32) -> Imm18 {
    Imm18::new_checked(u)
        .unwrap_or_else(|| panic!("Value `{u}` out of range for 18-bit immediate"))
}

fn check_imm24(u: u32) -> Imm24 {
    Imm24::new_checked(u)
        .unwrap_or_else(|| panic!("Value `{u}` out of range for 24-bit immediate"))
}

// --------------------------------------------------------

// The size of the instruction isn't larger than necessary.
// 1 byte for the opcode, 3 bytes for registers and immediates.
#[test]
fn test_instruction_size() {
    // NOTE: Throughout `fuel-vm`, we use the `Instruction::SIZE` associated
    // const to refer to offsets within raw instruction data. As a result, it's
    // *essential* that this equivalence remains the same. If you've added
    // a new field or changed the size of `Instruction` somehow and have
    // arrived at this assertion, ensure that you also revisit all sites where
    // `Instruction::SIZE` is used and make sure we're using the right value
    // (in most cases, the right value is `core::mem::size_of::<RawInstruction>()`).
    assert_eq!(
        core::mem::size_of::<Instruction>(),
        core::mem::size_of::<RawInstruction>()
    );

    assert_eq!(core::mem::size_of::<Instruction>(), Instruction::SIZE);
}

// The size of the opcode is exactly one byte.
#[test]
fn test_opcode_size() {
    assert_eq!(core::mem::size_of::<Opcode>(), 1);
}

#[test]
#[allow(clippy::match_like_matches_macro)]
fn check_predicate_allowed() {
    use Opcode::*;
    for byte in 0..u8::MAX {
        if let Ok(repr) = Opcode::try_from(byte) {
            let should_allow = match repr {
                BAL | BHEI | BHSH | BURN | CALL | CB | CCP | CROO | CSIZ | LOG | LOGD
                | MINT | RETD | RVRT | SMO | SCWQ | SRW | SRWQ | SWW | SWWQ | TIME
                | TR | TRO | ECAL => false,
                _ => true,
            };
            assert_eq!(should_allow, repr.is_predicate_allowed());
        }
    }
}

// Test roundtrip conversion for all valid opcodes.
#[test]
fn test_opcode_u8_conv() {
    for u in 0..=u8::MAX {
        if let Ok(op) = Opcode::try_from(u) {
            assert_eq!(op as u8, u);
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-asm/src/unpack.rs

Source
//! Functions for unpacking instruction data from bytes or u32s.

use crate::{
    Imm06,
    Imm12,
    Imm18,
    Imm24,
    RegId,
};

pub(super) fn rd_from_bytes(bs: [u8; 3]) -> RegId {
    rd_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn imm06_from_bytes(bs: [u8; 3]) -> Imm06 {
    imm06_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn imm12_from_bytes(bs: [u8; 3]) -> Imm12 {
    imm12_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn imm18_from_bytes(bs: [u8; 3]) -> Imm18 {
    imm18_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn imm24_from_bytes(bs: [u8; 3]) -> Imm24 {
    imm24_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn ra_rb_from_bytes(bs: [u8; 3]) -> (RegId, RegId) {
    (ra_from_bytes(bs), rb_from_bytes(bs))
}

pub(super) fn ra_rb_rc_from_bytes(bs: [u8; 3]) -> (RegId, RegId, RegId) {
    (ra_from_bytes(bs), rb_from_bytes(bs), rc_from_bytes(bs))
}

pub(super) fn ra_rb_rc_rd_from_bytes(bs: [u8; 3]) -> (RegId, RegId, RegId, RegId) {
    (
        ra_from_bytes(bs),
        rb_from_bytes(bs),
        rc_from_bytes(bs),
        rd_from_bytes(bs),
    )
}

pub(super) fn ra_rb_rc_imm06_from_bytes(bs: [u8; 3]) -> (RegId, RegId, RegId, Imm06) {
    (
        ra_from_bytes(bs),
        rb_from_bytes(bs),
        rc_from_bytes(bs),
        imm06_from_bytes(bs),
    )
}

pub(super) fn ra_rb_imm12_from_bytes(bs: [u8; 3]) -> (RegId, RegId, Imm12) {
    (ra_from_bytes(bs), rb_from_bytes(bs), imm12_from_bytes(bs))
}

pub(super) fn ra_imm18_from_bytes(bs: [u8; 3]) -> (RegId, Imm18) {
    (ra_from_bytes(bs), imm18_from_bytes(bs))
}

#[allow(clippy::cast_possible_truncation)]
fn ra_from_u32(u: u32) -> RegId {
    RegId::new((u >> 18) as u8)
}

#[allow(clippy::cast_possible_truncation)]
fn rb_from_u32(u: u32) -> RegId {
    RegId::new((u >> 12) as u8)
}

#[allow(clippy::cast_possible_truncation)]
fn rc_from_u32(u: u32) -> RegId {
    RegId::new((u >> 6) as u8)
}

#[allow(clippy::cast_possible_truncation)]
fn rd_from_u32(u: u32) -> RegId {
    RegId::new(u as u8)
}

#[allow(clippy::cast_possible_truncation)]
fn imm06_from_u32(u: u32) -> Imm06 {
    Imm06::new(u as u8)
}

#[allow(clippy::cast_possible_truncation)]
fn imm12_from_u32(u: u32) -> Imm12 {
    Imm12::new(u as u16)
}

fn imm18_from_u32(u: u32) -> Imm18 {
    Imm18::new(u)
}

fn imm24_from_u32(u: u32) -> Imm24 {
    Imm24::new(u)
}

pub(super) fn ra_from_bytes(bs: [u8; 3]) -> RegId {
    ra_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn rb_from_bytes(bs: [u8; 3]) -> RegId {
    rb_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

pub(super) fn rc_from_bytes(bs: [u8; 3]) -> RegId {
    rc_from_u32(u32::from_be_bytes(u8x4_from_u8x3(bs)))
}

// Produce the big-endian bytes for an instruction's data, with a zeroed opcode byte.
fn u8x4_from_u8x3([a, b, c]: [u8; 3]) -> [u8; 4] {
    [0, a, b, c]
}

/home/marten/fuel/fuel-vm/fuel-asm/src/pack.rs

Source
//! Functions for packing instruction data into bytes or u32s.

use crate::{
    Imm06,
    Imm12,
    Imm18,
    Imm24,
    RegId,
};

pub(super) fn bytes_from_ra(ra: RegId) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra(ra).to_be_bytes())
}

pub(super) fn bytes_from_ra_rb(ra: RegId, rb: RegId) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra_rb(ra, rb).to_be_bytes())
}

pub(super) fn bytes_from_ra_rb_rc(ra: RegId, rb: RegId, rc: RegId) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra_rb_rc(ra, rb, rc).to_be_bytes())
}

pub(super) fn bytes_from_ra_rb_rc_rd(
    ra: RegId,
    rb: RegId,
    rc: RegId,
    rd: RegId,
) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra_rb_rc_rd(ra, rb, rc, rd).to_be_bytes())
}

pub(super) fn bytes_from_ra_rb_rc_imm06(
    ra: RegId,
    rb: RegId,
    rc: RegId,
    imm: Imm06,
) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra_rb_rc_imm06(ra, rb, rc, imm).to_be_bytes())
}

pub(super) fn bytes_from_ra_rb_imm12(ra: RegId, rb: RegId, imm: Imm12) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra_rb_imm12(ra, rb, imm).to_be_bytes())
}

pub(super) fn bytes_from_ra_imm18(ra: RegId, imm: Imm18) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_ra_imm18(ra, imm).to_be_bytes())
}

pub(super) fn bytes_from_imm24(imm: Imm24) -> [u8; 3] {
    u8x3_from_u8x4(u32_from_imm24(imm).to_be_bytes())
}

fn u32_from_ra(r: RegId) -> u32 {
    (r.0 as u32) << 18
}

fn u32_from_rb(r: RegId) -> u32 {
    (r.0 as u32) << 12
}

fn u32_from_rc(r: RegId) -> u32 {
    (r.0 as u32) << 6
}

fn u32_from_rd(r: RegId) -> u32 {
    r.0 as u32
}

fn u32_from_imm06(imm: Imm06) -> u32 {
    imm.0 as u32
}

fn u32_from_imm12(imm: Imm12) -> u32 {
    imm.0 as u32
}

fn u32_from_imm18(imm: Imm18) -> u32 {
    imm.0
}

fn u32_from_imm24(imm: Imm24) -> u32 {
    imm.0
}

fn u32_from_ra_rb(ra: RegId, rb: RegId) -> u32 {
    u32_from_ra(ra) | u32_from_rb(rb)
}

fn u32_from_ra_rb_rc(ra: RegId, rb: RegId, rc: RegId) -> u32 {
    u32_from_ra_rb(ra, rb) | u32_from_rc(rc)
}

fn u32_from_ra_rb_rc_rd(ra: RegId, rb: RegId, rc: RegId, rd: RegId) -> u32 {
    u32_from_ra_rb_rc(ra, rb, rc) | u32_from_rd(rd)
}

fn u32_from_ra_rb_rc_imm06(ra: RegId, rb: RegId, rc: RegId, imm: Imm06) -> u32 {
    u32_from_ra_rb_rc(ra, rb, rc) | u32_from_imm06(imm)
}

fn u32_from_ra_rb_imm12(ra: RegId, rb: RegId, imm: Imm12) -> u32 {
    u32_from_ra_rb(ra, rb) | u32_from_imm12(imm)
}

fn u32_from_ra_imm18(ra: RegId, imm: Imm18) -> u32 {
    u32_from_ra(ra) | u32_from_imm18(imm)
}

// Ignore the opcode byte, take the remaining instruction data.
fn u8x3_from_u8x4([_, a, b, c]: [u8; 4]) -> [u8; 3] {
    [a, b, c]
}

/home/marten/fuel/fuel-vm/fuel-asm/src/args/wideint.rs

Source
//! Immediate value arguments for wide-math instructions

use crate::Imm06;

/// Comparison mode used by WDCM and WQCM instructions.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::FromRepr)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[repr(u8)]
#[must_use]
pub enum CompareMode {
    /// Equality (`==`)
    EQ = 0,
    /// Inequality (`!=`)
    NE = 1,
    /// Less than (`<`)
    LT = 2,
    /// Greater than (`>`)
    GT = 3,
    /// Less than or equals (`>=`)
    LTE = 4,
    /// Greater than or equals (`>=`)
    GTE = 5,
    /// Number of leading zeroes in lhs (`lzcnt`) (discards rhs)
    LZC = 6,
}

/// Arguments for WDCM and WQCM instructions.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[must_use]
pub struct CompareArgs {
    /// Comparison mode
    pub mode: CompareMode,
    /// Load RHS from register if true, otherwise zero-extend register value
    pub indirect_rhs: bool,
}

#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
impl CompareArgs {
    /// Convert to immediate value.
    pub fn to_imm(self) -> Imm06 {
        let mut bits = self.mode as u8;
        bits |= (self.indirect_rhs as u8) << 5;
        Imm06(bits)
    }

    /// Construct from `Imm06`. Returns `None` if the value has reserved flags set.
    pub fn from_imm(bits: Imm06) -> Option<CompareArgs> {
        let indirect_rhs = ((bits.0 >> 5) & 1) == 1;
        let reserved = (bits.0 >> 3) & 0b11;
        if reserved != 0 {
            return None
        }
        let mode = CompareMode::from_repr(bits.0 & 0b111)?;
        Some(Self { mode, indirect_rhs })
    }
}
/// The operation performed by WDOP and WQOP instructions, determined as
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::FromRepr)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[repr(u8)]
#[must_use]
pub enum MathOp {
    /// Add
    ADD = 0,
    /// Subtract
    SUB = 1,
    /// Invert bits (discards rhs)
    NOT = 2,
    /// Bitwise or
    OR = 3,
    /// Bitwise exclusive or
    XOR = 4,
    /// Bitwise and
    AND = 5,
    /// Shift left
    SHL = 6,
    /// Shift right
    SHR = 7,
}

/// Additional arguments for WDOP and WQOP instructions.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[must_use]
pub struct MathArgs {
    /// The operation to perform
    pub op: MathOp,
    /// Load RHS from register if true, otherwise zero-extend register value
    pub indirect_rhs: bool,
}

impl MathArgs {
    /// Convert to immediate value.
    pub fn to_imm(self) -> Imm06 {
        let mut bits = self.op as u8;
        bits |= (self.indirect_rhs as u8) << 5;
        Imm06(bits)
    }

    /// Construct from `Imm06`. Returns `None` if the value has reserved flags set.
    pub fn from_imm(bits: Imm06) -> Option<Self> {
        let indirect_rhs = ((bits.0 >> 5) & 1) == 1;
        let op = MathOp::from_repr(bits.0 & 0b11111)?;
        Some(Self { op, indirect_rhs })
    }
}

/// Additional arguments for WDML and WQML instructions.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[must_use]
pub struct MulArgs {
    /// Load LHSS from register if true, otherwise zero-extend register value
    pub indirect_lhs: bool,
    /// Load RHS from register if true, otherwise zero-extend register value
    pub indirect_rhs: bool,
}

impl MulArgs {
    /// Convert to immediate value.
    pub fn to_imm(self) -> Imm06 {
        let mut bits = 0u8;
        bits |= (self.indirect_lhs as u8) << 4;
        bits |= (self.indirect_rhs as u8) << 5;
        Imm06(bits)
    }

    /// Construct from `Imm06`. Returns `None` if the value has reserved flags set.
    pub fn from_imm(bits: Imm06) -> Option<Self> {
        let indirect_lhs = ((bits.0 >> 4) & 1) == 1;
        let indirect_rhs = ((bits.0 >> 5) & 1) == 1;
        if (bits.0 & 0b1111) != 0 {
            return None
        }
        Some(Self {
            indirect_lhs,
            indirect_rhs,
        })
    }
}

/// Additional arguments for WMDV and WDDV instructions.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[must_use]
pub struct DivArgs {
    /// Load RHS from register if true, otherwise zero-extend register value
    pub indirect_rhs: bool,
}

impl DivArgs {
    /// Convert to immediate value.
    pub fn to_imm(self) -> Imm06 {
        let mut bits = 0u8;
        bits |= (self.indirect_rhs as u8) << 5;
        Imm06(bits)
    }

    /// Construct from `Imm06`. Returns `None` if the value has reserved flags set.
    pub fn from_imm(bits: Imm06) -> Option<Self> {
        let indirect_rhs = ((bits.0 >> 5) & 1) == 1;
        if (bits.0 & 0b11111) != 0 {
            return None
        }
        Some(Self { indirect_rhs })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[rstest::rstest]
    fn encode_decode_compare(
        #[values(CompareMode::EQ, CompareMode::NE, CompareMode::GTE)] mode: CompareMode,
        #[values(true, false)] indirect_rhs: bool,
    ) {
        let orig = CompareArgs { mode, indirect_rhs };
        let decoded = CompareArgs::from_imm(orig.to_imm()).expect("decode error");
        assert_eq!(orig, decoded);
    }

    #[test]
    fn decode_encode_compare() {
        for imm in 0..Imm06::MAX.0 {
            let bits = Imm06::from(imm);
            if let Some(decoded) = CompareArgs::from_imm(bits) {
                assert_eq!(decoded.to_imm().0, imm);
            }
        }
    }

    #[rstest::rstest]
    fn encode_decode_mathop(
        #[values(MathOp::ADD, MathOp::SUB, MathOp::SHR)] op: MathOp,
        #[values(true, false)] indirect_rhs: bool,
    ) {
        let orig = MathArgs { op, indirect_rhs };
        let decoded = MathArgs::from_imm(orig.to_imm()).expect("decode error");
        assert_eq!(orig, decoded);
    }

    #[test]
    fn decode_encode_mathop() {
        for imm in 0..Imm06::MAX.0 {
            let bits = Imm06::from(imm);
            if let Some(decoded) = MathArgs::from_imm(bits) {
                assert_eq!(decoded.to_imm().0, imm);
            }
        }
    }

    #[rstest::rstest]
    fn encode_decode_mul(
        #[values(true, false)] indirect_lhs: bool,
        #[values(true, false)] indirect_rhs: bool,
    ) {
        let orig = MulArgs {
            indirect_lhs,
            indirect_rhs,
        };
        let decoded = MulArgs::from_imm(orig.to_imm()).expect("decode error");
        assert_eq!(orig, decoded);
    }

    #[test]
    fn decode_encode_mul() {
        for imm in 0..Imm06::MAX.0 {
            let bits = Imm06::from(imm);
            if let Some(decoded) = MulArgs::from_imm(bits) {
                assert_eq!(decoded.to_imm().0, imm);
            }
        }
    }

    #[rstest::rstest]
    fn encode_decode_div(#[values(true, false)] indirect_rhs: bool) {
        let orig = DivArgs { indirect_rhs };
        let decoded = DivArgs::from_imm(orig.to_imm()).expect("decode error");
        assert_eq!(orig, decoded);
    }

    #[test]
    fn decode_encode_div() {
        for imm in 0..Imm06::MAX.0 {
            let bits = Imm06::from(imm);
            if let Some(decoded) = DivArgs::from_imm(bits) {
                assert_eq!(decoded.to_imm().0, imm);
            }
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-asm/src/macros.rs

Source
//! # The `impl_instructions!` macro
//!
//! The heart of this crate's implementation is the private `impl_instructions!` macro.
//! This macro is used to generate the `Instruction` and `Opcode` types along with their
//! implementations.
//!
//! The intention is to allow for having a single source of truth from which each of the
//! instruction-related types and implementations are derived.
//!
//! Its usage looks like this:
//!
//! ```rust,ignore
//! impl_instructions! {
//!     "Adds two registers."
//!     0x10 ADD add [RegId RegId RegId]
//!     "Bitwise ANDs two registers."
//!     0x11 AND and [RegId RegId RegId]
//!     // ...
//! }
//! ```
//!
//! Each instruction's row includes:
//!
//! - A short docstring.
//! - The Opcode byte value.
//! - An uppercase identifier (for generating variants and types).
//! - A lowercase identifier (for generating the shorthand instruction constructor).
//! - The instruction layout (for the `new` and `unpack` functions).
//!
//! The following sections describe each of the items that are derived from the
//! `impl_instructions!` table in more detail.
//!
//! ## The `Opcode` enum
//!
//! Represents the bytecode portion of an instruction.
//!
//! ```rust,ignore
//! /// Solely the opcode portion of an instruction represented as a single byte.
//! #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
//! #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
//! #[repr(u8)]
//! pub enum Opcode {
//!     /// Adds two registers.
//!     ADD = 0x10,
//!     /// Bitwise ANDs two registers.
//!     AND = 0x11,
//!     // ...
//! }
//! ```
//!
//! A `TryFrom<u8>` implementation is also provided, producing an `Err(InvalidOpcode)` in
//! the case that the byte represents a reserved or undefined value.
//!
//! ```rust
//! # use fuel_asm::{InvalidOpcode, Opcode};
//! assert_eq!(Opcode::try_from(0x10), Ok(Opcode::ADD));
//! assert_eq!(Opcode::try_from(0x11), Ok(Opcode::AND));
//! assert_eq!(Opcode::try_from(0), Err(InvalidOpcode));
//! ```
//!
//! ## The `Instruction` enum
//!
//! Represents a single, full instruction, discriminated by its `Opcode`.
//!
//! ```rust,ignore
//! /// Representation of a single instruction for the interpreter.
//! ///
//! /// The opcode is represented in the tag (variant), or may be retrieved in the form of an
//! /// `Opcode` byte using the `opcode` method.
//! ///
//! /// The register and immediate data associated with the instruction is represented within
//! /// an inner unit type wrapper around the 3 remaining bytes.
//! #[derive(Clone, Copy, Eq, Hash, PartialEq)]
//! #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
//! pub enum Instruction {
//!     /// Adds two registers.
//!     ADD(op::ADD),
//!     /// Bitwise ANDs two registers.
//!     AND(op::AND),
//!     // ...
//! }
//! ```
//!
//! The `From<Instruction> for u32` (aka `RawInstruction`) and `TryFrom<u32> for
//! Instruction` implementations can be found in the crate root.
//!
//! ## A unique unit type per operation
//!
//! In order to reduce the likelihood of misusing unrelated register IDs or immediate
//! values, we generate a unique unit type for each type of operation (i.e instruction
//! variant) and guard access to the relevant register IDs and immediate values behind
//! each type's unique methods.
//!
//! These unique operation types are generated as follows within a dedicated `op` module:
//!
//! ```rust,ignore
//! pub mod op {
//!     //! Definitions and implementations for each unique instruction type, one for each
//!     //! unique `Opcode` variant.
//!
//!     // A unique type for each operation.
//!
//!     /// Adds two registers.
//!     pub struct ADD([u8; 3]);
//!
//!     /// Bitwise ANDs two registers.
//!     pub struct AND([u8; 3]);
//!
//!     // ...
//!
//!     // An implementation for each unique type.
//!
//!     impl ADD {
//!         pub const OPCODE: Opcode = Opcode::ADD;
//!
//!         /// Construct the instruction from its parts.
//!         pub fn new(ra: RegId, rb: RegId, rc: RegId) -> Self {
//!             Self(pack::bytes_from_ra_rb_rc(ra, rb, rc))
//!         }
//!
//!         /// Convert the instruction into its parts.
//!         pub fn unpack(self) -> (RegId, RegId, RegId) {
//!             unpack::ra_rb_rc_from_bytes(self.0)
//!         }
//!     }
//!
//!     impl AND {
//!         // ...
//!     }
//!
//!     // ...
//!
//!     // A short-hand `Instruction` constructor for each operation to make it easier to
//!     // hand-write assembly for tests and benchmarking. As these constructors are public and
//!     // accept literal values, we check that the values are within range.
//!
//!     /// Adds two registers.
//!     pub fn add(ra: u8, rb: u8, rc: u8) -> Instruction {
//!         ADD::new(check_reg_id(ra), check_reg_id(rb), check_reg_id(rc)).into()
//!     }
//!
//!     /// Bitwise ANDs two registers.
//!     pub fn and(ra: u8, rb: u8, rc: u8) -> Instruction {
//!         AND::new(check_reg_id(ra), check_reg_id(rb), check_reg_id(rc)).into()
//!     }
//!
//!     // ...
//! };
//! ```
//!
//! ### Instruction Layout
//!
//! The function signatures of the `new` and `unpack` functions are derived from the
//! instruction's data layout described in the `impl_instructions!` table.
//!
//! For example, the `unpack` method for `ADD` looks like this:
//!
//! ```rust,ignore
//! // 0x10 ADD add [RegId RegId RegId]
//! pub fn unpack(self) -> (RegId, RegId, RegId)
//! ```
//!
//! While the `unpack` method for `ADDI` looks like this:
//!
//! ```rust,ignore
//! // 0x50 ADDI addi [RegId RegId Imm12]
//! pub fn unpack(self) -> (RegId, RegId, Imm12)
//! ```
//!
//! ### Shorthand Constructors
//!
//! The shorthand instruction constructors (e.g. `add`, `and`, etc) are specifically
//! designed to make it easier to handwrite assembly for tests or benchmarking. Unlike the
//! `$OP::new` constructors which require typed register ID or immediate inputs, the
//! instruction constructors allow for constructing `Instruction`s from convenient literal
//! value inputs. E.g.
//!
//! ```rust
//! use fuel_asm::{op, Instruction};
//!
//! // A sample program to perform ecrecover
//! let program: Vec<Instruction> = vec![
//!     op::move_(0x10, 0x01),     // set r[0x10] := $one
//!     op::slli(0x20, 0x10, 5),   // set r[0x20] := `r[0x10] << 5 == 32`
//!     op::slli(0x21, 0x10, 6),   // set r[0x21] := `r[0x10] << 6 == 64`
//!     op::aloc(0x21),            // alloc `r[0x21] == 64` to the heap
//!     op::addi(0x10, 0x07, 1),   // set r[0x10] := `$hp + 1` (allocated heap)
//!     op::move_(0x11, 0x04),     // set r[0x11] := $ssp
//!     op::add(0x12, 0x04, 0x20), // set r[0x12] := `$ssp + r[0x20]`
//!     op::eck1(0x10, 0x11, 0x12),// recover public key in memory[r[0x10], 64]
//!     op::ret(0x01),             // return `1`
//! ];
//! ```

// Generate a shorthand free function named after the $op for constructing an
// `Instruction`.
macro_rules! op_constructor {
    ($doc:literal $Op:ident $op:ident[$ra:ident : RegId]) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId>($ra: A) -> Instruction {
            $Op::new($ra.check()).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8) -> typescript::Instruction {
                crate::op::$op($ra).into()
            }
        };
    };
    ($doc:literal $Op:ident $op:ident[$ra:ident : RegId $rb:ident : RegId]) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId, B: CheckRegId>($ra: A, $rb: B) -> Instruction {
            $Op::new($ra.check(), $rb.check()).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8, $rb: u8) -> typescript::Instruction {
                crate::op::$op($ra, $rb).into()
            }
        };
    };
    (
        $doc:literal
        $Op:ident
        $op:ident[$ra:ident : RegId $rb:ident : RegId $rc:ident : RegId]
    ) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
            $ra: A,
            $rb: B,
            $rc: C,
        ) -> Instruction {
            $Op::new($ra.check(), $rb.check(), $rc.check()).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8, $rb: u8, $rc: u8) -> typescript::Instruction {
                crate::op::$op($ra, $rb, $rc).into()
            }
        };
    };
    (
        $doc:literal
        $Op:ident
        $op:ident[$ra:ident : RegId $rb:ident : RegId $rc:ident : RegId $rd:ident : RegId]
    ) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId, B: CheckRegId, C: CheckRegId, D: CheckRegId>(
            $ra: A,
            $rb: B,
            $rc: C,
            $rd: D,
        ) -> Instruction {
            $Op::new($ra.check(), $rb.check(), $rc.check(), $rd.check()).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8, $rb: u8, $rc: u8, $rd: u8) -> typescript::Instruction {
                crate::op::$op($ra, $rb, $rc, $rd).into()
            }
        };
    };
    (
        $doc:literal
        $Op:ident
        $op:ident[$ra:ident : RegId $rb:ident : RegId $rc:ident : RegId $imm:ident : Imm06]
    ) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId, B: CheckRegId, C: CheckRegId>(
            $ra: A,
            $rb: B,
            $rc: C,
            $imm: u8,
        ) -> Instruction {
            $Op::new($ra.check(), $rb.check(), $rc.check(), check_imm06($imm)).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8, $rb: u8, $rc: u8, $imm: u8) -> typescript::Instruction {
                crate::op::$op($ra, $rb, $rc, $imm).into()
            }
        };
    };
    (
        $doc:literal
        $Op:ident
        $op:ident[$ra:ident : RegId $rb:ident : RegId $imm:ident : Imm12]
    ) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId, B: CheckRegId>(
            $ra: A,
            $rb: B,
            $imm: u16,
        ) -> Instruction {
            $Op::new($ra.check(), $rb.check(), check_imm12($imm)).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8, $rb: u8, $imm: u16) -> typescript::Instruction {
                crate::op::$op($ra, $rb, $imm).into()
            }
        };
    };
    ($doc:literal $Op:ident $op:ident[$ra:ident : RegId $imm:ident : Imm18]) => {
        #[doc = $doc]
        pub fn $op<A: CheckRegId>($ra: A, $imm: u32) -> Instruction {
            $Op::new($ra.check(), check_imm18($imm)).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($ra: u8, $imm: u32) -> typescript::Instruction {
                crate::op::$op($ra, $imm).into()
            }
        };
    };
    ($doc:literal $Op:ident $op:ident[$imm:ident : Imm24]) => {
        #[doc = $doc]
        pub fn $op($imm: u32) -> Instruction {
            $Op::new(check_imm24($imm)).into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op($imm: u32) -> typescript::Instruction {
                crate::op::$op($imm).into()
            }
        };
    };
    ($doc:literal $Op:ident $op:ident[]) => {
        #[doc = $doc]
        pub fn $op() -> Instruction {
            $Op::new().into()
        }

        #[cfg(feature = "typescript")]
        const _: () = {
            use super::*;

            #[wasm_bindgen::prelude::wasm_bindgen]
            #[doc = $doc]
            pub fn $op() -> typescript::Instruction {
                crate::op::$op().into()
            }
        };
    };
}

// Generate approriate `new` constructor for the instruction
macro_rules! op_new {
    // Generate a constructor based on the field layout.
    ($Op:ident $ra:ident : RegId) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId) -> Self {
                Self(pack::bytes_from_ra($ra))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript($ra: RegId) -> Self {
                Self::new($ra)
            }
        }
    };
    ($Op:ident $ra:ident : RegId $rb:ident : RegId) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId, $rb: RegId) -> Self {
                Self(pack::bytes_from_ra_rb($ra, $rb))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript($ra: RegId, $rb: RegId) -> Self {
                Self::new($ra, $rb)
            }
        }
    };
    ($Op:ident $ra:ident : RegId $rb:ident : RegId $rc:ident : RegId) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId, $rb: RegId, $rc: RegId) -> Self {
                Self(pack::bytes_from_ra_rb_rc($ra, $rb, $rc))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript($ra: RegId, $rb: RegId, $rc: RegId) -> Self {
                Self::new($ra, $rb, $rc)
            }
        }
    };
    (
        $Op:ident $ra:ident : RegId $rb:ident : RegId $rc:ident : RegId $rd:ident : RegId
    ) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId, $rb: RegId, $rc: RegId, $rd: RegId) -> Self {
                Self(pack::bytes_from_ra_rb_rc_rd($ra, $rb, $rc, $rd))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript(
                $ra: RegId,
                $rb: RegId,
                $rc: RegId,
                $rd: RegId,
            ) -> Self {
                Self::new($ra, $rb, $rc, $rd)
            }
        }
    };
    (
        $Op:ident
        $ra:ident : RegId
        $rb:ident : RegId
        $rc:ident : RegId
        $imm:ident : Imm06
    ) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId, $rb: RegId, $rc: RegId, $imm: Imm06) -> Self {
                Self(pack::bytes_from_ra_rb_rc_imm06($ra, $rb, $rc, $imm))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript(
                $ra: RegId,
                $rb: RegId,
                $rc: RegId,
                $imm: Imm06,
            ) -> Self {
                Self::new($ra, $rb, $rc, $imm)
            }
        }
    };
    ($Op:ident $ra:ident : RegId $rb:ident : RegId $imm:ident : Imm12) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId, $rb: RegId, $imm: Imm12) -> Self {
                Self(pack::bytes_from_ra_rb_imm12($ra, $rb, $imm))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript($ra: RegId, $rb: RegId, $imm: Imm12) -> Self {
                Self::new($ra, $rb, $imm)
            }
        }
    };
    ($Op:ident $ra:ident : RegId $imm:ident : Imm18) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($ra: RegId, $imm: Imm18) -> Self {
                Self(pack::bytes_from_ra_imm18($ra, $imm))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript($ra: RegId, $imm: Imm18) -> Self {
                Self::new($ra, $imm)
            }
        }
    };
    ($Op:ident $imm:ident : Imm24) => {
        impl $Op {
            /// Construct the instruction from its parts.
            pub fn new($imm: Imm24) -> Self {
                Self(pack::bytes_from_imm24($imm))
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction from its parts.
            pub fn new_typescript($imm: Imm24) -> Self {
                Self::new($imm)
            }
        }
    };
    ($Op:ident) => {
        impl $Op {
            /// Construct the instruction.
            #[allow(clippy::new_without_default)]
            pub fn new() -> Self {
                Self([0; 3])
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $Op {
            #[wasm_bindgen(constructor)]
            /// Construct the instruction.
            #[allow(clippy::new_without_default)]
            pub fn new_typescript() -> Self {
                Self::new()
            }
        }
    };
}

// Generate an accessor method for each field. Recurse based on layout.
macro_rules! op_accessors {
    ($Op:ident $ra:ident: RegId) => {
        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the ID for register A.
            pub fn ra(&self) -> RegId {
                unpack::ra_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: RegId $rb:ident: RegId) => {
        op_accessors!($Op ra: RegId);

        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the ID for register B.
            pub fn rb(&self) -> RegId {
                unpack::rb_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: RegId $rb:ident: RegId $rc:ident: RegId) => {
        op_accessors!($Op $ra: RegId $rb: RegId);

        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the ID for register C.
            pub fn rc(&self) -> RegId {
                unpack::rc_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: RegId $rb:ident: RegId $rc:ident: RegId $rd:ident: RegId) => {
        op_accessors!($Op $ra: RegId $rb: RegId $rc: RegId);

        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the ID for register D.
            pub fn rd(&self) -> RegId {
                unpack::rd_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: RegId $rb:ident: RegId $rc:ident: RegId $imm:ident: Imm06) => {
        op_accessors!($Op $ra: RegId rb: RegId $rc: RegId);

        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the 6-bit immediate value.
            pub fn imm06(&self) -> Imm06 {
                unpack::imm06_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: RegId $rb:ident: RegId $imm:ident: Imm12) => {
        op_accessors!($Op $ra: RegId $rb: RegId);

        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the 12-bit immediate value.
            pub fn imm12(&self) -> Imm12 {
                unpack::imm12_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: RegId $imm:ident: Imm18) => {
        op_accessors!($Op $ra: RegId);

        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the 18-bit immediate value.
            pub fn imm18(&self) -> Imm18 {
                unpack::imm18_from_bytes(self.0)
            }
        }
    };
    ($Op:ident $ra:ident: Imm24) => {
        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        impl $Op {
            /// Access the 24-bit immediate value.
            pub fn imm24(&self) -> Imm24 {
                unpack::imm24_from_bytes(self.0)
            }
        }
    };
    ($Op:ident) => {};
}

// Generate a method for converting the instruction into its parts.
macro_rules! op_unpack {
    (RegId) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> RegId {
            unpack::ra_from_bytes(self.0)
        }
    };
    (RegId RegId) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> (RegId, RegId) {
            unpack::ra_rb_from_bytes(self.0)
        }
    };
    (RegId RegId RegId) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> (RegId, RegId, RegId) {
            unpack::ra_rb_rc_from_bytes(self.0)
        }
    };
    (RegId RegId RegId RegId) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> (RegId, RegId, RegId, RegId) {
            unpack::ra_rb_rc_rd_from_bytes(self.0)
        }
    };
    (RegId RegId RegId Imm06) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> (RegId, RegId, RegId, Imm06) {
            unpack::ra_rb_rc_imm06_from_bytes(self.0)
        }
    };
    (RegId RegId Imm12) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> (RegId, RegId, Imm12) {
            unpack::ra_rb_imm12_from_bytes(self.0)
        }
    };
    (RegId Imm18) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> (RegId, Imm18) {
            unpack::ra_imm18_from_bytes(self.0)
        }
    };
    (Imm24) => {
        /// Convert the instruction into its parts.
        pub fn unpack(self) -> Imm24 {
            unpack::imm24_from_bytes(self.0)
        }
    };
    () => {};
}

// Generate a method for checking that the reserved part of the
// instruction is zero. This is private, as invalid instructions
// cannot be constructed outside this crate.
macro_rules! op_reserved_part {
    (RegId) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            let (_, imm) = unpack::ra_imm18_from_bytes(self.0);
            imm.0 == 0
        }
    };
    (RegId RegId) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            let (_, _, imm) = unpack::ra_rb_imm12_from_bytes(self.0);
            imm.0 == 0
        }
    };
    (RegId RegId RegId) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            let (_, _, _, imm) = unpack::ra_rb_rc_imm06_from_bytes(self.0);
            imm.0 == 0
        }
    };
    (RegId RegId RegId RegId) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            true
        }
    };
    (RegId RegId RegId Imm06) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            true
        }
    };
    (RegId RegId Imm12) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            true
        }
    };
    (RegId Imm18) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            true
        }
    };
    (Imm24) => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            true
        }
    };
    () => {
        pub(crate) fn reserved_part_is_zero(self) -> bool {
            self.0 == [0; 3]
        }
    };
}

// Generate a private fn for use within the `Instruction::reg_ids` implementation.
macro_rules! op_reg_ids {
    (RegId) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let ra = self.unpack();
            [Some(ra), None, None, None]
        }
    };
    (RegId RegId) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let (ra, rb) = self.unpack();
            [Some(ra), Some(rb), None, None]
        }
    };
    (RegId RegId RegId) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let (ra, rb, rc) = self.unpack();
            [Some(ra), Some(rb), Some(rc), None]
        }
    };
    (RegId RegId RegId RegId) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let (ra, rb, rc, rd) = self.unpack();
            [Some(ra), Some(rb), Some(rc), Some(rd)]
        }
    };
    (RegId RegId RegId Imm06) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let (ra, rb, rc, _) = self.unpack();
            [Some(ra), Some(rb), Some(rc), None]
        }
    };
    (RegId RegId Imm12) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let (ra, rb, _) = self.unpack();
            [Some(ra), Some(rb), None, None]
        }
    };
    (RegId Imm18) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            let (ra, _) = self.unpack();
            [Some(ra), None, None, None]
        }
    };
    ($($rest:tt)*) => {
        pub(super) fn reg_ids(&self) -> [Option<RegId>; 4] {
            [None; 4]
        }
    };
}

// Generate test constructors that can be used to generate instructions from non-matching
// input.
#[cfg(test)]
macro_rules! op_test_construct_fn {
    (RegId) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            _rb: RegId,
            _rc: RegId,
            _rd: RegId,
            _imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra(ra))
        }
    };
    (RegId RegId) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            rb: RegId,
            _rc: RegId,
            _rd: RegId,
            _imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra_rb(ra, rb))
        }
    };
    (RegId RegId RegId) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            rb: RegId,
            rc: RegId,
            _rd: RegId,
            _imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra_rb_rc(ra, rb, rc))
        }
    };
    (RegId RegId RegId RegId) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            rb: RegId,
            rc: RegId,
            rd: RegId,
            _imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra_rb_rc_rd(ra, rb, rc, rd))
        }
    };
    (RegId RegId RegId Imm06) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            rb: RegId,
            rc: RegId,
            _rd: RegId,
            imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra_rb_rc_imm06(
                ra,
                rb,
                rc,
                Imm06::from(imm as u8),
            ))
        }
    };
    (RegId RegId Imm12) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            rb: RegId,
            _rc: RegId,
            _rd: RegId,
            imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra_rb_imm12(
                ra,
                rb,
                Imm12::from(imm as u16),
            ))
        }
    };
    (RegId Imm18) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            ra: RegId,
            _rb: RegId,
            _rc: RegId,
            _rd: RegId,
            imm: u32,
        ) -> Self {
            Self(pack::bytes_from_ra_imm18(ra, Imm18::from(imm)))
        }
    };
    (Imm24) => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        pub fn test_construct(
            _ra: RegId,
            _rb: RegId,
            _rc: RegId,
            _rd: RegId,
            imm: u32,
        ) -> Self {
            Self(pack::bytes_from_imm24(Imm24::from(imm)))
        }
    };
    () => {
        /// Construct the instruction from all possible raw fields, ignoring inapplicable
        /// ones.
        #[allow(clippy::new_without_default)]
        pub fn test_construct(
            _ra: RegId,
            _rb: RegId,
            _rc: RegId,
            _rd: RegId,
            _imm: u32,
        ) -> Self {
            Self([0; 3])
        }
    };
}

// Debug implementations for each instruction.
macro_rules! op_debug_fmt {
    ($Op:ident[$ra:ident : RegId]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let ra = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .finish()
        }
    };
    ($Op:ident[$ra:ident : RegId $rb:ident : RegId]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let (ra, rb) = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .field(stringify!($rb), &format_args!("{:#02x}", u8::from(rb)))
                .finish()
        }
    };
    ($Op:ident[$ra:ident : RegId $rb:ident : RegId $rc:ident : RegId]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let (ra, rb, rc) = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .field(stringify!($rb), &format_args!("{:#02x}", u8::from(rb)))
                .field(stringify!($rc), &format_args!("{:#02x}", u8::from(rc)))
                .finish()
        }
    };
    (
        $Op:ident[$ra:ident : RegId $rb:ident : RegId $rc:ident : RegId $rd:ident : RegId]
    ) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let (ra, rb, rc, rd) = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .field(stringify!($rb), &format_args!("{:#02x}", u8::from(rb)))
                .field(stringify!($rc), &format_args!("{:#02x}", u8::from(rc)))
                .field(stringify!($rd), &format_args!("{:#02x}", u8::from(rd)))
                .finish()
        }
    };
    (
        $Op:ident[$ra:ident : RegId $rb:ident : RegId $rc:ident : RegId $imm:ident : Imm06]
    ) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let (ra, rb, rc, imm) = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .field(stringify!($rb), &format_args!("{:#02x}", u8::from(rb)))
                .field(stringify!($rc), &format_args!("{:#02x}", u8::from(rc)))
                .field(stringify!($imm), &u8::from(imm))
                .finish()
        }
    };
    ($Op:ident[$ra:ident : RegId $rb:ident : RegId $imm:ident : Imm12]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let (ra, rb, imm) = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .field(stringify!($rb), &format_args!("{:#02x}", u8::from(rb)))
                .field(stringify!($imm), &u16::from(imm))
                .finish()
        }
    };
    ($Op:ident[$ra:ident : RegId $imm:ident : Imm18]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let (ra, imm) = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($ra), &format_args!("{:#02x}", u8::from(ra)))
                .field(stringify!($imm), &u32::from(imm))
                .finish()
        }
    };
    ($Op:ident[$imm:ident : Imm24]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            let imm = self.unpack();
            f.debug_struct(stringify!($Op))
                .field(stringify!($imm), &u32::from(imm))
                .finish()
        }
    };
    ($Op:ident[]) => {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            f.debug_struct(stringify!($Op)).finish()
        }
    };
}

// Recursively declares a unique struct for each opcode.
macro_rules! decl_op_struct {
    ($doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*] $($rest:tt)*) => {
        #[doc = $doc]
        #[derive(Clone, Copy, Eq, Hash, PartialEq)]
        #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        pub struct $Op(pub (super) [u8; 3]);
        decl_op_struct!($($rest)*);
    };
    () => {};
}

/// This macro is intentionaly private. See the module-level documentation for a thorough
/// explanation of how this macro works.
macro_rules! impl_instructions {
    // Define the `Opcode` enum.
    (decl_opcode_enum $($doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*])*) => {
        /// Solely the opcode portion of an instruction represented as a single byte.
        #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
        #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
        #[repr(u8)]
        pub enum Opcode {
            $(
                #[doc = $doc]
                $Op = $ix,
            )*
        }
    };

    // Define the `Instruction` enum.
    (decl_instruction_enum $($doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*])*) => {
        /// Representation of a single instruction for the interpreter.
        ///
        /// The opcode is represented in the tag (variant), or may be retrieved in the form of an
        /// `Opcode` byte using the `opcode` method.
        ///
        /// The register and immediate data associated with the instruction is represented within
        /// an inner unit type wrapper around the 3 remaining bytes.
        #[derive(Clone, Copy, Eq, Hash, PartialEq)]
        #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
        pub enum Instruction {
            $(
                #[doc = $doc]
                $Op(op::$Op),
            )*
        }
    };

    // Recursively generate a test constructor for each opcode
    (impl_opcode_test_construct $doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*] $($rest:tt)*) => {
        #[cfg(test)]
        #[allow(clippy::cast_possible_truncation)]
        impl crate::_op::$Op {
            op_test_construct_fn!($($field)*);
        }
        impl_instructions!(impl_opcode_test_construct $($rest)*);
    };
    (impl_opcode_test_construct) => {};

    // Recursively generate a test constructor for each opcode
    (tests $doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*] $($rest:tt)*) => {
        op_test!($Op $op [$($field)*]);
        impl_instructions!(tests $($rest)*);
    };
    (tests) => {};

    // Implement constructors and accessors for register and immediate values.
    (impl_op $doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*] $($rest:tt)*) => {
        impl $Op {
            /// The associated 8-bit Opcode value.
            pub const OPCODE: Opcode = Opcode::$Op;
        }

        op_new!($Op $($fname: $field)*);
        op_accessors!($Op $($fname: $field)*);

        impl $Op {
            op_unpack!($($field)*);
            op_reserved_part!($($field)*);
            op_reg_ids!($($field)*);
        }

        op_constructor!($doc $Op $op [$($fname: $field)*]);

        impl From<$Op> for [u8; 3] {
            fn from($Op(arr): $Op) -> Self {
                arr
            }
        }

        impl From<$Op> for [u8; 4] {
            fn from($Op([a, b, c]): $Op) -> Self {
                [$Op::OPCODE as u8, a, b, c]
            }
        }

        impl From<$Op> for u32 {
            fn from(op: $Op) -> Self {
                u32::from_be_bytes(op.into())
            }
        }

        impl From<$Op> for Instruction {
            fn from(op: $Op) -> Self {
                Instruction::$Op(op)
            }
        }

        #[cfg(feature = "typescript")]
        impl From<$Op> for typescript::Instruction {
            fn from(opcode: $Op) -> Self {
                typescript::Instruction::new(opcode.into())
            }
        }

        impl core::fmt::Debug for $Op {
            op_debug_fmt!($Op [$($fname: $field)*]);
        }

        impl_instructions!(impl_op $($rest)*);
    };
    (impl_op) => {};

    // Implement functions for all opcode variants
    (impl_opcode $($doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*])*) => {
        impl core::convert::TryFrom<u8> for Opcode {
            type Error = InvalidOpcode;
            fn try_from(u: u8) -> Result<Self, Self::Error> {
                match u {
                    $(
                        $ix => Ok(Opcode::$Op),
                    )*
                    _ => Err(InvalidOpcode),
                }
            }
        }

        impl Opcode {
            /// Construct the instruction from all possible raw fields, ignoring inapplicable ones.
            #[cfg(test)]
            pub fn test_construct(self, ra: RegId, rb: RegId, rc: RegId, rd: RegId, imm: u32) -> Instruction {
                match self {
                    $(
                        Self::$Op => Instruction::$Op(crate::_op::$Op::test_construct(ra, rb, rc, rd, imm)),
                    )*
                }
            }
        }
    };

    // Implement accessors for register and immediate values.
    (impl_instruction $($doc:literal $ix:literal $Op:ident $op:ident [$($fname:ident: $field:ident)*])*) => {
        impl Instruction {
            /// This instruction's opcode.
            pub fn opcode(&self) -> Opcode {
                match self {
                    $(
                        Self::$Op(_) => Opcode::$Op,
                    )*
                }
            }

            /// Unpacks all register IDs into a slice of options.
            pub fn reg_ids(&self) -> [Option<RegId>; 4] {
                match self {
                    $(
                        Self::$Op(op) => op.reg_ids(),
                    )*
                }
            }
        }

        impl From<Instruction> for [u8; 4] {
            fn from(inst: Instruction) -> Self {
                match inst {
                    $(
                        Instruction::$Op(op) => op.into(),
                    )*
                }
            }
        }

        #[cfg(feature = "typescript")]
        impl From<Instruction> for typescript::Instruction {
            fn from(inst: Instruction) -> Self {
                typescript::Instruction::new(inst)
            }
        }

        impl core::convert::TryFrom<[u8; 4]> for Instruction {
            type Error = InvalidOpcode;
            fn try_from([op, a, b, c]: [u8; 4]) -> Result<Self, Self::Error> {
                match Opcode::try_from(op)? {
                    $(
                        Opcode::$Op => Ok(Self::$Op({
                            let op = op::$Op([a, b, c]);
                            if !op.reserved_part_is_zero() {
                                return Err(InvalidOpcode);
                            }
                            op
                        })),
                    )*
                }
            }
        }

        impl core::fmt::Debug for Instruction {
            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                match self {
                    $(
                        Self::$Op(op) => op.fmt(f),
                    )*
                }
            }
        }
    };

    // Entrypoint to the macro, generates structs, methods, opcode enum and instruction enum
    // separately.
    ($($tts:tt)*) => {
        mod _op {
            use super::*;
            decl_op_struct!($($tts)*);
            impl_instructions!(impl_op $($tts)*);
        }
        impl_instructions!(decl_opcode_enum $($tts)*);
        impl_instructions!(decl_instruction_enum $($tts)*);
        impl_instructions!(impl_opcode $($tts)*);
        impl_instructions!(impl_instruction $($tts)*);
        impl_instructions!(impl_opcode_test_construct $($tts)*);


        #[cfg(test)]
        mod opcode_tests {
            use super::*;
            impl_instructions!(tests $($tts)*);
        }
    };
}

/// Defines the enum with `TryFrom` trait implementation.
#[macro_export]
macro_rules! enum_try_from {
    (
        $(#[$meta:meta])* $vis:vis enum $name:ident {
            $($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)*
        },
        $from:ident
    ) => {
        $(#[$meta])*
        $vis enum $name {
            $($(#[$vmeta])* $vname $(= $val)?,)*
        }

        impl core::convert::TryFrom<$from> for $name {
            type Error = $crate::PanicReason;

            fn try_from(v: $from) -> Result<Self, Self::Error> {
                match v {
                    $(x if x == $name::$vname as $from => Ok($name::$vname),)*
                    _ => Err($crate::PanicReason::InvalidMetadataIdentifier),
                }
            }
        }
    }
}

#[cfg(test)]
// Generate a test for the instruction.
macro_rules! op_test {
    ($Op:ident $op:ident[RegId]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, false, false, false);
        }
    };
    ($Op:ident $op:ident[RegId RegId]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, false, false);
        }
    };
    ($Op:ident $op:ident[RegId RegId RegId]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, true, false);
        }
    };
    ($Op:ident $op:ident[RegId RegId RegId RegId]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, true, true);
        }
    };
    ($Op:ident $op:ident[RegId RegId RegId Imm06]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, true, true);
        }
    };
    ($Op:ident $op:ident[RegId RegId Imm12]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, true, true);
        }
    };
    ($Op:ident $op:ident[RegId Imm18]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, true, true);
        }
    };
    ($Op:ident $op:ident[Imm24]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, true, true, true, true);
        }
    };
    ($Op:ident $op:ident[]) => {
        #[test]
        fn $op() {
            crate::macros::test_reserved_part(Opcode::$Op, false, false, false, false);
        }
    };
}

#[cfg(test)]
fn bytes(a: u8, b: u8, c: u8, d: u8) -> [u8; 3] {
    use crate::RegId;
    crate::pack::bytes_from_ra_rb_rc_rd(
        RegId::new(a),
        RegId::new(b),
        RegId::new(c),
        RegId::new(d),
    )
}

#[cfg(test)]
pub(crate) fn test_reserved_part(
    opcode: crate::Opcode,
    zero_should_pass: bool,
    first_should_pass: bool,
    second_should_pass: bool,
    third_should_pass: bool,
) {
    use crate::Instruction;

    // Args: 0
    let [a, b, c] = bytes(0, 0, 0, 0);
    Instruction::try_from([opcode as u8, a, b, c]).unwrap();
    let [a, b, c] = bytes(1, 0, 0, 0);
    let zero_is_error = Instruction::try_from([opcode as u8, a, b, c]).is_ok();
    assert_eq!(
        zero_should_pass, zero_is_error,
        "Opcode: {opcode:?} failed zero"
    );

    // Args: 1
    let [a, b, c] = bytes(0, 0, 0, 0);
    Instruction::try_from([opcode as u8, a, b, c]).unwrap();
    let [a, b, c] = bytes(0, 1, 0, 0);
    let first_is_error = Instruction::try_from([opcode as u8, a, b, c]).is_ok();
    assert_eq!(
        first_should_pass, first_is_error,
        "Opcode: {opcode:?} failed first"
    );

    // Args: 2
    let [a, b, c] = bytes(0, 0, 0, 0);
    Instruction::try_from([opcode as u8, a, b, c]).unwrap();
    let [a, b, c] = bytes(0, 0, 1, 0);
    let second_is_error = Instruction::try_from([opcode as u8, a, b, c]).is_ok();
    assert_eq!(
        second_should_pass, second_is_error,
        "Opcode: {opcode:?} failed second"
    );

    // Args: 3
    let [a, b, c] = bytes(0, 0, 0, 0);
    Instruction::try_from([opcode as u8, a, b, c]).unwrap();
    let [a, b, c] = bytes(0, 0, 0, 1);
    let third_is_error = Instruction::try_from([opcode as u8, a, b, c]).is_ok();
    assert_eq!(
        third_should_pass, third_is_error,
        "Opcode: {opcode:?} failed third"
    );
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction.rs

Source
use crate::{
    input::{
        coin::{
            CoinPredicate,
            CoinSigned,
        },
        message::{
            MessageCoinPredicate,
            MessageDataPredicate,
        },
    },
    policies::Policies,
    TxPointer,
};
use fuel_crypto::{
    Hasher,
    PublicKey,
};
use fuel_types::{
    canonical::{
        Deserialize,
        Error,
        Serialize,
    },
    Address,
    AssetId,
    BlobId,
    Bytes32,
    Nonce,
    Salt,
    Word,
};

use input::*;
use output::*;

#[cfg(feature = "typescript")]
use self::{
    input::typescript as input_ts,
    output::typescript as output_ts,
};

use alloc::vec::{
    IntoIter,
    Vec,
};
use itertools::Itertools;

mod fee;
mod metadata;
mod repr;
mod types;
mod validity;

mod id;

pub mod consensus_parameters;
pub mod policies;

pub use consensus_parameters::{
    ConsensusParameters,
    ContractParameters,
    DependentCost,
    FeeParameters,
    GasCosts,
    GasCostsValues,
    PredicateParameters,
    ScriptParameters,
    TxParameters,
};
pub use fee::{
    Chargeable,
    TransactionFee,
};
pub use metadata::Cacheable;
pub use repr::TransactionRepr;
pub use types::*;
pub use validity::{
    FormatValidityChecks,
    ValidityError,
};

#[cfg(feature = "alloc")]
pub use id::Signable;

pub use id::{
    PrepareSign,
    UniqueIdentifier,
};

/// Identification of transaction (also called transaction hash)
pub type TxId = Bytes32;

/// The fuel transaction entity <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md>.
#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Hash,
    strum_macros::EnumCount,
    serde::Serialize,
    serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[allow(clippy::large_enum_variant)]
pub enum Transaction {
    Script(Script),
    Create(Create),
    Mint(Mint),
    Upgrade(Upgrade),
    Upload(Upload),
    Blob(Blob),
}

#[cfg(feature = "test-helpers")]
impl Default for Transaction {
    fn default() -> Self {
        Script::default().into()
    }
}

impl Transaction {
    /// Return default valid transaction useful for tests.
    #[cfg(all(feature = "random", feature = "std", feature = "test-helpers"))]
    pub fn default_test_tx() -> Self {
        use crate::Finalizable;

        crate::TransactionBuilder::script(vec![], vec![])
            .max_fee_limit(0)
            .add_fee_input()
            .finalize()
            .into()
    }

    pub const fn script(
        gas_limit: Word,
        script: Vec<u8>,
        script_data: Vec<u8>,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
    ) -> Script {
        let receipts_root = Bytes32::zeroed();

        Script {
            body: ScriptBody {
                script_gas_limit: gas_limit,
                receipts_root,
                script: ScriptCode { bytes: script },
                script_data,
            },
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    pub fn create(
        bytecode_witness_index: u16,
        policies: Policies,
        salt: Salt,
        mut storage_slots: Vec<StorageSlot>,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
    ) -> Create {
        // sort incoming storage slots
        storage_slots.sort();

        Create {
            body: CreateBody {
                bytecode_witness_index,
                salt,
                storage_slots,
            },
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    pub fn mint(
        tx_pointer: TxPointer,
        input_contract: input::contract::Contract,
        output_contract: output::contract::Contract,
        mint_amount: Word,
        mint_asset_id: AssetId,
        gas_price: Word,
    ) -> Mint {
        Mint {
            tx_pointer,
            input_contract,
            output_contract,
            mint_amount,
            mint_asset_id,
            gas_price,
            metadata: None,
        }
    }

    pub fn upgrade(
        upgrade_purpose: UpgradePurpose,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
    ) -> Upgrade {
        Upgrade {
            body: UpgradeBody {
                purpose: upgrade_purpose,
            },
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    /// Creates an `Upgrade` transaction with the purpose of upgrading the consensus
    /// parameters.
    pub fn upgrade_consensus_parameters(
        consensus_parameters: &ConsensusParameters,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        mut witnesses: Vec<Witness>,
    ) -> Result<Upgrade, ValidityError> {
        let serialized_consensus_parameters = postcard::to_allocvec(consensus_parameters)
            .map_err(|_| {
                ValidityError::TransactionUpgradeConsensusParametersSerialization
            })?;
        let checksum = Hasher::hash(&serialized_consensus_parameters);
        let witness_index = u16::try_from(witnesses.len())
            .map_err(|_| ValidityError::TransactionWitnessesMax)?;
        witnesses.push(serialized_consensus_parameters.into());

        Ok(Upgrade {
            body: UpgradeBody {
                purpose: UpgradePurpose::ConsensusParameters {
                    witness_index,
                    checksum,
                },
            },
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        })
    }

    pub fn upload(
        upload_body: UploadBody,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
    ) -> Upload {
        Upload {
            body: upload_body,
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    pub fn upload_from_subsection(
        subsection: UploadSubsection,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        mut witnesses: Vec<Witness>,
    ) -> Upload {
        let body = UploadBody {
            root: subsection.root,
            witness_index: u16::try_from(witnesses.len()).unwrap_or(u16::MAX),
            subsection_index: subsection.subsection_index,
            subsections_number: subsection.subsections_number,
            proof_set: subsection.proof_set,
        };
        witnesses.push(subsection.subsection.into());
        Upload {
            body,
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    pub fn blob(
        body: BlobBody,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        witnesses: Vec<Witness>,
    ) -> Blob {
        Blob {
            body,
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    pub fn blob_from_bytes(
        bytes: Vec<u8>,
        policies: Policies,
        inputs: Vec<Input>,
        outputs: Vec<Output>,
        mut witnesses: Vec<Witness>,
    ) -> Blob {
        let body = BlobBody {
            id: BlobId::compute(&bytes),
            witness_index: u16::try_from(witnesses.len()).unwrap_or(u16::MAX),
        };
        witnesses.push(bytes.into());
        Blob {
            body,
            policies,
            inputs,
            outputs,
            witnesses,
            metadata: None,
        }
    }

    /// Convert the type into a JSON string
    ///
    /// This is implemented as infallible because serde_json will fail only if the type
    /// can't serialize one of its attributes. We don't have such case with the
    /// transaction because all of its attributes are trivially serialized.
    ///
    /// If an error happens, a JSON string with the error description will be returned
    #[cfg(test)]
    pub fn to_json(&self) -> alloc::string::String {
        serde_json::to_string(self)
            .unwrap_or_else(|e| alloc::format!(r#"{{"error": "{e}"}}"#))
    }

    /// Attempt to deserialize a transaction from a JSON string, returning `None` if it
    /// fails
    #[cfg(test)]
    pub fn from_json<J>(json: J) -> Option<Self>
    where
        J: AsRef<str>,
    {
        // we opt to return `Option` to not leak serde concrete error implementations in
        // the crate. considering we don't expect to handle failures downstream
        // (e.g. if a string is not a valid json, then we simply don't have a
        // transaction out of that), then its not required to leak the type
        serde_json::from_str(json.as_ref()).ok()
    }

    pub const fn is_script(&self) -> bool {
        matches!(self, Self::Script { .. })
    }

    pub const fn is_create(&self) -> bool {
        matches!(self, Self::Create { .. })
    }

    pub const fn is_mint(&self) -> bool {
        matches!(self, Self::Mint { .. })
    }

    pub const fn is_upgrade(&self) -> bool {
        matches!(self, Self::Upgrade { .. })
    }

    pub const fn is_upload(&self) -> bool {
        matches!(self, Self::Upload { .. })
    }

    pub const fn is_blob(&self) -> bool {
        matches!(self, Self::Blob { .. })
    }

    pub const fn as_script(&self) -> Option<&Script> {
        match self {
            Self::Script(script) => Some(script),
            _ => None,
        }
    }

    pub fn as_script_mut(&mut self) -> Option<&mut Script> {
        match self {
            Self::Script(script) => Some(script),
            _ => None,
        }
    }

    pub const fn as_create(&self) -> Option<&Create> {
        match self {
            Self::Create(create) => Some(create),
            _ => None,
        }
    }

    pub fn as_create_mut(&mut self) -> Option<&mut Create> {
        match self {
            Self::Create(create) => Some(create),
            _ => None,
        }
    }

    pub const fn as_mint(&self) -> Option<&Mint> {
        match self {
            Self::Mint(mint) => Some(mint),
            _ => None,
        }
    }

    pub fn as_mint_mut(&mut self) -> Option<&mut Mint> {
        match self {
            Self::Mint(mint) => Some(mint),
            _ => None,
        }
    }

    pub const fn as_upgrade(&self) -> Option<&Upgrade> {
        match self {
            Self::Upgrade(tx) => Some(tx),
            _ => None,
        }
    }

    pub fn as_upgrade_mut(&mut self) -> Option<&mut Upgrade> {
        match self {
            Self::Upgrade(tx) => Some(tx),
            _ => None,
        }
    }

    pub const fn as_upload(&self) -> Option<&Upload> {
        match self {
            Self::Upload(tx) => Some(tx),
            _ => None,
        }
    }

    pub fn as_upload_mut(&mut self) -> Option<&mut Upload> {
        match self {
            Self::Upload(tx) => Some(tx),
            _ => None,
        }
    }

    pub const fn as_blob(&self) -> Option<&Blob> {
        match self {
            Self::Blob(tx) => Some(tx),
            _ => None,
        }
    }

    pub fn as_blob_mut(&mut self) -> Option<&mut Blob> {
        match self {
            Self::Blob(tx) => Some(tx),
            _ => None,
        }
    }
}

pub trait Executable: field::Inputs + field::Outputs + field::Witnesses {
    /// Returns the assets' ids used in the inputs in the order of inputs.
    fn input_asset_ids<'a>(
        &'a self,
        base_asset_id: &'a AssetId,
    ) -> IntoIter<&'a AssetId> {
        self.inputs()
            .iter()
            .filter_map(|input| match input {
                Input::CoinPredicate(CoinPredicate { asset_id, .. })
                | Input::CoinSigned(CoinSigned { asset_id, .. }) => Some(asset_id),
                Input::MessageCoinSigned(_)
                | Input::MessageCoinPredicate(_)
                | Input::MessageDataPredicate(_)
                | Input::MessageDataSigned(_) => Some(base_asset_id),
                _ => None,
            })
            .collect_vec()
            .into_iter()
    }

    /// Returns unique assets' ids used in the inputs.
    fn input_asset_ids_unique<'a>(
        &'a self,
        base_asset_id: &'a AssetId,
    ) -> IntoIter<&'a AssetId> {
        let asset_ids = self.input_asset_ids(base_asset_id);

        #[cfg(feature = "std")]
        let asset_ids = asset_ids.unique();

        #[cfg(not(feature = "std"))]
        let asset_ids = asset_ids.sorted().dedup();

        asset_ids.collect_vec().into_iter()
    }

    /// Checks that all owners of inputs in the predicates are valid.
    fn check_predicate_owners(&self) -> bool {
        self.inputs()
            .iter()
            .filter_map(|i| match i {
                Input::CoinPredicate(CoinPredicate {
                    owner, predicate, ..
                }) => Some((owner, predicate)),
                Input::MessageDataPredicate(MessageDataPredicate {
                    recipient,
                    predicate,
                    ..
                }) => Some((recipient, predicate)),
                Input::MessageCoinPredicate(MessageCoinPredicate {
                    recipient,
                    predicate,
                    ..
                }) => Some((recipient, predicate)),
                _ => None,
            })
            .fold(true, |result, (owner, predicate)| {
                result && Input::is_predicate_owner_valid(owner, &**predicate)
            })
    }

    /// Append a new unsigned coin input to the transaction.
    ///
    /// When the transaction is constructed, [`Signable::sign_inputs`] should
    /// be called for every secret key used with this method.
    ///
    /// The production of the signatures can be done only after the full
    /// transaction skeleton is built because the input of the hash message
    /// is the ID of the final transaction.
    fn add_unsigned_coin_input(
        &mut self,
        utxo_id: UtxoId,
        owner: &PublicKey,
        amount: Word,
        asset_id: AssetId,
        tx_pointer: TxPointer,
        witness_index: u16,
    ) {
        let owner = Input::owner(owner);

        let input = Input::coin_signed(
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
        );
        self.inputs_mut().push(input);
    }

    /// Append a new unsigned message input to the transaction.
    ///
    /// When the transaction is constructed, [`Signable::sign_inputs`] should
    /// be called for every secret key used with this method.
    ///
    /// The production of the signatures can be done only after the full
    /// transaction skeleton is built because the input of the hash message
    /// is the ID of the final transaction.
    fn add_unsigned_message_input(
        &mut self,
        sender: Address,
        recipient: Address,
        nonce: Nonce,
        amount: Word,
        data: Vec<u8>,
        witness_index: u16,
    ) {
        let input = if data.is_empty() {
            Input::message_coin_signed(sender, recipient, amount, nonce, witness_index)
        } else {
            Input::message_data_signed(
                sender,
                recipient,
                amount,
                nonce,
                witness_index,
                data,
            )
        };

        self.inputs_mut().push(input);
    }
}

impl<T: field::Inputs + field::Outputs + field::Witnesses> Executable for T {}

impl From<Script> for Transaction {
    fn from(tx: Script) -> Self {
        Self::Script(tx)
    }
}

impl From<Create> for Transaction {
    fn from(tx: Create) -> Self {
        Self::Create(tx)
    }
}

impl From<Mint> for Transaction {
    fn from(tx: Mint) -> Self {
        Self::Mint(tx)
    }
}

impl From<Upgrade> for Transaction {
    fn from(tx: Upgrade) -> Self {
        Self::Upgrade(tx)
    }
}

impl From<Upload> for Transaction {
    fn from(tx: Upload) -> Self {
        Self::Upload(tx)
    }
}

impl From<Blob> for Transaction {
    fn from(tx: Blob) -> Self {
        Self::Blob(tx)
    }
}

impl Serialize for Transaction {
    fn size_static(&self) -> usize {
        match self {
            Self::Script(tx) => tx.size_static(),
            Self::Create(tx) => tx.size_static(),
            Self::Mint(tx) => tx.size_static(),
            Self::Upgrade(tx) => tx.size_static(),
            Self::Upload(tx) => tx.size_static(),
            Self::Blob(tx) => tx.size_static(),
        }
    }

    fn size_dynamic(&self) -> usize {
        match self {
            Self::Script(tx) => tx.size_dynamic(),
            Self::Create(tx) => tx.size_dynamic(),
            Self::Mint(tx) => tx.size_dynamic(),
            Self::Upgrade(tx) => tx.size_dynamic(),
            Self::Upload(tx) => tx.size_dynamic(),
            Self::Blob(tx) => tx.size_dynamic(),
        }
    }

    fn encode_static<O: fuel_types::canonical::Output + ?Sized>(
        &self,
        buffer: &mut O,
    ) -> Result<(), Error> {
        match self {
            Self::Script(tx) => tx.encode_static(buffer),
            Self::Create(tx) => tx.encode_static(buffer),
            Self::Mint(tx) => tx.encode_static(buffer),
            Self::Upgrade(tx) => tx.encode_static(buffer),
            Self::Upload(tx) => tx.encode_static(buffer),
            Self::Blob(tx) => tx.encode_static(buffer),
        }
    }

    fn encode_dynamic<O: fuel_types::canonical::Output + ?Sized>(
        &self,
        buffer: &mut O,
    ) -> Result<(), Error> {
        match self {
            Self::Script(tx) => tx.encode_dynamic(buffer),
            Self::Create(tx) => tx.encode_dynamic(buffer),
            Self::Mint(tx) => tx.encode_dynamic(buffer),
            Self::Upgrade(tx) => tx.encode_dynamic(buffer),
            Self::Upload(tx) => tx.encode_dynamic(buffer),
            Self::Blob(tx) => tx.encode_dynamic(buffer),
        }
    }
}

impl Deserialize for Transaction {
    fn decode_static<I: fuel_types::canonical::Input + ?Sized>(
        buffer: &mut I,
    ) -> Result<Self, Error> {
        let mut discriminant_buffer = [0u8; 8];
        buffer.peek(&mut discriminant_buffer)?;

        let discriminant =
            <TransactionRepr as Deserialize>::decode(&mut &discriminant_buffer[..])?;

        match discriminant {
            TransactionRepr::Script => {
                Ok(<Script as Deserialize>::decode_static(buffer)?.into())
            }
            TransactionRepr::Create => {
                Ok(<Create as Deserialize>::decode_static(buffer)?.into())
            }
            TransactionRepr::Mint => {
                Ok(<Mint as Deserialize>::decode_static(buffer)?.into())
            }
            TransactionRepr::Upgrade => {
                Ok(<Upgrade as Deserialize>::decode_static(buffer)?.into())
            }
            TransactionRepr::Upload => {
                Ok(<Upload as Deserialize>::decode_static(buffer)?.into())
            }
            TransactionRepr::Blob => {
                Ok(<Blob as Deserialize>::decode_static(buffer)?.into())
            }
        }
    }

    fn decode_dynamic<I: fuel_types::canonical::Input + ?Sized>(
        &mut self,
        buffer: &mut I,
    ) -> Result<(), Error> {
        match self {
            Self::Script(tx) => tx.decode_dynamic(buffer),
            Self::Create(tx) => tx.decode_dynamic(buffer),
            Self::Mint(tx) => tx.decode_dynamic(buffer),
            Self::Upgrade(tx) => tx.decode_dynamic(buffer),
            Self::Upload(tx) => tx.decode_dynamic(buffer),
            Self::Blob(tx) => tx.decode_dynamic(buffer),
        }
    }
}

/// The module contains traits for each possible field in the `Transaction`. Those traits
/// can be used to write generic code based on the different combinations of the fields.
pub mod field {
    use crate::{
        input,
        output,
        policies,
        Input,
        Output,
        StorageSlot,
        UpgradePurpose as UpgradePurposeType,
        Witness,
    };
    use fuel_types::{
        AssetId,
        BlockHeight,
        Bytes32,
        Word,
    };

    use crate::policies::PolicyType;
    use alloc::vec::Vec;
    use core::ops::{
        Deref,
        DerefMut,
    };

    pub trait Tip {
        fn tip(&self) -> Word;
        fn set_tip(&mut self, value: Word);
    }

    impl<T: Policies + ?Sized> Tip for T {
        #[inline(always)]
        fn tip(&self) -> Word {
            self.policies().get(PolicyType::Tip).unwrap_or_default()
        }

        #[inline(always)]
        fn set_tip(&mut self, price: Word) {
            self.policies_mut().set(PolicyType::Tip, Some(price))
        }
    }

    pub trait WitnessLimit {
        fn witness_limit(&self) -> Word;
        fn set_witness_limit(&mut self, value: Word);
    }

    impl<T: Policies + ?Sized> WitnessLimit for T {
        #[inline(always)]
        fn witness_limit(&self) -> Word {
            self.policies().get(PolicyType::WitnessLimit).unwrap_or(0)
        }

        #[inline(always)]
        fn set_witness_limit(&mut self, value: Word) {
            self.policies_mut()
                .set(PolicyType::WitnessLimit, Some(value))
        }
    }

    pub trait ScriptGasLimit {
        fn script_gas_limit(&self) -> &Word;
        fn script_gas_limit_mut(&mut self) -> &mut Word;
        fn script_gas_limit_offset(&self) -> usize {
            Self::script_gas_limit_offset_static()
        }

        fn script_gas_limit_offset_static() -> usize;
    }

    pub trait Maturity {
        fn maturity(&self) -> BlockHeight;
        fn set_maturity(&mut self, value: BlockHeight);
    }

    impl<T: Policies + ?Sized> Maturity for T {
        #[inline(always)]
        fn maturity(&self) -> BlockHeight {
            self.policies()
                .get(PolicyType::Maturity)
                .map(|value| u32::try_from(value).unwrap_or(u32::MAX).into())
                .unwrap_or_default()
        }

        #[inline(always)]
        fn set_maturity(&mut self, block_height: BlockHeight) {
            self.policies_mut()
                .set(PolicyType::Maturity, Some(*block_height.deref() as u64))
        }
    }

    pub trait MaxFeeLimit {
        fn max_fee_limit(&self) -> Word;
        fn set_max_fee_limit(&mut self, value: Word);
    }

    impl<T: Policies + ?Sized> MaxFeeLimit for T {
        #[inline(always)]
        fn max_fee_limit(&self) -> Word {
            self.policies().get(PolicyType::MaxFee).unwrap_or(0)
        }

        #[inline(always)]
        fn set_max_fee_limit(&mut self, value: Word) {
            self.policies_mut().set(PolicyType::MaxFee, Some(value))
        }
    }

    pub trait TxPointer {
        fn tx_pointer(&self) -> &crate::TxPointer;
        fn tx_pointer_mut(&mut self) -> &mut crate::TxPointer;
        fn tx_pointer_offset(&self) -> usize {
            Self::tx_pointer_static()
        }

        fn tx_pointer_static() -> usize;
    }

    pub trait InputContract {
        fn input_contract(&self) -> &input::contract::Contract;
        fn input_contract_mut(&mut self) -> &mut input::contract::Contract;
        fn input_contract_offset(&self) -> usize;
    }

    pub trait OutputContract {
        fn output_contract(&self) -> &output::contract::Contract;
        fn output_contract_mut(&mut self) -> &mut output::contract::Contract;
        fn output_contract_offset(&self) -> usize;
    }

    pub trait MintAmount {
        fn mint_amount(&self) -> &Word;
        fn mint_amount_mut(&mut self) -> &mut Word;
        fn mint_amount_offset(&self) -> usize;
    }

    pub trait MintAssetId {
        fn mint_asset_id(&self) -> &AssetId;
        fn mint_asset_id_mut(&mut self) -> &mut AssetId;
        fn mint_asset_id_offset(&self) -> usize;
    }

    pub trait MintGasPrice {
        fn gas_price(&self) -> &Word;
        fn gas_price_mut(&mut self) -> &mut Word;
        fn gas_price_offset(&self) -> usize;
    }

    pub trait ReceiptsRoot {
        fn receipts_root(&self) -> &Bytes32;
        fn receipts_root_mut(&mut self) -> &mut Bytes32;
        fn receipts_root_offset(&self) -> usize {
            Self::receipts_root_offset_static()
        }

        fn receipts_root_offset_static() -> usize;
    }

    pub trait Script {
        fn script(&self) -> &Vec<u8>;
        fn script_mut(&mut self) -> &mut Vec<u8>;
        fn script_offset(&self) -> usize {
            Self::script_offset_static()
        }

        fn script_offset_static() -> usize;
    }

    pub trait ScriptData {
        fn script_data(&self) -> &Vec<u8>;
        fn script_data_mut(&mut self) -> &mut Vec<u8>;
        fn script_data_offset(&self) -> usize;
    }

    pub trait ChargeableBody<Body> {
        fn body(&self) -> &Body;
        fn body_mut(&mut self) -> &mut Body;
        fn body_offset_end(&self) -> usize;
    }

    pub trait Policies {
        fn policies(&self) -> &policies::Policies;
        fn policies_mut(&mut self) -> &mut policies::Policies;
        fn policies_offset(&self) -> usize;
    }

    pub trait BytecodeWitnessIndex {
        fn bytecode_witness_index(&self) -> &u16;
        fn bytecode_witness_index_mut(&mut self) -> &mut u16;
        fn bytecode_witness_index_offset(&self) -> usize {
            Self::bytecode_witness_index_offset_static()
        }

        fn bytecode_witness_index_offset_static() -> usize;
    }

    pub trait Salt {
        fn salt(&self) -> &fuel_types::Salt;
        fn salt_mut(&mut self) -> &mut fuel_types::Salt;
        fn salt_offset(&self) -> usize {
            Self::salt_offset_static()
        }

        fn salt_offset_static() -> usize;
    }

    pub trait StorageSlots {
        fn storage_slots(&self) -> &Vec<StorageSlot>;
        fn storage_slots_mut(&mut self) -> StorageSlotRef;
        fn storage_slots_offset_static() -> usize;

        /// Returns the offset to the `StorageSlot` at `idx` index, if any.
        fn storage_slots_offset_at(&self, idx: usize) -> Option<usize>;
    }

    /// Reference object for mutating storage slots which will automatically
    /// sort the slots when dropped.
    pub struct StorageSlotRef<'a> {
        pub(crate) storage_slots: &'a mut Vec<StorageSlot>,
    }

    impl<'a> AsMut<Vec<StorageSlot>> for StorageSlotRef<'a> {
        fn as_mut(&mut self) -> &mut Vec<StorageSlot> {
            self.storage_slots
        }
    }

    impl<'a> Deref for StorageSlotRef<'a> {
        type Target = [StorageSlot];

        fn deref(&self) -> &Self::Target {
            self.storage_slots.deref()
        }
    }

    impl<'a> DerefMut for StorageSlotRef<'a> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            self.storage_slots.deref_mut()
        }
    }

    /// Ensure the storage slots are sorted after being set
    impl<'a> Drop for StorageSlotRef<'a> {
        fn drop(&mut self) {
            self.storage_slots.sort()
        }
    }

    pub trait Inputs {
        fn inputs(&self) -> &Vec<Input>;
        fn inputs_mut(&mut self) -> &mut Vec<Input>;
        fn inputs_offset(&self) -> usize;

        /// Returns the offset to the `Input` at `idx` index, if any.
        fn inputs_offset_at(&self, idx: usize) -> Option<usize>;

        /// Returns predicate's offset and length of the `Input` at `idx`, if any.
        fn inputs_predicate_offset_at(&self, idx: usize) -> Option<(usize, usize)>;
    }

    pub trait Outputs {
        fn outputs(&self) -> &Vec<Output>;
        fn outputs_mut(&mut self) -> &mut Vec<Output>;
        fn outputs_offset(&self) -> usize;

        /// Returns the offset to the `Output` at `idx` index, if any.
        fn outputs_offset_at(&self, idx: usize) -> Option<usize>;
    }

    pub trait Witnesses {
        fn witnesses(&self) -> &Vec<Witness>;
        fn witnesses_mut(&mut self) -> &mut Vec<Witness>;
        fn witnesses_offset(&self) -> usize;

        /// Returns the offset to the `Witness` at `idx` index, if any.
        fn witnesses_offset_at(&self, idx: usize) -> Option<usize>;
    }

    pub trait UpgradePurpose {
        fn upgrade_purpose(&self) -> &UpgradePurposeType;
        fn upgrade_purpose_mut(&mut self) -> &mut UpgradePurposeType;
        fn upgrade_purpose_offset(&self) -> usize {
            Self::upgrade_purpose_offset_static()
        }

        fn upgrade_purpose_offset_static() -> usize;
    }

    pub trait BytecodeRoot {
        fn bytecode_root(&self) -> &Bytes32;
        fn bytecode_root_mut(&mut self) -> &mut Bytes32;
        fn bytecode_root_offset(&self) -> usize {
            Self::bytecode_root_offset_static()
        }

        fn bytecode_root_offset_static() -> usize;
    }

    pub trait BlobId {
        fn blob_id(&self) -> &fuel_types::BlobId;
        fn blob_id_mut(&mut self) -> &mut fuel_types::BlobId;
        fn blob_id_offset(&self) -> usize {
            Self::blob_id_offset_static()
        }

        fn blob_id_offset_static() -> usize;
    }

    pub trait SubsectionIndex {
        fn subsection_index(&self) -> &u16;
        fn subsection_index_mut(&mut self) -> &mut u16;
        fn subsection_index_offset(&self) -> usize {
            Self::subsection_index_offset_static()
        }

        fn subsection_index_offset_static() -> usize;
    }

    pub trait SubsectionsNumber {
        fn subsections_number(&self) -> &u16;
        fn subsections_number_mut(&mut self) -> &mut u16;
        fn subsections_number_offset(&self) -> usize {
            Self::subsections_number_offset_static()
        }

        fn subsections_number_offset_static() -> usize;
    }

    pub trait ProofSet {
        fn proof_set(&self) -> &Vec<Bytes32>;
        fn proof_set_mut(&mut self) -> &mut Vec<Bytes32>;
        fn proof_set_offset(&self) -> usize {
            Self::proof_set_offset_static()
        }

        fn proof_set_offset_static() -> usize;
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use crate::{
        transaction::{
            input_ts::Input,
            output_ts::Output,
            Policies,
        },
        AssetId,
        Witness,
        Word,
    };
    use alloc::{
        boxed::Box,
        format,
        string::String,
        vec::Vec,
    };
    use fuel_types::Bytes32;

    #[derive(Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize)]
    #[wasm_bindgen]
    pub struct Transaction(#[wasm_bindgen(skip)] pub Box<crate::Transaction>);

    #[derive(
        Default, Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize,
    )]
    #[wasm_bindgen]
    pub struct Create(#[wasm_bindgen(skip)] pub Box<crate::Create>);

    #[derive(
        Default, Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize,
    )]
    #[wasm_bindgen]
    pub struct Script(#[wasm_bindgen(skip)] pub Box<crate::Script>);

    #[derive(
        Default, Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize,
    )]
    #[wasm_bindgen]
    pub struct Mint(#[wasm_bindgen(skip)] pub Box<crate::Mint>);

    #[derive(
        Default, Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize,
    )]
    #[wasm_bindgen]
    pub struct Upgrade(#[wasm_bindgen(skip)] pub Box<crate::Upgrade>);

    #[derive(Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize)]
    #[wasm_bindgen]
    pub struct UpgradePurpose(#[wasm_bindgen(skip)] pub Box<crate::UpgradePurpose>);

    #[derive(
        Default, Debug, Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize,
    )]
    #[wasm_bindgen]
    pub struct Upload(#[wasm_bindgen(skip)] pub Box<crate::Upload>);

    #[wasm_bindgen]
    impl Transaction {
        #[wasm_bindgen(js_name = toJSON)]
        pub fn to_json(&self) -> String {
            serde_json::to_string(&self.0).expect("unable to json format")
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:?}", self.0)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            self.0.to_bytes()
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<Transaction, js_sys::Error> {
            use fuel_types::canonical::Deserialize;
            crate::Transaction::from_bytes(value)
                .map(|v| Transaction(Box::new(v)))
                .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
        }

        #[wasm_bindgen]
        pub fn script(
            gas_limit: Word,
            script: Vec<u8>,
            script_data: Vec<u8>,
            policies: Policies,
            inputs: Vec<Input>,
            outputs: Vec<Output>,
            witnesses: Vec<Witness>,
        ) -> Script {
            Script(
                crate::Transaction::script(
                    gas_limit,
                    script,
                    script_data,
                    policies,
                    inputs.into_iter().map(|v| *v.0).collect(),
                    outputs.into_iter().map(|v| *v.0).collect(),
                    witnesses,
                )
                .into(),
            )
        }

        #[wasm_bindgen]
        pub fn create(
            bytecode_witness_index: u16,
            policies: Policies,
            salt: crate::Salt,
            storage_slots: Vec<crate::StorageSlot>,
            inputs: Vec<Input>,
            outputs: Vec<Output>,
            witnesses: Vec<Witness>,
        ) -> Create {
            Create(
                crate::Transaction::create(
                    bytecode_witness_index,
                    policies,
                    salt,
                    storage_slots,
                    inputs.into_iter().map(|v| *v.0).collect(),
                    outputs.into_iter().map(|v| *v.0).collect(),
                    witnesses,
                )
                .into(),
            )
        }

        #[wasm_bindgen]
        pub fn mint(
            tx_pointer: crate::TxPointer,
            input_contract: crate::input::contract::Contract,
            output_contract: crate::output::contract::Contract,
            mint_amount: Word,
            mint_asset_id: AssetId,
            gas_price: Word,
        ) -> Mint {
            Mint(
                crate::Mint {
                    tx_pointer,
                    input_contract,
                    output_contract,
                    mint_amount,
                    mint_asset_id,
                    gas_price,
                    metadata: None,
                }
                .into(),
            )
        }

        #[wasm_bindgen]
        pub fn upgrade(
            purpose: UpgradePurpose,
            policies: Policies,
            inputs: Vec<Input>,
            outputs: Vec<Output>,
            witnesses: Vec<Witness>,
        ) -> Upgrade {
            Upgrade(
                crate::Transaction::upgrade(
                    *purpose.0.as_ref(),
                    policies,
                    inputs.into_iter().map(|v| *v.0).collect(),
                    outputs.into_iter().map(|v| *v.0).collect(),
                    witnesses,
                )
                .into(),
            )
        }

        #[wasm_bindgen]
        pub fn upload(
            root: Bytes32,
            witness_index: u16,
            subsection_index: u16,
            subsections_number: u16,
            proof_set: Vec<Bytes32>,
            policies: Policies,
            inputs: Vec<Input>,
            outputs: Vec<Output>,
            witnesses: Vec<Witness>,
        ) -> Upload {
            Upload(
                crate::Transaction::upload(
                    crate::UploadBody {
                        root,
                        witness_index,
                        subsection_index,
                        subsections_number,
                        proof_set,
                    },
                    policies,
                    inputs.into_iter().map(|v| *v.0).collect(),
                    outputs.into_iter().map(|v| *v.0).collect(),
                    witnesses,
                )
                .into(),
            )
        }
    }

    macro_rules! ts_methods {
        ($t:ty, $tx:expr) => {
            #[wasm_bindgen]
            impl $t {
                #[wasm_bindgen(js_name = as_tx)]
                pub fn typescript_wrap_tx(self) -> Transaction {
                    Transaction(Box::new($tx(self.0.as_ref().clone())))
                }

                #[wasm_bindgen(constructor)]
                pub fn typescript_new() -> $t {
                    <$t>::default()
                }

                #[wasm_bindgen(js_name = toJSON)]
                pub fn to_json(&self) -> String {
                    serde_json::to_string(&self).expect("unable to json format")
                }

                #[wasm_bindgen(js_name = toString)]
                pub fn typescript_to_string(&self) -> String {
                    format!("{:?}", self)
                }

                #[wasm_bindgen(js_name = to_bytes)]
                pub fn typescript_to_bytes(&self) -> Vec<u8> {
                    use fuel_types::canonical::Serialize;
                    <_ as Serialize>::to_bytes(self.0.as_ref())
                }

                #[wasm_bindgen(js_name = from_bytes)]
                pub fn typescript_from_bytes(value: &[u8]) -> Result<$t, js_sys::Error> {
                    use fuel_types::canonical::Deserialize;
                    let res = <_ as Deserialize>::from_bytes(value)
                        .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))?;
                    Ok(Self(Box::new(res)))
                }
            }
        };
    }

    ts_methods!(Script, crate::Transaction::Script);
    ts_methods!(Create, crate::Transaction::Create);
    ts_methods!(Mint, crate::Transaction::Mint);
    ts_methods!(Upgrade, crate::Transaction::Upgrade);
    ts_methods!(Upload, crate::Transaction::Upload);
}

#[allow(non_snake_case)]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn script__metered_bytes_size___includes_witnesses() {
        let witness = [0u8; 64].to_vec();
        let script_with_no_witnesses = Transaction::script(
            Default::default(),
            vec![],
            vec![],
            Default::default(),
            vec![],
            vec![],
            vec![],
        );
        let script_with_witnesses = Transaction::script(
            Default::default(),
            vec![],
            vec![],
            Default::default(),
            vec![],
            vec![],
            vec![witness.clone().into()],
        );

        assert_eq!(
            script_with_witnesses.metered_bytes_size(),
            script_with_no_witnesses.metered_bytes_size() + witness.size()
        );
    }

    #[test]
    fn create__metered_bytes_size___includes_witnesses() {
        let witness = [0u8; 64].to_vec();
        let create_with_no_witnesses = Transaction::create(
            0,
            Default::default(),
            Default::default(),
            vec![],
            vec![],
            vec![],
            vec![],
        );
        let create_with_witnesses = Transaction::create(
            0,
            Default::default(),
            Default::default(),
            vec![],
            vec![],
            vec![],
            vec![witness.clone().into()],
        );
        assert_eq!(
            create_with_witnesses.metered_bytes_size(),
            create_with_no_witnesses.metered_bytes_size() + witness.size()
        );
    }

    #[test]
    fn upgrade__metered_bytes_size___includes_witnesses() {
        let witness = [0u8; 64].to_vec();
        let tx_with_no_witnesses = Transaction::upgrade(
            UpgradePurpose::StateTransition {
                root: Default::default(),
            },
            Default::default(),
            vec![],
            vec![],
            vec![],
        );
        let tx_with_witnesses = Transaction::upgrade(
            UpgradePurpose::StateTransition {
                root: Default::default(),
            },
            Default::default(),
            vec![],
            vec![],
            vec![witness.clone().into()],
        );
        assert_eq!(
            tx_with_witnesses.metered_bytes_size(),
            tx_with_no_witnesses.metered_bytes_size() + witness.size()
        );
    }

    #[test]
    fn upload__metered_bytes_size__includes_witness() {
        let witness = [0u8; 64].to_vec();
        let tx_with_no_witnesses = Transaction::upload(
            Default::default(),
            Default::default(),
            vec![],
            vec![],
            vec![],
        );
        let tx_with_witnesses = Transaction::upload(
            Default::default(),
            Default::default(),
            vec![],
            vec![],
            vec![witness.clone().into()],
        );
        assert_eq!(
            tx_with_witnesses.metered_bytes_size(),
            tx_with_no_witnesses.metered_bytes_size() + witness.size()
        );
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/builder.rs

Source
use crate::{
    input,
    output,
    transaction::{
        field::{
            self,
            BytecodeWitnessIndex,
            Maturity,
            Tip,
            Witnesses,
        },
        Chargeable,
        Create,
        Executable,
        Script,
    },
    Blob,
    BlobBody,
    ConsensusParameters,
    ContractParameters,
    CreateMetadata,
    FeeParameters,
    GasCosts,
    Input,
    Mint,
    Output,
    PredicateParameters,
    ScriptParameters,
    StorageSlot,
    Transaction,
    TxParameters,
    TxPointer,
    Upgrade,
    UpgradePurpose,
    Upload,
    UploadBody,
    Witness,
};

use crate::{
    Cacheable,
    Signable,
};

use crate::{
    field::{
        MaxFeeLimit,
        Outputs,
        WitnessLimit,
    },
    policies::Policies,
    transaction::{
        CreateBody,
        ScriptBody,
        UpgradeBody,
    },
};
use alloc::{
    collections::BTreeMap,
    vec::Vec,
};
use fuel_crypto::SecretKey;
use fuel_types::{
    AssetId,
    BlockHeight,
    ChainId,
    Nonce,
    Salt,
    Word,
};
#[cfg(feature = "rand")]
use rand::{
    rngs::StdRng,
    Rng,
};

pub trait BuildableAloc
where
    Self: Default + Clone + Executable + Chargeable + field::Policies + Into<Transaction>,
{
}

pub trait BuildableStd: Signable + Cacheable {}

pub trait BuildableSet: BuildableAloc + BuildableStd {}

pub trait Buildable
where
    Self: BuildableSet,
{
    /// Append an input to the transaction
    fn add_input(&mut self, input: Input) {
        self.inputs_mut().push(input)
    }

    /// Append a witness to the transaction
    fn add_witness(&mut self, witness: Witness) {
        self.witnesses_mut().push(witness);
    }

    /// Set the `Script`'s gas limit
    fn set_script_gas_limit(&mut self, limit: Word)
    where
        Self: field::ScriptGasLimit,
    {
        *self.script_gas_limit_mut() = limit;
    }
}

impl<T> BuildableAloc for T where
    Self: Default + Clone + Executable + Chargeable + field::Policies + Into<Transaction>
{
}

impl<T> BuildableStd for T where T: Signable + Cacheable {}

impl<T> BuildableSet for T where T: BuildableAloc + BuildableStd {}

impl<T> Buildable for T where T: BuildableSet {}

#[derive(Debug, Clone)]
pub struct TransactionBuilder<Tx> {
    tx: Tx,

    params: ConsensusParameters,

    // We take the key by reference so this lib won't have the responsibility to properly
    // zeroize the keys
    // Maps signing keys -> witness indexes
    sign_keys: BTreeMap<SecretKey, u16>,
}

impl TransactionBuilder<Script> {
    pub fn script(script: Vec<u8>, script_data: Vec<u8>) -> Self {
        let tx = Script {
            body: ScriptBody {
                script_gas_limit: Default::default(),
                receipts_root: Default::default(),
                script: script.into(),
                script_data,
            },
            policies: Policies::new().with_max_fee(0),
            inputs: Default::default(),
            outputs: Default::default(),
            witnesses: Default::default(),
            metadata: None,
        };
        Self::with_tx(tx)
    }
}

impl TransactionBuilder<Create> {
    pub fn create(
        bytecode: Witness,
        salt: Salt,
        mut storage_slots: Vec<StorageSlot>,
    ) -> Self {
        // sort the storage slots before initializing the builder
        storage_slots.sort();
        let mut tx = Create {
            body: CreateBody {
                bytecode_witness_index: Default::default(),
                salt,
                storage_slots,
            },
            policies: Policies::new().with_max_fee(0),
            inputs: Default::default(),
            outputs: Default::default(),
            witnesses: Default::default(),
            metadata: None,
        };

        *tx.bytecode_witness_index_mut() = 0;

        tx.witnesses_mut().push(bytecode);

        Self::with_tx(tx)
    }

    pub fn add_contract_created(&mut self) -> &mut Self {
        let create_metadata = CreateMetadata::compute(&self.tx)
            .expect("Should be able to compute metadata");

        self.tx.outputs_mut().push(Output::contract_created(
            create_metadata.contract_id,
            create_metadata.state_root,
        ));
        self
    }
}

impl TransactionBuilder<Upgrade> {
    pub fn upgrade(purpose: UpgradePurpose) -> Self {
        let tx = Upgrade {
            body: UpgradeBody { purpose },
            policies: Policies::new().with_max_fee(0),
            inputs: Default::default(),
            outputs: Default::default(),
            witnesses: Default::default(),
            metadata: None,
        };
        Self::with_tx(tx)
    }
}

impl TransactionBuilder<Upload> {
    pub fn upload(body: UploadBody) -> Self {
        let tx = Upload {
            body,
            policies: Policies::new().with_max_fee(0),
            inputs: Default::default(),
            outputs: Default::default(),
            witnesses: Default::default(),
            metadata: None,
        };
        Self::with_tx(tx)
    }
}

impl TransactionBuilder<Blob> {
    pub fn blob(body: BlobBody) -> Self {
        let tx = Blob {
            body,
            policies: Policies::new().with_max_fee(0),
            inputs: Default::default(),
            outputs: Default::default(),
            witnesses: Default::default(),
            metadata: None,
        };
        Self::with_tx(tx)
    }
}

impl TransactionBuilder<Mint> {
    pub fn mint(
        block_height: BlockHeight,
        tx_index: u16,
        input_contract: input::contract::Contract,
        output_contract: output::contract::Contract,
        mint_amount: Word,
        mint_asset_id: AssetId,
        gas_price: Word,
    ) -> Self {
        let tx = Mint {
            tx_pointer: TxPointer::new(block_height, tx_index),
            input_contract,
            output_contract,
            mint_amount,
            mint_asset_id,
            gas_price,
            metadata: None,
        };

        Self::with_tx(tx)
    }
}

impl<Tx> TransactionBuilder<Tx> {
    fn with_tx(tx: Tx) -> Self {
        let sign_keys = BTreeMap::new();

        Self {
            tx,
            params: ConsensusParameters::standard(),
            sign_keys,
        }
    }

    pub fn get_params(&self) -> &ConsensusParameters {
        &self.params
    }

    pub fn get_tx_params(&self) -> &TxParameters {
        self.params.tx_params()
    }

    pub fn get_predicate_params(&self) -> &PredicateParameters {
        self.params.predicate_params()
    }

    pub fn get_script_params(&self) -> &ScriptParameters {
        self.params.script_params()
    }

    pub fn get_contract_params(&self) -> &ContractParameters {
        self.params.contract_params()
    }

    pub fn get_fee_params(&self) -> &FeeParameters {
        self.params.fee_params()
    }

    pub fn get_chain_id(&self) -> ChainId {
        self.params.chain_id()
    }

    pub fn with_params(&mut self, params: ConsensusParameters) -> &mut Self {
        self.params = params;
        self
    }

    pub fn with_tx_params(&mut self, tx_params: TxParameters) -> &mut Self {
        self.params.set_tx_params(tx_params);
        self
    }

    pub fn with_predicate_params(
        &mut self,
        predicate_params: PredicateParameters,
    ) -> &mut Self {
        self.params.set_predicate_params(predicate_params);
        self
    }

    pub fn with_script_params(&mut self, script_params: ScriptParameters) -> &mut Self {
        self.params.set_script_params(script_params);
        self
    }

    pub fn with_contract_params(
        &mut self,
        contract_params: ContractParameters,
    ) -> &mut Self {
        self.params.set_contract_params(contract_params);
        self
    }

    pub fn with_fee_params(&mut self, fee_params: FeeParameters) -> &mut Self {
        self.params.set_fee_params(fee_params);
        self
    }

    pub fn with_chain_id(&mut self, chain_id: ChainId) -> &mut Self {
        self.params.set_chain_id(chain_id);
        self
    }

    pub fn with_gas_costs(&mut self, gas_costs: GasCosts) -> &mut Self {
        self.params.set_gas_costs(gas_costs);
        self
    }

    pub fn with_base_asset_id(&mut self, base_asset_id: AssetId) -> &mut Self {
        self.params.set_base_asset_id(base_asset_id);
        self
    }

    pub fn with_block_gas_limit(&mut self, block_gas_limit: u64) -> &mut Self {
        self.params.set_block_gas_limit(block_gas_limit);
        self
    }
}

impl<Tx: Buildable> TransactionBuilder<Tx> {
    pub fn sign_keys(&self) -> impl Iterator<Item = &SecretKey> {
        self.sign_keys.keys()
    }

    pub fn tip(&mut self, tip: Word) -> &mut Self {
        self.tx.set_tip(tip);
        self
    }

    pub fn script_gas_limit(&mut self, gas_limit: Word) -> &mut Self
    where
        Tx: field::ScriptGasLimit,
    {
        self.tx.set_script_gas_limit(gas_limit);

        self
    }

    pub fn maturity(&mut self, maturity: BlockHeight) -> &mut Self {
        self.tx.set_maturity(maturity);

        self
    }

    pub fn witness_limit(&mut self, witness_limit: Word) -> &mut Self {
        self.tx.set_witness_limit(witness_limit);

        self
    }

    pub fn max_fee_limit(&mut self, max_fee: Word) -> &mut Self {
        self.tx.set_max_fee_limit(max_fee);

        self
    }

    pub fn add_unsigned_coin_input(
        &mut self,
        secret: SecretKey,
        utxo_id: crate::UtxoId,
        amount: Word,
        asset_id: fuel_types::AssetId,
        tx_pointer: TxPointer,
    ) -> &mut Self {
        let pk = secret.public_key();

        let witness_index = self.upsert_secret(secret);

        self.tx.add_unsigned_coin_input(
            utxo_id,
            &pk,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
        );

        self
    }

    #[cfg(feature = "rand")]
    pub fn add_random_fee_input(&mut self, rng: &mut StdRng) -> &mut Self {
        self.add_unsigned_coin_input(
            SecretKey::random(rng),
            rng.gen(),
            u32::MAX as u64,
            *self.params.base_asset_id(),
            Default::default(),
        )
    }

    #[cfg(feature = "rand")]
    pub fn add_fee_input(&mut self) -> &mut Self {
        use rand::{
            Rng,
            SeedableRng,
        };
        let mut rng = rand::rngs::StdRng::seed_from_u64(2322u64);
        self.add_unsigned_coin_input(
            SecretKey::random(&mut rng),
            rng.gen(),
            u32::MAX as u64,
            *self.params.base_asset_id(),
            Default::default(),
        )
    }

    pub fn add_unsigned_message_input(
        &mut self,
        secret: SecretKey,
        sender: fuel_types::Address,
        nonce: Nonce,
        amount: Word,
        data: Vec<u8>,
    ) -> &mut Self {
        let pk = secret.public_key();
        let recipient = Input::owner(&pk);

        let witness_index = self.upsert_secret(secret);

        self.tx.add_unsigned_message_input(
            sender,
            recipient,
            nonce,
            amount,
            data,
            witness_index,
        );

        self
    }

    pub fn inputs(&self) -> &[Input] {
        self.tx.inputs()
    }

    pub fn outputs(&self) -> &[Output] {
        self.tx.outputs()
    }

    pub fn witnesses(&self) -> &[Witness] {
        self.tx.witnesses()
    }

    pub fn add_input(&mut self, input: Input) -> &mut Self {
        self.tx.add_input(input);

        self
    }

    pub fn add_witness(&mut self, witness: Witness) -> &mut Self {
        self.tx.add_witness(witness);

        self
    }

    /// Adds a secret to the builder, and adds a corresponding witness if it's a new entry
    fn upsert_secret(&mut self, secret_key: SecretKey) -> u16 {
        let witness_len = u16::try_from(self.witnesses().len())
            .expect("The number of witnesses can't exceed `u16::MAX`");

        if u32::from(witness_len) > self.params.tx_params().max_witnesses() {
            panic!("Max witnesses exceeded");
        }

        let witness_index = self.sign_keys.entry(secret_key).or_insert_with(|| {
            // if this private key hasn't been used before,
            // add a new witness entry and return its index
            self.tx.witnesses_mut().push(Witness::default());
            witness_len
        });
        *witness_index
    }

    fn finalize_inner(&self) -> Tx {
        let mut tx = self.tx.clone();

        self.sign_keys
            .iter()
            .for_each(|(k, _)| tx.sign_inputs(k, &self.get_chain_id()));

        tx.precompute(&self.get_chain_id())
            .expect("Should be able to calculate cache");

        tx
    }

    pub fn finalize_without_signature_inner(&self) -> Tx {
        let mut tx = self.tx.clone();

        tx.precompute(&self.get_chain_id())
            .expect("Should be able to calculate cache");

        tx
    }
}

impl<Tx: field::Outputs> TransactionBuilder<Tx> {
    pub fn add_output(&mut self, output: Output) -> &mut Self {
        self.tx.outputs_mut().push(output);
        self
    }
}

pub trait Finalizable<Tx> {
    fn finalize(&self) -> Tx;

    fn finalize_without_signature(&self) -> Tx;
}

impl Finalizable<Mint> for TransactionBuilder<Mint> {
    fn finalize(&self) -> Mint {
        let mut tx = self.tx.clone();
        tx.precompute(&self.get_chain_id())
            .expect("Should be able to calculate cache");
        tx
    }

    fn finalize_without_signature(&self) -> Mint {
        self.finalize()
    }
}

impl<Tx> Finalizable<Tx> for TransactionBuilder<Tx>
where
    Tx: Buildable,
{
    fn finalize(&self) -> Tx {
        self.finalize_inner()
    }

    fn finalize_without_signature(&self) -> Tx {
        self.finalize_without_signature_inner()
    }
}

impl<Tx> TransactionBuilder<Tx>
where
    Self: Finalizable<Tx>,
    Transaction: From<Tx>,
{
    pub fn finalize_as_transaction(&mut self) -> Transaction {
        self.finalize().into()
    }

    pub fn finalize_without_signature_as_transaction(&mut self) -> Transaction {
        self.finalize_without_signature().into()
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/id.rs

Source
use crate::{
    field,
    input::{
        coin::CoinSigned,
        message::{
            MessageCoinSigned,
            MessageDataSigned,
        },
    },
    Input,
    Transaction,
};
use fuel_crypto::{
    Message,
    PublicKey,
    SecretKey,
    Signature,
};
use fuel_types::{
    Bytes32,
    ChainId,
};

/// Prepares transaction for signing.
pub trait PrepareSign {
    /// Prepares transaction for signing zeroing required fields.
    fn prepare_sign(&mut self);
}

/// Means that transaction has a unique identifier.
pub trait UniqueIdentifier {
    /// The unique identifier of the transaction is based on its content.
    fn id(&self, chain_id: &ChainId) -> Bytes32;

    /// The cached unique identifier of the transaction.
    /// Returns None if transaction was not precomputed.
    fn cached_id(&self) -> Option<Bytes32>;
}

impl UniqueIdentifier for Transaction {
    fn id(&self, chain_id: &ChainId) -> Bytes32 {
        match self {
            Self::Script(tx) => tx.id(chain_id),
            Self::Create(tx) => tx.id(chain_id),
            Self::Mint(tx) => tx.id(chain_id),
            Self::Upgrade(tx) => tx.id(chain_id),
            Self::Upload(tx) => tx.id(chain_id),
            Self::Blob(tx) => tx.id(chain_id),
        }
    }

    fn cached_id(&self) -> Option<Bytes32> {
        match self {
            Self::Script(tx) => tx.cached_id(),
            Self::Create(tx) => tx.cached_id(),
            Self::Mint(tx) => tx.cached_id(),
            Self::Upgrade(tx) => tx.cached_id(),
            Self::Upload(tx) => tx.cached_id(),
            Self::Blob(tx) => tx.cached_id(),
        }
    }
}

/// Means that transaction can be singed.
///
/// # Note: Autogenerated transactions are not signable.
pub trait Signable: UniqueIdentifier {
    /// Signs inputs of the transaction.
    fn sign_inputs(&mut self, secret: &SecretKey, chain_id: &ChainId);
}

impl<T> Signable for T
where
    T: UniqueIdentifier + field::Witnesses + field::Inputs,
{
    /// For all inputs of type `coin` or `message`, check if its `owner` equals the public
    /// counterpart of the provided key. Sign all matches.
    fn sign_inputs(&mut self, secret: &SecretKey, chain_id: &ChainId) {
        use itertools::Itertools;

        let pk = PublicKey::from(secret);
        let pk = Input::owner(&pk);
        let id = self.id(chain_id);

        let message = Message::from_bytes_ref(&id);

        let signature = Signature::sign(secret, message);

        let inputs = self.inputs();

        let witness_indexes = inputs
            .iter()
            .filter_map(|input| match input {
                Input::CoinSigned(CoinSigned {
                    owner,
                    witness_index,
                    ..
                })
                | Input::MessageCoinSigned(MessageCoinSigned {
                    recipient: owner,
                    witness_index,
                    ..
                })
                | Input::MessageDataSigned(MessageDataSigned {
                    recipient: owner,
                    witness_index,
                    ..
                }) if owner == &pk => Some(*witness_index as usize),
                _ => None,
            })
            .sorted()
            .dedup()
            .collect_vec();

        for w in witness_indexes {
            if let Some(w) = self.witnesses_mut().get_mut(w) {
                *w = signature.as_ref().into();
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        field::*,
        input,
        input::{
            coin::{
                CoinPredicate,
                CoinSigned,
            },
            message::{
                MessageCoinPredicate,
                MessageCoinSigned,
                MessageDataPredicate,
                MessageDataSigned,
            },
        },
        output,
        test_helper::{
            generate_bytes,
            generate_nonempty_padded_bytes,
        },
        Buildable,
        Input,
        Output,
        StorageSlot,
        Transaction,
        UpgradePurpose as UpgradePurposeType,
        UploadBody,
        UtxoId,
    };
    use core::{
        mem,
        ops::Not,
    };
    use fuel_types::{
        canonical::{
            Deserialize,
            Serialize,
        },
        ChainId,
    };
    use rand::{
        rngs::StdRng,
        Rng,
        RngCore,
        SeedableRng,
    };

    fn invert<B>(mut bytes: B)
    where
        B: AsMut<[u8]>,
    {
        bytes.as_mut().iter_mut().for_each(|b| *b = b.not());
    }

    fn invert_utxo_id(utxo_id: &mut UtxoId) {
        let mut tx_id = *utxo_id.tx_id();
        invert(&mut tx_id);
        let out_idx = utxo_id.output_index().not();

        *utxo_id = UtxoId::new(tx_id, out_idx)
    }

    fn invert_storage_slot(storage_slot: &mut StorageSlot) {
        let mut data = storage_slot.to_bytes();
        invert(&mut data);
        *storage_slot =
            StorageSlot::from_bytes(&data).expect("Failed to decode storage slot");
    }

    fn inv_v(bytes: &mut Vec<u8>) {
        if bytes.is_empty() {
            bytes.push(0xfb);
        } else {
            invert(bytes.as_mut_slice());
        }
    }

    fn not<T>(t: &mut T)
    where
        T: Copy + Not<Output = T>,
    {
        let mut t_p = t.not();
        mem::swap(t, &mut t_p);
    }

    fn assert_id_eq<Tx: Buildable, F>(tx: &Tx, mut f: F)
    where
        F: FnMut(&mut Tx),
    {
        let mut tx_p = tx.clone();

        let tx_q = tx.clone();

        f(&mut tx_p);

        let chain_id = ChainId::default();

        assert_eq!(tx.id(&chain_id), tx_p.id(&chain_id));
        assert_eq!(tx.id(&chain_id), tx_q.id(&chain_id));
    }

    fn assert_id_ne<Tx: Buildable, F>(tx: &Tx, mut f: F)
    where
        F: FnMut(&mut Tx),
    {
        let mut tx_p = tx.clone();

        f(&mut tx_p);

        let tx_q = tx_p.clone();

        let chain_id = ChainId::default();

        assert_ne!(tx.id(&chain_id), tx_p.id(&chain_id));
        assert_ne!(tx.id(&chain_id), tx_q.id(&chain_id));
    }

    macro_rules! assert_io_ne {
        ($tx:expr, $t:ident, $i:path, $a:ident, $inv:expr) => {
            assert_id_ne($tx, |t| {
                t.$t().iter_mut().for_each(|x| match x {
                    $i { $a, .. } => $inv($a),
                    _ => (),
                })
            });
        };
        ($tx:expr, $t:ident, $i:path[$it:path], $a:ident, $inv:expr) => {
            assert_id_ne($tx, |t| {
                t.$t().iter_mut().for_each(|x| match x {
                    $i($it { $a, .. }) => $inv($a),
                    _ => (),
                })
            });
        };
    }

    macro_rules! assert_io_eq {
        ($tx:expr, $t:ident, $i:path, $a:ident, $inv:expr) => {
            assert_id_eq($tx, |t| {
                t.$t().iter_mut().for_each(|x| match x {
                    $i { $a, .. } => $inv($a),
                    _ => (),
                })
            });
        };
        ($tx:expr, $t:ident, $i:path[$it:path], $a:ident, $inv:expr) => {
            assert_id_eq($tx, |t| {
                t.$t().iter_mut().for_each(|x| match x {
                    $i($it { $a, .. }) => $inv($a),
                    _ => (),
                })
            });
        };
    }

    fn assert_id_common_attrs<Tx: Buildable>(tx: &Tx) {
        use core::ops::Deref;
        assert_id_ne(tx, |t| t.set_tip(t.tip().not()));
        assert_id_ne(tx, |t| t.set_maturity((t.maturity().deref().not()).into()));

        if !tx.inputs().is_empty() {
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinSigned[CoinSigned],
                utxo_id,
                invert_utxo_id
            );
            assert_io_ne!(tx, inputs_mut, Input::CoinSigned[CoinSigned], owner, invert);
            assert_io_ne!(tx, inputs_mut, Input::CoinSigned[CoinSigned], amount, not);
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinSigned[CoinSigned],
                asset_id,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinSigned[CoinSigned],
                witness_index,
                not
            );

            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinPredicate[CoinPredicate],
                utxo_id,
                invert_utxo_id
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinPredicate[CoinPredicate],
                owner,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinPredicate[CoinPredicate],
                amount,
                not
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinPredicate[CoinPredicate],
                asset_id,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinPredicate[CoinPredicate],
                predicate,
                inv_v
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::CoinPredicate[CoinPredicate],
                predicate_data,
                inv_v
            );

            assert_io_eq!(
                tx,
                inputs_mut,
                Input::Contract[input::contract::Contract],
                utxo_id,
                invert_utxo_id
            );
            assert_io_eq!(
                tx,
                inputs_mut,
                Input::Contract[input::contract::Contract],
                balance_root,
                invert
            );
            assert_io_eq!(
                tx,
                inputs_mut,
                Input::Contract[input::contract::Contract],
                state_root,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::Contract[input::contract::Contract],
                contract_id,
                invert
            );

            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinSigned[MessageCoinSigned],
                sender,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinSigned[MessageCoinSigned],
                recipient,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinSigned[MessageCoinSigned],
                amount,
                not
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinSigned[MessageCoinSigned],
                nonce,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinSigned[MessageCoinSigned],
                witness_index,
                not
            );

            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataSigned[MessageDataSigned],
                sender,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataSigned[MessageDataSigned],
                recipient,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataSigned[MessageDataSigned],
                amount,
                not
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataSigned[MessageDataSigned],
                nonce,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataSigned[MessageDataSigned],
                witness_index,
                not
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataSigned[MessageDataSigned],
                data,
                inv_v
            );

            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                sender,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinPredicate[MessageCoinPredicate],
                recipient,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinPredicate[MessageCoinPredicate],
                amount,
                not
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinPredicate[MessageCoinPredicate],
                nonce,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinPredicate[MessageCoinPredicate],
                predicate,
                inv_v
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageCoinPredicate[MessageCoinPredicate],
                predicate_data,
                inv_v
            );

            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                sender,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                recipient,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                amount,
                not
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                data,
                inv_v
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                nonce,
                invert
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                data,
                inv_v
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                predicate,
                inv_v
            );
            assert_io_ne!(
                tx,
                inputs_mut,
                Input::MessageDataPredicate[MessageDataPredicate],
                predicate_data,
                inv_v
            );
        }

        if !tx.outputs().is_empty() {
            assert_io_ne!(tx, outputs_mut, Output::Coin, to, invert);
            assert_io_ne!(tx, outputs_mut, Output::Coin, amount, not);
            assert_io_ne!(tx, outputs_mut, Output::Coin, asset_id, invert);

            assert_io_ne!(
                tx,
                outputs_mut,
                Output::Contract[output::contract::Contract],
                input_index,
                not
            );
            assert_io_eq!(
                tx,
                outputs_mut,
                Output::Contract[output::contract::Contract],
                balance_root,
                invert
            );
            assert_io_eq!(
                tx,
                outputs_mut,
                Output::Contract[output::contract::Contract],
                state_root,
                invert
            );

            assert_io_ne!(tx, outputs_mut, Output::Change, to, invert);
            assert_io_eq!(tx, outputs_mut, Output::Change, amount, not);
            assert_io_ne!(tx, outputs_mut, Output::Change, asset_id, invert);

            assert_io_eq!(tx, outputs_mut, Output::Variable, to, invert);
            assert_io_eq!(tx, outputs_mut, Output::Variable, amount, not);
            assert_io_eq!(tx, outputs_mut, Output::Variable, asset_id, invert);

            assert_io_ne!(
                tx,
                outputs_mut,
                Output::ContractCreated,
                contract_id,
                invert
            );
        }

        if !tx.witnesses().is_empty() {
            assert_id_eq(tx, |t| {
                inv_v(t.witnesses_mut().first_mut().unwrap().as_vec_mut())
            });
        }
    }

    #[test]
    fn id() {
        let rng = &mut StdRng::seed_from_u64(8586);

        let inputs = [
            vec![],
            vec![
                Input::coin_signed(
                    rng.gen(),
                    rng.gen(),
                    rng.next_u64(),
                    rng.gen(),
                    rng.gen(),
                    rng.gen(),
                ),
                Input::coin_predicate(
                    rng.gen(),
                    rng.gen(),
                    rng.next_u64(),
                    rng.gen(),
                    rng.gen(),
                    rng.gen(),
                    generate_nonempty_padded_bytes(rng),
                    generate_bytes(rng),
                ),
                Input::contract(rng.gen(), rng.gen(), rng.gen(), rng.gen(), rng.gen()),
                Input::message_coin_signed(
                    rng.gen(),
                    rng.gen(),
                    rng.next_u64(),
                    rng.gen(),
                    rng.gen(),
                ),
                Input::message_coin_predicate(
                    rng.gen(),
                    rng.gen(),
                    rng.next_u64(),
                    rng.gen(),
                    rng.gen(),
                    generate_nonempty_padded_bytes(rng),
                    generate_bytes(rng),
                ),
                Input::message_data_signed(
                    rng.gen(),
                    rng.gen(),
                    rng.next_u64(),
                    rng.gen(),
                    rng.gen(),
                    generate_nonempty_padded_bytes(rng),
                ),
                Input::message_data_predicate(
                    rng.gen(),
                    rng.gen(),
                    rng.next_u64(),
                    rng.gen(),
                    rng.gen(),
                    generate_nonempty_padded_bytes(rng),
                    generate_nonempty_padded_bytes(rng),
                    generate_bytes(rng),
                ),
            ],
        ];

        let outputs = [
            vec![],
            vec![
                Output::coin(rng.gen(), rng.next_u64(), rng.gen()),
                Output::contract(rng.gen(), rng.gen(), rng.gen()),
                Output::change(rng.gen(), rng.next_u64(), rng.gen()),
                Output::variable(rng.gen(), rng.next_u64(), rng.gen()),
                Output::contract_created(rng.gen(), rng.gen()),
            ],
        ];

        let witnesses = [
            vec![],
            vec![generate_bytes(rng).into(), generate_bytes(rng).into()],
        ];

        let scripts = [vec![], generate_bytes(rng), generate_bytes(rng)];
        let script_data = [vec![], generate_bytes(rng), generate_bytes(rng)];
        let storage_slots = [vec![], vec![rng.gen(), rng.gen()]];
        let purposes = [
            UpgradePurposeType::ConsensusParameters {
                witness_index: rng.gen(),
                checksum: rng.gen(),
            },
            UpgradePurposeType::StateTransition { root: rng.gen() },
        ];

        for inputs in inputs.iter() {
            for outputs in outputs.iter() {
                for witnesses in witnesses.iter() {
                    for script in scripts.iter() {
                        for script_data in script_data.iter() {
                            let tx = Transaction::script(
                                rng.next_u64(),
                                script.clone(),
                                script_data.clone(),
                                rng.gen(),
                                inputs.clone(),
                                outputs.clone(),
                                witnesses.clone(),
                            );

                            assert_id_common_attrs(&tx);
                            assert_id_ne(&tx, |t| {
                                t.set_script_gas_limit(t.script_gas_limit().not())
                            });
                            assert_id_ne(&tx, |t| inv_v(t.script_mut()));
                            assert_id_ne(&tx, |t| inv_v(t.script_data_mut()));
                        }
                    }

                    for storage_slots in storage_slots.iter() {
                        let tx = Transaction::create(
                            rng.gen(),
                            rng.gen(),
                            rng.gen(),
                            storage_slots.clone(),
                            inputs.clone(),
                            outputs.clone(),
                            witnesses.clone(),
                        );

                        assert_id_ne(&tx, |t| not(t.bytecode_witness_index_mut()));
                        assert_id_ne(&tx, |t| invert(t.salt_mut()));
                        assert_id_ne(&tx, |t| invert(t.salt_mut()));

                        if !storage_slots.is_empty() {
                            assert_id_ne(&tx, |t| {
                                invert_storage_slot(
                                    t.storage_slots_mut().first_mut().unwrap(),
                                )
                            });
                        }

                        assert_id_common_attrs(&tx);
                    }

                    for purpose in purposes.iter() {
                        let tx = Transaction::upgrade(
                            *purpose,
                            rng.gen(),
                            inputs.clone(),
                            outputs.clone(),
                            witnesses.clone(),
                        );

                        assert_id_common_attrs(&tx);
                        assert_id_ne(&tx, |t| match t.upgrade_purpose_mut() {
                            UpgradePurposeType::ConsensusParameters {
                                witness_index,
                                checksum,
                            } => {
                                *witness_index = witness_index.not();
                                invert(checksum);
                            }
                            UpgradePurposeType::StateTransition { root } => {
                                invert(root);
                            }
                        });
                    }

                    // Upload
                    {
                        let tx = Transaction::upload(
                            UploadBody {
                                root: rng.gen(),
                                witness_index: rng.gen(),
                                subsection_index: rng.gen(),
                                subsections_number: rng.gen(),
                                proof_set: vec![rng.gen(), rng.gen(), rng.gen()],
                            },
                            rng.gen(),
                            inputs.clone(),
                            outputs.clone(),
                            witnesses.clone(),
                        );

                        assert_id_common_attrs(&tx);
                        assert_id_ne(&tx, |t| invert(t.bytecode_root_mut()));
                        assert_id_ne(&tx, |t| not(t.bytecode_witness_index_mut()));
                        assert_id_ne(&tx, |t| not(t.subsection_index_mut()));
                        assert_id_ne(&tx, |t| not(t.subsections_number_mut()));
                        assert_id_ne(&tx, |t| {
                            t.proof_set_mut().iter_mut().for_each(invert)
                        });
                    }
                }
            }
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/validity/error.rs

Source
use crate::UtxoId;
use fuel_types::{
    AssetId,
    ContractId,
    MessageId,
};

/// The error returned during the checking of the transaction's validity rules.
#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Hash,
    derive_more::Display,
    serde::Serialize,
    serde::Deserialize,
)]
#[non_exhaustive]
pub enum ValidityError {
    /// The actual and calculated metadata of the transaction mismatch.
    TransactionMetadataMismatch,
    /// Transaction doesn't have spendable input message or coin.
    NoSpendableInput,
    InputWitnessIndexBounds {
        index: usize,
    },
    InputPredicateEmpty {
        index: usize,
    },
    InputPredicateLength {
        index: usize,
    },
    InputPredicateDataLength {
        index: usize,
    },
    InputPredicateOwner {
        index: usize,
    },
    InputInvalidSignature {
        index: usize,
    },
    InputContractAssociatedOutputContract {
        index: usize,
    },
    InputMessageDataLength {
        index: usize,
    },
    DuplicateInputUtxoId {
        utxo_id: UtxoId,
    },
    DuplicateMessageInputId {
        message_id: MessageId,
    },
    DuplicateInputContractId {
        contract_id: ContractId,
    },
    OutputContractInputIndex {
        index: usize,
    },
    /// One of inputs' `AssetId` is not base asset id.
    TransactionInputContainsNonBaseAssetId {
        index: usize,
    },
    /// One of inputs is a `Input::Contract` when it is not allowed.
    TransactionInputContainsContract {
        index: usize,
    },
    /// One of inputs contains retryable message when it is not allowed.
    TransactionInputContainsMessageData {
        index: usize,
    },
    /// One of outputs is a `Output::Contract` when it is not allowed.
    TransactionOutputContainsContract {
        index: usize,
    },
    /// One of outputs is a `Output::Variable` when it is not allowed.
    TransactionOutputContainsVariable {
        index: usize,
    },
    /// One of `Output::Change` outputs uses a non-base asset id.
    TransactionChangeChangeUsesNotBaseAsset {
        index: usize,
    },
    TransactionCreateOutputContractCreatedDoesntMatch {
        index: usize,
    },
    TransactionCreateOutputContractCreatedMultiple {
        index: usize,
    },
    TransactionCreateBytecodeLen,
    TransactionCreateBytecodeWitnessIndex,
    TransactionCreateStorageSlotMax,
    TransactionCreateStorageSlotOrder,
    TransactionScriptLength,
    TransactionScriptDataLength,
    /// The output contains a `Output::ContractCreated` which is not allowed.
    TransactionOutputContainsContractCreated {
        index: usize,
    },
    /// The block height of the checking doesn't match the transaction's block height.
    /// `Mint` transaction only exists in the scope of the block.
    TransactionMintIncorrectBlockHeight,
    /// The `Output.input_index` is not zero.
    TransactionMintIncorrectOutputIndex,
    /// The `Output.mint_base_asset` is not base asset.
    TransactionMintNonBaseAsset,
    /// The `Upgrade` transaction doesn't have the privileged address as the input
    /// owner.
    TransactionUpgradeNoPrivilegedAddress,
    /// The `Upgrade` transaction's checksum doesn't match the consensus parameters from
    /// witness.
    TransactionUpgradeConsensusParametersChecksumMismatch,
    /// The `Upgrade` transaction's consensus parameters serialization failed.
    TransactionUpgradeConsensusParametersSerialization,
    /// The `Upgrade` transaction's consensus parameters deserialization failed.
    TransactionUpgradeConsensusParametersDeserialization,
    /// The verification of the bytecode root of the `Upload` transaction failed.
    TransactionUploadRootVerificationFailed,
    /// The total number of bytecode subsections in the `Upload` transaction exceeds the
    /// limit.
    TransactionUploadTooManyBytecodeSubsections,
    /// The transaction exceeded the size limit.
    TransactionSizeLimitExceeded,
    /// Max gas per tx exceeded
    TransactionMaxGasExceeded,
    TransactionWitnessLimitExceeded,
    TransactionPoliciesAreInvalid,
    TransactionNoGasPricePolicy,
    TransactionMaturity,
    TransactionMaxFeeNotSet,
    TransactionInputsMax,
    TransactionOutputsMax,
    TransactionWitnessesMax,
    TransactionOutputChangeAssetIdDuplicated(AssetId),
    TransactionOutputChangeAssetIdNotFound(AssetId),
    /// This error happens when a transaction attempts to create a coin output for an
    /// asset type that doesn't exist in the coin inputs.
    TransactionOutputCoinAssetIdNotFound(AssetId),
    /// The transaction doesn't provide enough input amount of the native chain asset to
    /// cover all potential execution fees
    #[display(
        fmt = "Insufficient fee amount: expected {}, provided {}",
        expected,
        provided
    )]
    InsufficientFeeAmount {
        /// The expected amount of fees required to cover the transaction
        expected: u64,
        /// The fee amount actually provided for spending
        provided: u64,
    },
    /// The transaction doesn't provide enough input amount of the given asset to cover
    /// the amounts used in the outputs.
    #[display(
        fmt = "Insufficient input amount: asset {}, expected {}, provided {}",
        asset,
        expected,
        provided
    )]
    InsufficientInputAmount {
        /// The asset id being spent
        asset: AssetId,
        /// The amount expected by a coin output
        expected: u64,
        /// The total amount provided by coin inputs
        provided: u64,
    },
    /// The given coins is too large
    BalanceOverflow,
    /// The given gas costs is are too large
    GasCostsCoinsOverflow,
    /// Serialized input length is too large.
    SerializedInputTooLarge {
        index: usize,
    },
    /// Serialized output length is too large.
    SerializedOutputTooLarge {
        index: usize,
    },
    /// Serialized witness length is too large.
    SerializedWitnessTooLarge {
        index: usize,
    },
    /// The `Create` transaction doesn't contain `Output::ContractCreated`.
    TransactionOutputDoesntContainContractCreated,
    /// Blob id of the transaction differs from the data.
    TransactionBlobIdVerificationFailed,
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/policies.rs

Source
use core::ops::Deref;
use fuel_types::{
    canonical::{
        Deserialize,
        Error,
        Input,
        Output,
        Serialize,
    },
    BlockHeight,
    Word,
};

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

bitflags::bitflags! {
    /// See https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/policy.md#policy
    #[derive(Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
    #[derive(serde::Serialize, serde::Deserialize)]
    pub struct PoliciesBits: u32 {
        /// If set, the gas price is present in the policies.
        const Tip = 1 << 0;
        /// If set, the witness limit is present in the policies.
        const WitnessLimit = 1 << 1;
        /// If set, the maturity is present in the policies.
        const Maturity = 1 << 2;
        /// If set, the max fee is present in the policies.
        const MaxFee = 1 << 3;
    }
}

#[cfg(feature = "da-compression")]
impl fuel_compression::Compressible for PoliciesBits {
    type Compressed = u32;
}

#[cfg(feature = "da-compression")]
impl<Ctx> fuel_compression::CompressibleBy<Ctx> for PoliciesBits
where
    Ctx: fuel_compression::ContextError,
{
    async fn compress_with(&self, _: &mut Ctx) -> Result<Self::Compressed, Ctx::Error> {
        Ok(self.bits())
    }
}

#[cfg(feature = "da-compression")]
impl<Ctx> fuel_compression::DecompressibleBy<Ctx> for PoliciesBits
where
    Ctx: fuel_compression::ContextError,
{
    async fn decompress_with(c: Self::Compressed, _: &Ctx) -> Result<Self, Ctx::Error> {
        Ok(Self::from_bits_truncate(c))
    }
}

/// The helper enum to make user-friendly API for [`Policies::set`] and [`Policies::get`]
/// methods.
#[derive(
    Clone,
    Copy,
    Debug,
    PartialEq,
    Eq,
    Hash,
    strum_macros::EnumCount,
    strum_macros::EnumIter,
    serde::Serialize,
    serde::Deserialize,
)]
pub enum PolicyType {
    Tip,
    WitnessLimit,
    Maturity,
    MaxFee,
}

impl PolicyType {
    pub const fn index(&self) -> usize {
        match self {
            PolicyType::Tip => 0,
            PolicyType::WitnessLimit => 1,
            PolicyType::Maturity => 2,
            PolicyType::MaxFee => 3,
        }
    }

    pub const fn bit(&self) -> PoliciesBits {
        match self {
            PolicyType::Tip => PoliciesBits::Tip,
            PolicyType::WitnessLimit => PoliciesBits::WitnessLimit,
            PolicyType::Maturity => PoliciesBits::Maturity,
            PolicyType::MaxFee => PoliciesBits::MaxFee,
        }
    }
}

/// The total number of policies.
pub const POLICIES_NUMBER: usize = PoliciesBits::all().bits().count_ones() as usize;

/// Container for managing policies.
#[derive(
    Clone, Copy, Default, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
pub struct Policies {
    /// A bitmask that indicates what policies are set.
    bits: PoliciesBits,
    /// The array of policy values.
    values: [Word; POLICIES_NUMBER],
}

impl Policies {
    /// Creates an empty `Self`.
    pub const fn new() -> Self {
        Self {
            bits: PoliciesBits::empty(),
            values: [0; POLICIES_NUMBER],
        }
    }

    /// Returns `true` if no policies are set.
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Returns the number of set policies.
    pub fn len(&self) -> usize {
        self.bits.bits().count_ones() as usize
    }

    /// Returns the bit mask of the policies.
    pub fn bits(&self) -> u32 {
        self.bits.bits()
    }

    /// Sets the `gas_price` policy.
    pub fn with_tip(mut self, tip: Word) -> Self {
        self.set(PolicyType::Tip, Some(tip));
        self
    }

    /// Sets the `witness_limit` policy.
    pub fn with_witness_limit(mut self, witness_limit: Word) -> Self {
        self.set(PolicyType::WitnessLimit, Some(witness_limit));
        self
    }

    /// Sets the `maturity` policy.
    pub fn with_maturity(mut self, maturity: BlockHeight) -> Self {
        self.set(PolicyType::Maturity, Some(*maturity.deref() as u64));
        self
    }

    /// Sets the `max_fee` policy.
    pub fn with_max_fee(mut self, max_fee: Word) -> Self {
        self.set(PolicyType::MaxFee, Some(max_fee));
        self
    }

    /// Returns a policy's value if the corresponding bit is set.
    pub fn get(&self, policy_type: PolicyType) -> Option<Word> {
        if self.bits.contains(policy_type.bit()) {
            Some(self.values[policy_type.index()])
        } else {
            None
        }
    }

    /// Returns `true` if the policy is set.
    pub fn is_set(&self, policy_type: PolicyType) -> bool {
        self.bits.contains(policy_type.bit())
    }

    /// Returns a policy's type by the `index`.
    pub fn get_type_by_index(&self, index: usize) -> Option<u32> {
        self.bits.iter().nth(index).map(|bit| bit.bits())
    }

    /// Sets a policy's value if the `value` is `Some`, otherwise, unset it.
    pub fn set(&mut self, policy_type: PolicyType, value: Option<Word>) {
        if let Some(value) = value {
            self.bits.insert(policy_type.bit());
            self.values[policy_type.index()] = value;
        } else {
            self.bits.remove(policy_type.bit());
            self.values[policy_type.index()] = 0;
        }
    }

    /// Returns `true` if the `Self` follows all rules from the specification.
    pub fn is_valid(&self) -> bool {
        let expected_values = Self::values_for_bitmask(self.bits, self.values);

        if self.bits.bits() > PoliciesBits::all().bits() {
            return false;
        }

        if self.values != expected_values {
            return false;
        }

        if let Some(maturity) = self.get(PolicyType::Maturity) {
            if maturity > u32::MAX as u64 {
                return false;
            }
        }

        true
    }

    /// Helper function to generate values arrays based on the `PoliciesBits`.
    fn values_for_bitmask(
        bits: PoliciesBits,
        default_values: [Word; POLICIES_NUMBER],
    ) -> [Word; POLICIES_NUMBER] {
        use strum::IntoEnumIterator;
        let mut values = [0; POLICIES_NUMBER];
        for policy_type in PolicyType::iter() {
            if bits.contains(policy_type.bit()) {
                values[policy_type.index()] = default_values[policy_type.index()];
            }
        }
        values
    }
}

impl Serialize for Policies {
    fn size_static(&self) -> usize {
        self.bits.bits().size_static()
    }

    #[allow(clippy::arithmetic_side_effects)] // Bit count is not large enough to overflow.
    fn size_dynamic(&self) -> usize {
        self.bits.bits().count_ones() as usize * Word::MIN.size()
    }

    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        self.bits.bits().encode_static(buffer)
    }

    fn encode_dynamic<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        for (value, bit) in self.values.iter().zip(PoliciesBits::all().iter()) {
            if self.bits.contains(bit) {
                value.encode(buffer)?;
            }
        }
        Ok(())
    }
}

impl Deserialize for Policies {
    fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error> {
        let bits = u32::decode(buffer)?;
        let bits = PoliciesBits::from_bits(bits)
            .ok_or(Error::Unknown("Invalid policies bits"))?;
        Ok(Self {
            bits,
            values: Default::default(),
        })
    }

    fn decode_dynamic<I: Input + ?Sized>(&mut self, buffer: &mut I) -> Result<(), Error> {
        for (index, bit) in PoliciesBits::all().iter().enumerate() {
            if self.bits.contains(bit) {
                self.values[index] = Word::decode(buffer)?;
            }
        }

        if let Some(maturity) = self.get(PolicyType::Maturity) {
            if maturity > u32::MAX as u64 {
                return Err(Error::Unknown("The maturity in more than `u32::MAX`"));
            }
        }

        Ok(())
    }
}

#[cfg(feature = "random")]
impl Distribution<Policies> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Policies {
        let bits: u32 = rng.gen();
        let bits = bits & PoliciesBits::all().bits();
        let bits = PoliciesBits::from_bits(bits).expect("We checked that above");
        let values = rng.gen();
        let mut policies = Policies {
            bits,
            values: Policies::values_for_bitmask(bits, values),
        };

        if policies.get(PolicyType::Maturity).is_some() {
            let maturity: u32 = rng.gen();
            policies.set(PolicyType::Maturity, Some(maturity as u64));
        }

        policies
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use crate::transaction::Policies;
    use alloc::{
        format,
        string::String,
        vec::Vec,
    };

    #[wasm_bindgen]
    impl Policies {
        #[wasm_bindgen(constructor)]
        pub fn typescript_new() -> Policies {
            Policies::default()
        }

        #[wasm_bindgen(js_name = toJSON)]
        pub fn to_json(&self) -> String {
            serde_json::to_string(&self).expect("unable to json format")
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:?}", self)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            <Self as Serialize>::to_bytes(self)
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<Policies, js_sys::Error> {
            use fuel_types::canonical::Deserialize;
            <Self as Deserialize>::from_bytes(value)
                .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
        }
    }
}

#[test]
fn values_for_bitmask_produces_expected_values() {
    const MAX_BITMASK: u32 = 1 << POLICIES_NUMBER;
    const VALUES: [Word; POLICIES_NUMBER] = [0x1000001, 0x2000001, 0x3000001, 0x4000001];

    // Given
    let mut set = hashbrown::HashSet::new();

    // When
    for bitmask in 0..MAX_BITMASK {
        let bits =
            PoliciesBits::from_bits(bitmask).expect("Should construct a valid bits");
        set.insert(Policies::values_for_bitmask(bits, VALUES));
    }

    // Then
    assert_eq!(set.len(), MAX_BITMASK as usize);
}

#[test]
fn canonical_serialization_deserialization_for_any_combination_of_values_works() {
    const MAX_BITMASK: u32 = 1 << POLICIES_NUMBER;
    const VALUES: [Word; POLICIES_NUMBER] = [0x1000001, 0x2000001, 0x3000001, 0x4000001];

    for bitmask in 0..MAX_BITMASK {
        let bits =
            PoliciesBits::from_bits(bitmask).expect("Should construct a valid bits");
        let policies = Policies {
            bits,
            values: Policies::values_for_bitmask(bits, VALUES),
        };

        let size = policies.size();
        let mut buffer = vec![0u8; size];
        policies
            .encode(&mut buffer.as_mut_slice())
            .expect("Should encode without error");

        let new_policies = Policies::decode(&mut buffer.as_slice())
            .expect("Should decode without error");

        assert_eq!(policies, new_policies);
        assert_eq!(new_policies.bits.bits(), bitmask);

        for (index, bit) in PoliciesBits::all().iter().enumerate() {
            if policies.bits.contains(bit) {
                assert_eq!(VALUES[index], new_policies.values[index]);
            } else {
                assert_eq!(0, new_policies.values[index]);
            }
        }

        assert_eq!(new_policies.size(), size);
        // `bitmask.count_ones()` - the number of serialized values
        assert_eq!(
            size,
            (policies.bits.bits().size()
                + bitmask.count_ones() as usize * Word::MIN.size())
        );
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/consensus_parameters/gas.rs

Source
//! Tools for gas instrumentalization

use core::ops::Deref;

#[cfg(feature = "alloc")]
use alloc::sync::Arc;

use fuel_asm::PanicReason;
use fuel_types::Word;

/// Default gas costs are generated from the
/// `fuel-core` repo using the `collect` bin
/// in the `fuel-core-benches` crate.
/// The git sha is included in the file to
/// show what version of `fuel-core` was used
/// to generate the costs.
#[allow(dead_code)]
mod default_gas_costs;

/// Gas costings for every op.
/// The inner values are wrapped in an [`Arc`]
/// so this is cheap to clone.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg(feature = "alloc")]
pub struct GasCosts(Arc<GasCostsValues>);

#[cfg(feature = "alloc")]
impl<'de> serde::Deserialize<'de> for GasCosts {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        Ok(GasCosts(Arc::new(serde::Deserialize::deserialize(
            deserializer,
        )?)))
    }
}

#[cfg(feature = "alloc")]
impl serde::Serialize for GasCosts {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serde::Serialize::serialize(self.0.as_ref(), serializer)
    }
}

#[cfg(feature = "alloc")]
impl GasCosts {
    /// Create new cost values wrapped in an [`Arc`].
    pub fn new(costs: GasCostsValues) -> Self {
        Self(Arc::new(costs))
    }
}

#[cfg(feature = "alloc")]
impl Default for GasCosts {
    fn default() -> Self {
        Self(Arc::new(GasCostsValues::default()))
    }
}

impl Default for GasCostsValues {
    fn default() -> Self {
        // The default values for gas costs
        // are generated from fuel-core-benches.
        default_gas_costs::default_gas_costs()
    }
}

/// The versioned gas costs for every op.
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub enum GasCostsValues {
    /// Version 1 of the gas costs.
    V1(GasCostsValuesV1),
    /// Version 2 of the gas costs.
    V2(GasCostsValuesV2),
    /// Version 3 of the gas costs.
    V3(GasCostsValuesV3),
    /// Version 4 of the gas costs.
    V4(GasCostsValuesV4),
}

/// Gas cost for this instruction is not defined for this version.
pub struct GasCostNotDefined;

impl From<GasCostNotDefined> for PanicReason {
    fn from(_: GasCostNotDefined) -> PanicReason {
        PanicReason::GasCostNotDefined
    }
}

#[allow(missing_docs)]
impl GasCostsValues {
    pub fn add(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.add,
            GasCostsValues::V2(v2) => v2.add,
            GasCostsValues::V3(v3) => v3.add,
            GasCostsValues::V4(v4) => v4.add,
        }
    }

    pub fn addi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.addi,
            GasCostsValues::V2(v2) => v2.addi,
            GasCostsValues::V3(v3) => v3.addi,
            GasCostsValues::V4(v4) => v4.addi,
        }
    }

    pub fn and(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.and,
            GasCostsValues::V2(v2) => v2.and,
            GasCostsValues::V3(v3) => v3.and,
            GasCostsValues::V4(v4) => v4.and,
        }
    }

    pub fn andi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.andi,
            GasCostsValues::V2(v2) => v2.andi,
            GasCostsValues::V3(v3) => v3.andi,
            GasCostsValues::V4(v4) => v4.andi,
        }
    }

    pub fn bal(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.bal,
            GasCostsValues::V2(v2) => v2.bal,
            GasCostsValues::V3(v3) => v3.bal,
            GasCostsValues::V4(v4) => v4.bal,
        }
    }

    pub fn bhei(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.bhei,
            GasCostsValues::V2(v2) => v2.bhei,
            GasCostsValues::V3(v3) => v3.bhei,
            GasCostsValues::V4(v4) => v4.bhei,
        }
    }

    pub fn bhsh(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.bhsh,
            GasCostsValues::V2(v2) => v2.bhsh,
            GasCostsValues::V3(v3) => v3.bhsh,
            GasCostsValues::V4(v4) => v4.bhsh,
        }
    }

    pub fn burn(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.burn,
            GasCostsValues::V2(v2) => v2.burn,
            GasCostsValues::V3(v3) => v3.burn,
            GasCostsValues::V4(v4) => v4.burn,
        }
    }

    pub fn cb(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.cb,
            GasCostsValues::V2(v2) => v2.cb,
            GasCostsValues::V3(v3) => v3.cb,
            GasCostsValues::V4(v4) => v4.cb,
        }
    }

    pub fn cfsi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.cfsi,
            GasCostsValues::V2(v2) => v2.cfsi,
            GasCostsValues::V3(v3) => v3.cfsi,
            GasCostsValues::V4(v4) => v4.cfsi,
        }
    }

    pub fn div(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.div,
            GasCostsValues::V2(v2) => v2.div,
            GasCostsValues::V3(v3) => v3.div,
            GasCostsValues::V4(v4) => v4.div,
        }
    }

    pub fn divi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.divi,
            GasCostsValues::V2(v2) => v2.divi,
            GasCostsValues::V3(v3) => v3.divi,
            GasCostsValues::V4(v4) => v4.divi,
        }
    }

    pub fn eck1(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.eck1,
            GasCostsValues::V2(v2) => v2.eck1,
            GasCostsValues::V3(v3) => v3.eck1,
            GasCostsValues::V4(v4) => v4.eck1,
        }
    }

    pub fn ecr1(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.ecr1,
            GasCostsValues::V2(v2) => v2.ecr1,
            GasCostsValues::V3(v3) => v3.ecr1,
            GasCostsValues::V4(v4) => v4.ecr1,
        }
    }

    pub fn eq_(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.eq,
            GasCostsValues::V2(v2) => v2.eq,
            GasCostsValues::V3(v3) => v3.eq,
            GasCostsValues::V4(v4) => v4.eq,
        }
    }

    pub fn exp(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.exp,
            GasCostsValues::V2(v2) => v2.exp,
            GasCostsValues::V3(v3) => v3.exp,
            GasCostsValues::V4(v4) => v4.exp,
        }
    }

    pub fn expi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.expi,
            GasCostsValues::V2(v2) => v2.expi,
            GasCostsValues::V3(v3) => v3.expi,
            GasCostsValues::V4(v4) => v4.expi,
        }
    }

    pub fn flag(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.flag,
            GasCostsValues::V2(v2) => v2.flag,
            GasCostsValues::V3(v3) => v3.flag,
            GasCostsValues::V4(v4) => v4.flag,
        }
    }

    pub fn gm(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.gm,
            GasCostsValues::V2(v2) => v2.gm,
            GasCostsValues::V3(v3) => v3.gm,
            GasCostsValues::V4(v4) => v4.gm,
        }
    }

    pub fn gt(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.gt,
            GasCostsValues::V2(v2) => v2.gt,
            GasCostsValues::V3(v3) => v3.gt,
            GasCostsValues::V4(v4) => v4.gt,
        }
    }

    pub fn gtf(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.gtf,
            GasCostsValues::V2(v2) => v2.gtf,
            GasCostsValues::V3(v3) => v3.gtf,
            GasCostsValues::V4(v4) => v4.gtf,
        }
    }

    pub fn ji(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.ji,
            GasCostsValues::V2(v2) => v2.ji,
            GasCostsValues::V3(v3) => v3.ji,
            GasCostsValues::V4(v4) => v4.ji,
        }
    }

    pub fn jmp(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jmp,
            GasCostsValues::V2(v2) => v2.jmp,
            GasCostsValues::V3(v3) => v3.jmp,
            GasCostsValues::V4(v4) => v4.jmp,
        }
    }

    pub fn jne(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jne,
            GasCostsValues::V2(v2) => v2.jne,
            GasCostsValues::V3(v3) => v3.jne,
            GasCostsValues::V4(v4) => v4.jne,
        }
    }

    pub fn jnei(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jnei,
            GasCostsValues::V2(v2) => v2.jnei,
            GasCostsValues::V3(v3) => v3.jnei,
            GasCostsValues::V4(v4) => v4.jnei,
        }
    }

    pub fn jnzi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jnzi,
            GasCostsValues::V2(v2) => v2.jnzi,
            GasCostsValues::V3(v3) => v3.jnzi,
            GasCostsValues::V4(v4) => v4.jnzi,
        }
    }

    pub fn jmpf(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jmpf,
            GasCostsValues::V2(v2) => v2.jmpf,
            GasCostsValues::V3(v3) => v3.jmpf,
            GasCostsValues::V4(v4) => v4.jmpf,
        }
    }

    pub fn jmpb(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jmpb,
            GasCostsValues::V2(v2) => v2.jmpb,
            GasCostsValues::V3(v3) => v3.jmpb,
            GasCostsValues::V4(v4) => v4.jmpb,
        }
    }

    pub fn jnzf(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jnzf,
            GasCostsValues::V2(v2) => v2.jnzf,
            GasCostsValues::V3(v3) => v3.jnzf,
            GasCostsValues::V4(v4) => v4.jnzf,
        }
    }

    pub fn jnzb(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jnzb,
            GasCostsValues::V2(v2) => v2.jnzb,
            GasCostsValues::V3(v3) => v3.jnzb,
            GasCostsValues::V4(v4) => v4.jnzb,
        }
    }

    pub fn jnef(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jnef,
            GasCostsValues::V2(v2) => v2.jnef,
            GasCostsValues::V3(v3) => v3.jnef,
            GasCostsValues::V4(v4) => v4.jnef,
        }
    }

    pub fn jneb(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.jneb,
            GasCostsValues::V2(v2) => v2.jneb,
            GasCostsValues::V3(v3) => v3.jneb,
            GasCostsValues::V4(v4) => v4.jneb,
        }
    }

    pub fn lb(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.lb,
            GasCostsValues::V2(v2) => v2.lb,
            GasCostsValues::V3(v3) => v3.lb,
            GasCostsValues::V4(v4) => v4.lb,
        }
    }

    pub fn log(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.log,
            GasCostsValues::V2(v2) => v2.log,
            GasCostsValues::V3(v3) => v3.log,
            GasCostsValues::V4(v4) => v4.log,
        }
    }

    pub fn lt(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.lt,
            GasCostsValues::V2(v2) => v2.lt,
            GasCostsValues::V3(v3) => v3.lt,
            GasCostsValues::V4(v4) => v4.lt,
        }
    }

    pub fn lw(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.lw,
            GasCostsValues::V2(v2) => v2.lw,
            GasCostsValues::V3(v3) => v3.lw,
            GasCostsValues::V4(v4) => v4.lw,
        }
    }

    pub fn mint(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.mint,
            GasCostsValues::V2(v2) => v2.mint,
            GasCostsValues::V3(v3) => v3.mint,
            GasCostsValues::V4(v4) => v4.mint,
        }
    }

    pub fn mlog(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.mlog,
            GasCostsValues::V2(v2) => v2.mlog,
            GasCostsValues::V3(v3) => v3.mlog,
            GasCostsValues::V4(v4) => v4.mlog,
        }
    }

    pub fn mod_op(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.mod_op,
            GasCostsValues::V2(v2) => v2.mod_op,
            GasCostsValues::V3(v3) => v3.mod_op,
            GasCostsValues::V4(v4) => v4.mod_op,
        }
    }

    pub fn modi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.modi,
            GasCostsValues::V2(v2) => v2.modi,
            GasCostsValues::V3(v3) => v3.modi,
            GasCostsValues::V4(v4) => v4.modi,
        }
    }

    pub fn move_op(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.move_op,
            GasCostsValues::V2(v2) => v2.move_op,
            GasCostsValues::V3(v3) => v3.move_op,
            GasCostsValues::V4(v4) => v4.move_op,
        }
    }

    pub fn movi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.movi,
            GasCostsValues::V2(v2) => v2.movi,
            GasCostsValues::V3(v3) => v3.movi,
            GasCostsValues::V4(v4) => v4.movi,
        }
    }

    pub fn mroo(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.mroo,
            GasCostsValues::V2(v2) => v2.mroo,
            GasCostsValues::V3(v3) => v3.mroo,
            GasCostsValues::V4(v4) => v4.mroo,
        }
    }

    pub fn mul(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.mul,
            GasCostsValues::V2(v2) => v2.mul,
            GasCostsValues::V3(v3) => v3.mul,
            GasCostsValues::V4(v4) => v4.mul,
        }
    }

    pub fn muli(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.muli,
            GasCostsValues::V2(v2) => v2.muli,
            GasCostsValues::V3(v3) => v3.muli,
            GasCostsValues::V4(v4) => v4.muli,
        }
    }

    pub fn mldv(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.mldv,
            GasCostsValues::V2(v2) => v2.mldv,
            GasCostsValues::V3(v3) => v3.mldv,
            GasCostsValues::V4(v4) => v4.mldv,
        }
    }

    pub fn noop(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.noop,
            GasCostsValues::V2(v2) => v2.noop,
            GasCostsValues::V3(v3) => v3.noop,
            GasCostsValues::V4(v4) => v4.noop,
        }
    }

    pub fn not(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.not,
            GasCostsValues::V2(v2) => v2.not,
            GasCostsValues::V3(v3) => v3.not,
            GasCostsValues::V4(v4) => v4.not,
        }
    }

    pub fn or(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.or,
            GasCostsValues::V2(v2) => v2.or,
            GasCostsValues::V3(v3) => v3.or,
            GasCostsValues::V4(v4) => v4.or,
        }
    }

    pub fn ori(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.ori,
            GasCostsValues::V2(v2) => v2.ori,
            GasCostsValues::V3(v3) => v3.ori,
            GasCostsValues::V4(v4) => v4.ori,
        }
    }

    pub fn poph(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.poph,
            GasCostsValues::V2(v2) => v2.poph,
            GasCostsValues::V3(v3) => v3.poph,
            GasCostsValues::V4(v4) => v4.poph,
        }
    }

    pub fn popl(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.popl,
            GasCostsValues::V2(v2) => v2.popl,
            GasCostsValues::V3(v3) => v3.popl,
            GasCostsValues::V4(v4) => v4.popl,
        }
    }

    pub fn pshh(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.pshh,
            GasCostsValues::V2(v2) => v2.pshh,
            GasCostsValues::V3(v3) => v3.pshh,
            GasCostsValues::V4(v4) => v4.pshh,
        }
    }

    pub fn pshl(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.pshl,
            GasCostsValues::V2(v2) => v2.pshl,
            GasCostsValues::V3(v3) => v3.pshl,
            GasCostsValues::V4(v4) => v4.pshl,
        }
    }

    pub fn ret(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.ret,
            GasCostsValues::V2(v2) => v2.ret,
            GasCostsValues::V3(v3) => v3.ret,
            GasCostsValues::V4(v4) => v4.ret,
        }
    }

    pub fn rvrt(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.rvrt,
            GasCostsValues::V2(v2) => v2.rvrt,
            GasCostsValues::V3(v3) => v3.rvrt,
            GasCostsValues::V4(v4) => v4.rvrt,
        }
    }

    pub fn sb(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.sb,
            GasCostsValues::V2(v2) => v2.sb,
            GasCostsValues::V3(v3) => v3.sb,
            GasCostsValues::V4(v4) => v4.sb,
        }
    }

    pub fn sll(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.sll,
            GasCostsValues::V2(v2) => v2.sll,
            GasCostsValues::V3(v3) => v3.sll,
            GasCostsValues::V4(v4) => v4.sll,
        }
    }

    pub fn slli(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.slli,
            GasCostsValues::V2(v2) => v2.slli,
            GasCostsValues::V3(v3) => v3.slli,
            GasCostsValues::V4(v4) => v4.slli,
        }
    }

    pub fn srl(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.srl,
            GasCostsValues::V2(v2) => v2.srl,
            GasCostsValues::V3(v3) => v3.srl,
            GasCostsValues::V4(v4) => v4.srl,
        }
    }

    pub fn srli(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.srli,
            GasCostsValues::V2(v2) => v2.srli,
            GasCostsValues::V3(v3) => v3.srli,
            GasCostsValues::V4(v4) => v4.srli,
        }
    }

    pub fn srw(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.srw,
            GasCostsValues::V2(v2) => v2.srw,
            GasCostsValues::V3(v3) => v3.srw,
            GasCostsValues::V4(v4) => v4.srw,
        }
    }

    pub fn sub(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.sub,
            GasCostsValues::V2(v2) => v2.sub,
            GasCostsValues::V3(v3) => v3.sub,
            GasCostsValues::V4(v4) => v4.sub,
        }
    }

    pub fn subi(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.subi,
            GasCostsValues::V2(v2) => v2.subi,
            GasCostsValues::V3(v3) => v3.subi,
            GasCostsValues::V4(v4) => v4.subi,
        }
    }

    pub fn sw(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.sw,
            GasCostsValues::V2(v2) => v2.sw,
            GasCostsValues::V3(v3) => v3.sw,
            GasCostsValues::V4(v4) => v4.sw,
        }
    }

    pub fn sww(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.sww,
            GasCostsValues::V2(v2) => v2.sww,
            GasCostsValues::V3(v3) => v3.sww,
            GasCostsValues::V4(v4) => v4.sww,
        }
    }

    pub fn time(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.time,
            GasCostsValues::V2(v2) => v2.time,
            GasCostsValues::V3(v3) => v3.time,
            GasCostsValues::V4(v4) => v4.time,
        }
    }

    pub fn tr(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.tr,
            GasCostsValues::V2(v2) => v2.tr,
            GasCostsValues::V3(v3) => v3.tr,
            GasCostsValues::V4(v4) => v4.tr,
        }
    }

    pub fn tro(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.tro,
            GasCostsValues::V2(v2) => v2.tro,
            GasCostsValues::V3(v3) => v3.tro,
            GasCostsValues::V4(v4) => v4.tro,
        }
    }

    pub fn wdcm(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wdcm,
            GasCostsValues::V2(v2) => v2.wdcm,
            GasCostsValues::V3(v3) => v3.wdcm,
            GasCostsValues::V4(v4) => v4.wdcm,
        }
    }

    pub fn wqcm(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqcm,
            GasCostsValues::V2(v2) => v2.wqcm,
            GasCostsValues::V3(v3) => v3.wqcm,
            GasCostsValues::V4(v4) => v4.wqcm,
        }
    }

    pub fn wdop(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wdop,
            GasCostsValues::V2(v2) => v2.wdop,
            GasCostsValues::V3(v3) => v3.wdop,
            GasCostsValues::V4(v4) => v4.wdop,
        }
    }

    pub fn wqop(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqop,
            GasCostsValues::V2(v2) => v2.wqop,
            GasCostsValues::V3(v3) => v3.wqop,
            GasCostsValues::V4(v4) => v4.wqop,
        }
    }

    pub fn wdml(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wdml,
            GasCostsValues::V2(v2) => v2.wdml,
            GasCostsValues::V3(v3) => v3.wdml,
            GasCostsValues::V4(v4) => v4.wdml,
        }
    }

    pub fn wqml(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqml,
            GasCostsValues::V2(v2) => v2.wqml,
            GasCostsValues::V3(v3) => v3.wqml,
            GasCostsValues::V4(v4) => v4.wqml,
        }
    }

    pub fn wddv(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wddv,
            GasCostsValues::V2(v2) => v2.wddv,
            GasCostsValues::V3(v3) => v3.wddv,
            GasCostsValues::V4(v4) => v4.wddv,
        }
    }

    pub fn wqdv(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqdv,
            GasCostsValues::V2(v2) => v2.wqdv,
            GasCostsValues::V3(v3) => v3.wqdv,
            GasCostsValues::V4(v4) => v4.wqdv,
        }
    }

    pub fn wdmd(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wdmd,
            GasCostsValues::V2(v2) => v2.wdmd,
            GasCostsValues::V3(v3) => v3.wdmd,
            GasCostsValues::V4(v4) => v4.wdmd,
        }
    }

    pub fn wqmd(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqmd,
            GasCostsValues::V2(v2) => v2.wqmd,
            GasCostsValues::V3(v3) => v3.wqmd,
            GasCostsValues::V4(v4) => v4.wqmd,
        }
    }

    pub fn wdam(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wdam,
            GasCostsValues::V2(v2) => v2.wdam,
            GasCostsValues::V3(v3) => v3.wdam,
            GasCostsValues::V4(v4) => v4.wdam,
        }
    }

    pub fn wqam(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqam,
            GasCostsValues::V2(v2) => v2.wqam,
            GasCostsValues::V3(v3) => v3.wqam,
            GasCostsValues::V4(v4) => v4.wqam,
        }
    }

    pub fn wdmm(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wdmm,
            GasCostsValues::V2(v2) => v2.wdmm,
            GasCostsValues::V3(v3) => v3.wdmm,
            GasCostsValues::V4(v4) => v4.wdmm,
        }
    }

    pub fn wqmm(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.wqmm,
            GasCostsValues::V2(v2) => v2.wqmm,
            GasCostsValues::V3(v3) => v3.wqmm,
            GasCostsValues::V4(v4) => v4.wqmm,
        }
    }

    pub fn xor(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.xor,
            GasCostsValues::V2(v2) => v2.xor,
            GasCostsValues::V3(v3) => v3.xor,
            GasCostsValues::V4(v4) => v4.xor,
        }
    }

    pub fn xori(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.xori,
            GasCostsValues::V2(v2) => v2.xori,
            GasCostsValues::V3(v3) => v3.xori,
            GasCostsValues::V4(v4) => v4.xori,
        }
    }

    pub fn aloc(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => DependentCost::HeavyOperation {
                base: v1.aloc,
                gas_per_unit: 0,
            },
            GasCostsValues::V2(v2) => v2.aloc,
            GasCostsValues::V3(v3) => v3.aloc,
            GasCostsValues::V4(v4) => v4.aloc,
        }
    }

    pub fn cfe(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => DependentCost::HeavyOperation {
                base: v1.cfei,
                gas_per_unit: 0,
            },
            GasCostsValues::V2(v2) => DependentCost::HeavyOperation {
                base: v2.cfei,
                gas_per_unit: 0,
            },
            GasCostsValues::V3(v3) => v3.cfe,
            GasCostsValues::V4(v4) => v4.cfe,
        }
    }

    pub fn cfei(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => DependentCost::HeavyOperation {
                base: v1.cfei,
                gas_per_unit: 0,
            },
            GasCostsValues::V2(v2) => DependentCost::HeavyOperation {
                base: v2.cfei,
                gas_per_unit: 0,
            },
            GasCostsValues::V3(v3) => v3.cfei,
            GasCostsValues::V4(v4) => v4.cfei,
        }
    }

    pub fn call(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.call,
            GasCostsValues::V2(v2) => v2.call,
            GasCostsValues::V3(v3) => v3.call,
            GasCostsValues::V4(v4) => v4.call,
        }
    }

    pub fn ccp(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.ccp,
            GasCostsValues::V2(v2) => v2.ccp,
            GasCostsValues::V3(v3) => v3.ccp,
            GasCostsValues::V4(v4) => v4.ccp,
        }
    }

    pub fn croo(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.croo,
            GasCostsValues::V2(v2) => v2.croo,
            GasCostsValues::V3(v3) => v3.croo,
            GasCostsValues::V4(v4) => v4.croo,
        }
    }

    pub fn csiz(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.csiz,
            GasCostsValues::V2(v2) => v2.csiz,
            GasCostsValues::V3(v3) => v3.csiz,
            GasCostsValues::V4(v4) => v4.csiz,
        }
    }

    pub fn ed19(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => DependentCost::HeavyOperation {
                base: v1.ed19,
                gas_per_unit: 0,
            },
            GasCostsValues::V2(v2) => DependentCost::HeavyOperation {
                base: v2.ed19,
                gas_per_unit: 0,
            },
            GasCostsValues::V3(v3) => DependentCost::HeavyOperation {
                base: v3.ed19,
                gas_per_unit: 0,
            },
            GasCostsValues::V4(v4) => v4.ed19,
        }
    }

    pub fn k256(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.k256,
            GasCostsValues::V2(v2) => v2.k256,
            GasCostsValues::V3(v3) => v3.k256,
            GasCostsValues::V4(v4) => v4.k256,
        }
    }

    pub fn ldc(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.ldc,
            GasCostsValues::V2(v2) => v2.ldc,
            GasCostsValues::V3(v3) => v3.ldc,
            GasCostsValues::V4(v4) => v4.ldc,
        }
    }

    pub fn logd(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.logd,
            GasCostsValues::V2(v2) => v2.logd,
            GasCostsValues::V3(v3) => v3.logd,
            GasCostsValues::V4(v4) => v4.logd,
        }
    }

    pub fn mcl(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.mcl,
            GasCostsValues::V2(v2) => v2.mcl,
            GasCostsValues::V3(v3) => v3.mcl,
            GasCostsValues::V4(v4) => v4.mcl,
        }
    }

    pub fn mcli(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.mcli,
            GasCostsValues::V2(v2) => v2.mcli,
            GasCostsValues::V3(v3) => v3.mcli,
            GasCostsValues::V4(v4) => v4.mcli,
        }
    }

    pub fn mcp(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.mcp,
            GasCostsValues::V2(v2) => v2.mcp,
            GasCostsValues::V3(v3) => v3.mcp,
            GasCostsValues::V4(v4) => v4.mcp,
        }
    }

    pub fn mcpi(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.mcpi,
            GasCostsValues::V2(v2) => v2.mcpi,
            GasCostsValues::V3(v3) => v3.mcpi,
            GasCostsValues::V4(v4) => v4.mcpi,
        }
    }

    pub fn meq(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.meq,
            GasCostsValues::V2(v2) => v2.meq,
            GasCostsValues::V3(v3) => v3.meq,
            GasCostsValues::V4(v4) => v4.meq,
        }
    }

    pub fn retd(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.retd,
            GasCostsValues::V2(v2) => v2.retd,
            GasCostsValues::V3(v3) => v3.retd,
            GasCostsValues::V4(v4) => v4.retd,
        }
    }

    pub fn s256(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.s256,
            GasCostsValues::V2(v2) => v2.s256,
            GasCostsValues::V3(v3) => v3.s256,
            GasCostsValues::V4(v4) => v4.s256,
        }
    }

    pub fn scwq(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.scwq,
            GasCostsValues::V2(v2) => v2.scwq,
            GasCostsValues::V3(v3) => v3.scwq,
            GasCostsValues::V4(v4) => v4.scwq,
        }
    }

    pub fn smo(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.smo,
            GasCostsValues::V2(v2) => v2.smo,
            GasCostsValues::V3(v3) => v3.smo,
            GasCostsValues::V4(v4) => v4.smo,
        }
    }

    pub fn srwq(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.srwq,
            GasCostsValues::V2(v2) => v2.srwq,
            GasCostsValues::V3(v3) => v3.srwq,
            GasCostsValues::V4(v4) => v4.srwq,
        }
    }

    pub fn swwq(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.swwq,
            GasCostsValues::V2(v2) => v2.swwq,
            GasCostsValues::V3(v3) => v3.swwq,
            GasCostsValues::V4(v4) => v4.swwq,
        }
    }

    pub fn bsiz(&self) -> Result<DependentCost, GasCostNotDefined> {
        match self {
            GasCostsValues::V1(_v1) => Err(GasCostNotDefined),
            GasCostsValues::V2(_v2) => Err(GasCostNotDefined),
            GasCostsValues::V3(_v3) => Err(GasCostNotDefined),
            GasCostsValues::V4(v4) => Ok(v4.bsiz),
        }
    }

    pub fn bldd(&self) -> Result<DependentCost, GasCostNotDefined> {
        match self {
            GasCostsValues::V1(_v1) => Err(GasCostNotDefined),
            GasCostsValues::V2(_v2) => Err(GasCostNotDefined),
            GasCostsValues::V3(_v3) => Err(GasCostNotDefined),
            GasCostsValues::V4(v4) => Ok(v4.bldd),
        }
    }

    pub fn contract_root(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.contract_root,
            GasCostsValues::V2(v2) => v2.contract_root,
            GasCostsValues::V3(v3) => v3.contract_root,
            GasCostsValues::V4(v4) => v4.contract_root,
        }
    }

    pub fn state_root(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.state_root,
            GasCostsValues::V2(v2) => v2.state_root,
            GasCostsValues::V3(v3) => v3.state_root,
            GasCostsValues::V4(v4) => v4.state_root,
        }
    }

    pub fn new_storage_per_byte(&self) -> Word {
        match self {
            GasCostsValues::V1(v1) => v1.new_storage_per_byte,
            GasCostsValues::V2(v2) => v2.new_storage_per_byte,
            GasCostsValues::V3(v3) => v3.new_storage_per_byte,
            GasCostsValues::V4(v4) => v4.new_storage_per_byte,
        }
    }

    pub fn vm_initialization(&self) -> DependentCost {
        match self {
            GasCostsValues::V1(v1) => v1.vm_initialization,
            GasCostsValues::V2(v2) => v2.vm_initialization,
            GasCostsValues::V3(v3) => v3.vm_initialization,
            GasCostsValues::V4(v4) => v4.vm_initialization,
        }
    }
}

/// Gas costs for every op.
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[serde(default = "GasCostsValuesV1::unit")]
pub struct GasCostsValuesV1 {
    pub add: Word,
    pub addi: Word,
    pub aloc: Word,
    pub and: Word,
    pub andi: Word,
    pub bal: Word,
    pub bhei: Word,
    pub bhsh: Word,
    pub burn: Word,
    pub cb: Word,
    pub cfei: Word,
    pub cfsi: Word,
    pub div: Word,
    pub divi: Word,
    pub eck1: Word,
    pub ecr1: Word,
    pub ed19: Word,
    pub eq: Word,
    pub exp: Word,
    pub expi: Word,
    pub flag: Word,
    pub gm: Word,
    pub gt: Word,
    pub gtf: Word,
    pub ji: Word,
    pub jmp: Word,
    pub jne: Word,
    pub jnei: Word,
    pub jnzi: Word,
    pub jmpf: Word,
    pub jmpb: Word,
    pub jnzf: Word,
    pub jnzb: Word,
    pub jnef: Word,
    pub jneb: Word,
    pub lb: Word,
    pub log: Word,
    pub lt: Word,
    pub lw: Word,
    pub mint: Word,
    pub mlog: Word,
    #[serde(rename = "mod")]
    pub mod_op: Word,
    pub modi: Word,
    #[serde(rename = "move")]
    pub move_op: Word,
    pub movi: Word,
    pub mroo: Word,
    pub mul: Word,
    pub muli: Word,
    pub mldv: Word,
    pub noop: Word,
    pub not: Word,
    pub or: Word,
    pub ori: Word,
    pub poph: Word,
    pub popl: Word,
    pub pshh: Word,
    pub pshl: Word,
    #[serde(rename = "ret_contract")]
    pub ret: Word,
    #[serde(rename = "rvrt_contract")]
    pub rvrt: Word,
    pub sb: Word,
    pub sll: Word,
    pub slli: Word,
    pub srl: Word,
    pub srli: Word,
    pub srw: Word,
    pub sub: Word,
    pub subi: Word,
    pub sw: Word,
    pub sww: Word,
    pub time: Word,
    pub tr: Word,
    pub tro: Word,
    pub wdcm: Word,
    pub wqcm: Word,
    pub wdop: Word,
    pub wqop: Word,
    pub wdml: Word,
    pub wqml: Word,
    pub wddv: Word,
    pub wqdv: Word,
    pub wdmd: Word,
    pub wqmd: Word,
    pub wdam: Word,
    pub wqam: Word,
    pub wdmm: Word,
    pub wqmm: Word,
    pub xor: Word,
    pub xori: Word,

    // Dependent
    pub call: DependentCost,
    pub ccp: DependentCost,
    pub croo: DependentCost,
    pub csiz: DependentCost,
    pub k256: DependentCost,
    pub ldc: DependentCost,
    pub logd: DependentCost,
    pub mcl: DependentCost,
    pub mcli: DependentCost,
    pub mcp: DependentCost,
    pub mcpi: DependentCost,
    pub meq: DependentCost,
    #[serde(rename = "retd_contract")]
    pub retd: DependentCost,
    pub s256: DependentCost,
    pub scwq: DependentCost,
    pub smo: DependentCost,
    pub srwq: DependentCost,
    pub swwq: DependentCost,

    // Non-opcode costs
    pub contract_root: DependentCost,
    pub state_root: DependentCost,
    pub new_storage_per_byte: Word,
    pub vm_initialization: DependentCost,
}

/// Gas costs for every op.
/// The difference with [`GasCostsValuesV1`]:
/// - `aloc` is a [`DependentCost`] instead of a [`Word`]
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[serde(default = "GasCostsValuesV2::unit")]
pub struct GasCostsValuesV2 {
    pub add: Word,
    pub addi: Word,
    pub and: Word,
    pub andi: Word,
    pub bal: Word,
    pub bhei: Word,
    pub bhsh: Word,
    pub burn: Word,
    pub cb: Word,
    pub cfei: Word,
    pub cfsi: Word,
    pub div: Word,
    pub divi: Word,
    pub eck1: Word,
    pub ecr1: Word,
    pub ed19: Word,
    pub eq: Word,
    pub exp: Word,
    pub expi: Word,
    pub flag: Word,
    pub gm: Word,
    pub gt: Word,
    pub gtf: Word,
    pub ji: Word,
    pub jmp: Word,
    pub jne: Word,
    pub jnei: Word,
    pub jnzi: Word,
    pub jmpf: Word,
    pub jmpb: Word,
    pub jnzf: Word,
    pub jnzb: Word,
    pub jnef: Word,
    pub jneb: Word,
    pub lb: Word,
    pub log: Word,
    pub lt: Word,
    pub lw: Word,
    pub mint: Word,
    pub mlog: Word,
    #[serde(rename = "mod")]
    pub mod_op: Word,
    pub modi: Word,
    #[serde(rename = "move")]
    pub move_op: Word,
    pub movi: Word,
    pub mroo: Word,
    pub mul: Word,
    pub muli: Word,
    pub mldv: Word,
    pub noop: Word,
    pub not: Word,
    pub or: Word,
    pub ori: Word,
    pub poph: Word,
    pub popl: Word,
    pub pshh: Word,
    pub pshl: Word,
    #[serde(rename = "ret_contract")]
    pub ret: Word,
    #[serde(rename = "rvrt_contract")]
    pub rvrt: Word,
    pub sb: Word,
    pub sll: Word,
    pub slli: Word,
    pub srl: Word,
    pub srli: Word,
    pub srw: Word,
    pub sub: Word,
    pub subi: Word,
    pub sw: Word,
    pub sww: Word,
    pub time: Word,
    pub tr: Word,
    pub tro: Word,
    pub wdcm: Word,
    pub wqcm: Word,
    pub wdop: Word,
    pub wqop: Word,
    pub wdml: Word,
    pub wqml: Word,
    pub wddv: Word,
    pub wqdv: Word,
    pub wdmd: Word,
    pub wqmd: Word,
    pub wdam: Word,
    pub wqam: Word,
    pub wdmm: Word,
    pub wqmm: Word,
    pub xor: Word,
    pub xori: Word,

    // Dependent
    pub aloc: DependentCost,
    pub call: DependentCost,
    pub ccp: DependentCost,
    pub croo: DependentCost,
    pub csiz: DependentCost,
    pub k256: DependentCost,
    pub ldc: DependentCost,
    pub logd: DependentCost,
    pub mcl: DependentCost,
    pub mcli: DependentCost,
    pub mcp: DependentCost,
    pub mcpi: DependentCost,
    pub meq: DependentCost,
    #[serde(rename = "retd_contract")]
    pub retd: DependentCost,
    pub s256: DependentCost,
    pub scwq: DependentCost,
    pub smo: DependentCost,
    pub srwq: DependentCost,
    pub swwq: DependentCost,

    // Non-opcode costs
    pub contract_root: DependentCost,
    pub state_root: DependentCost,
    pub new_storage_per_byte: Word,
    pub vm_initialization: DependentCost,
}

/// Gas costs for every op.
/// The difference with [`GasCostsValuesV2`]:
/// - Added `cfe` as a [`DependentCost`]
/// - `cfei` is a [`DependentCost`] instead of a [`Word`]
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[serde(default = "GasCostsValuesV3::unit")]
pub struct GasCostsValuesV3 {
    pub add: Word,
    pub addi: Word,
    pub and: Word,
    pub andi: Word,
    pub bal: Word,
    pub bhei: Word,
    pub bhsh: Word,
    pub burn: Word,
    pub cb: Word,
    pub cfsi: Word,
    pub div: Word,
    pub divi: Word,
    pub eck1: Word,
    pub ecr1: Word,
    pub ed19: Word,
    pub eq: Word,
    pub exp: Word,
    pub expi: Word,
    pub flag: Word,
    pub gm: Word,
    pub gt: Word,
    pub gtf: Word,
    pub ji: Word,
    pub jmp: Word,
    pub jne: Word,
    pub jnei: Word,
    pub jnzi: Word,
    pub jmpf: Word,
    pub jmpb: Word,
    pub jnzf: Word,
    pub jnzb: Word,
    pub jnef: Word,
    pub jneb: Word,
    pub lb: Word,
    pub log: Word,
    pub lt: Word,
    pub lw: Word,
    pub mint: Word,
    pub mlog: Word,
    #[serde(rename = "mod")]
    pub mod_op: Word,
    pub modi: Word,
    #[serde(rename = "move")]
    pub move_op: Word,
    pub movi: Word,
    pub mroo: Word,
    pub mul: Word,
    pub muli: Word,
    pub mldv: Word,
    pub noop: Word,
    pub not: Word,
    pub or: Word,
    pub ori: Word,
    pub poph: Word,
    pub popl: Word,
    pub pshh: Word,
    pub pshl: Word,
    #[serde(rename = "ret_contract")]
    pub ret: Word,
    #[serde(rename = "rvrt_contract")]
    pub rvrt: Word,
    pub sb: Word,
    pub sll: Word,
    pub slli: Word,
    pub srl: Word,
    pub srli: Word,
    pub srw: Word,
    pub sub: Word,
    pub subi: Word,
    pub sw: Word,
    pub sww: Word,
    pub time: Word,
    pub tr: Word,
    pub tro: Word,
    pub wdcm: Word,
    pub wqcm: Word,
    pub wdop: Word,
    pub wqop: Word,
    pub wdml: Word,
    pub wqml: Word,
    pub wddv: Word,
    pub wqdv: Word,
    pub wdmd: Word,
    pub wqmd: Word,
    pub wdam: Word,
    pub wqam: Word,
    pub wdmm: Word,
    pub wqmm: Word,
    pub xor: Word,
    pub xori: Word,

    // Dependent
    pub aloc: DependentCost,
    pub cfe: DependentCost,
    pub cfei: DependentCost,
    pub call: DependentCost,
    pub ccp: DependentCost,
    pub croo: DependentCost,
    pub csiz: DependentCost,
    pub k256: DependentCost,
    pub ldc: DependentCost,
    pub logd: DependentCost,
    pub mcl: DependentCost,
    pub mcli: DependentCost,
    pub mcp: DependentCost,
    pub mcpi: DependentCost,
    pub meq: DependentCost,
    #[serde(rename = "retd_contract")]
    pub retd: DependentCost,
    pub s256: DependentCost,
    pub scwq: DependentCost,
    pub smo: DependentCost,
    pub srwq: DependentCost,
    pub swwq: DependentCost,

    // Non-opcode costs
    pub contract_root: DependentCost,
    pub state_root: DependentCost,
    pub new_storage_per_byte: Word,
    pub vm_initialization: DependentCost,
}

/// Gas costs for every op.
/// The difference with [`GasCostsValuesV3`]:
/// - Added `bsiz`, `bldd` instructions
/// - Changed `ed19` to be `DependentCost`
#[allow(missing_docs)]
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[serde(default = "GasCostsValuesV4::unit")]
pub struct GasCostsValuesV4 {
    pub add: Word,
    pub addi: Word,
    pub and: Word,
    pub andi: Word,
    pub bal: Word,
    pub bhei: Word,
    pub bhsh: Word,
    pub burn: Word,
    pub cb: Word,
    pub cfsi: Word,
    pub div: Word,
    pub divi: Word,
    pub eck1: Word,
    pub ecr1: Word,
    pub eq: Word,
    pub exp: Word,
    pub expi: Word,
    pub flag: Word,
    pub gm: Word,
    pub gt: Word,
    pub gtf: Word,
    pub ji: Word,
    pub jmp: Word,
    pub jne: Word,
    pub jnei: Word,
    pub jnzi: Word,
    pub jmpf: Word,
    pub jmpb: Word,
    pub jnzf: Word,
    pub jnzb: Word,
    pub jnef: Word,
    pub jneb: Word,
    pub lb: Word,
    pub log: Word,
    pub lt: Word,
    pub lw: Word,
    pub mint: Word,
    pub mlog: Word,
    #[serde(rename = "mod")]
    pub mod_op: Word,
    pub modi: Word,
    #[serde(rename = "move")]
    pub move_op: Word,
    pub movi: Word,
    pub mroo: Word,
    pub mul: Word,
    pub muli: Word,
    pub mldv: Word,
    pub noop: Word,
    pub not: Word,
    pub or: Word,
    pub ori: Word,
    pub poph: Word,
    pub popl: Word,
    pub pshh: Word,
    pub pshl: Word,
    #[serde(rename = "ret_contract")]
    pub ret: Word,
    #[serde(rename = "rvrt_contract")]
    pub rvrt: Word,
    pub sb: Word,
    pub sll: Word,
    pub slli: Word,
    pub srl: Word,
    pub srli: Word,
    pub srw: Word,
    pub sub: Word,
    pub subi: Word,
    pub sw: Word,
    pub sww: Word,
    pub time: Word,
    pub tr: Word,
    pub tro: Word,
    pub wdcm: Word,
    pub wqcm: Word,
    pub wdop: Word,
    pub wqop: Word,
    pub wdml: Word,
    pub wqml: Word,
    pub wddv: Word,
    pub wqdv: Word,
    pub wdmd: Word,
    pub wqmd: Word,
    pub wdam: Word,
    pub wqam: Word,
    pub wdmm: Word,
    pub wqmm: Word,
    pub xor: Word,
    pub xori: Word,

    // Dependent
    pub aloc: DependentCost,
    pub bsiz: DependentCost,
    pub bldd: DependentCost,
    pub cfe: DependentCost,
    pub cfei: DependentCost,
    pub call: DependentCost,
    pub ccp: DependentCost,
    pub croo: DependentCost,
    pub csiz: DependentCost,
    pub ed19: DependentCost,
    pub k256: DependentCost,
    pub ldc: DependentCost,
    pub logd: DependentCost,
    pub mcl: DependentCost,
    pub mcli: DependentCost,
    pub mcp: DependentCost,
    pub mcpi: DependentCost,
    pub meq: DependentCost,
    #[serde(rename = "retd_contract")]
    pub retd: DependentCost,
    pub s256: DependentCost,
    pub scwq: DependentCost,
    pub smo: DependentCost,
    pub srwq: DependentCost,
    pub swwq: DependentCost,

    // Non-opcode costs
    pub contract_root: DependentCost,
    pub state_root: DependentCost,
    pub new_storage_per_byte: Word,
    pub vm_initialization: DependentCost,
}

/// Dependent cost is a cost that depends on the number of units.
#[derive(
    Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum DependentCost {
    /// When an operation is dependent on the magnitude of its inputs, and the
    /// time per unit of input is less than a single no-op operation
    LightOperation {
        /// The minimum that this operation can cost.
        base: Word,
        /// How many elements can be processed with a single gas. The
        /// higher the `units_per_gas`, the less additional cost you will incur
        /// for a given number of units, because you need more units to increase
        /// the total cost.
        /// This must be nonzero.
        units_per_gas: Word,
    },

    /// When an operation is dependent on the magnitude of its inputs, and the
    /// time per unit of input is greater than a single no-op operation
    HeavyOperation {
        /// The minimum that this operation can cost.
        base: Word,
        /// How much gas is required to process a single unit.
        gas_per_unit: Word,
    },
}

#[cfg(feature = "alloc")]
impl GasCosts {
    /// Create costs that are all set to zero.
    pub fn free() -> Self {
        Self(Arc::new(GasCostsValues::free()))
    }

    /// Create costs that are all set to one.
    pub fn unit() -> Self {
        Self(Arc::new(GasCostsValues::unit()))
    }
}

impl GasCostsValues {
    /// Create costs that are all set to zero.
    pub fn free() -> Self {
        GasCostsValuesV4::free().into()
    }

    /// Create costs that are all set to one.
    pub fn unit() -> Self {
        GasCostsValuesV4::unit().into()
    }
}

impl GasCostsValuesV1 {
    /// Create costs that are all set to zero.
    pub fn free() -> Self {
        Self {
            add: 0,
            addi: 0,
            aloc: 0,
            and: 0,
            andi: 0,
            bal: 0,
            bhei: 0,
            bhsh: 0,
            burn: 0,
            cb: 0,
            cfei: 0,
            cfsi: 0,
            div: 0,
            divi: 0,
            eck1: 0,
            ecr1: 0,
            ed19: 0,
            eq: 0,
            exp: 0,
            expi: 0,
            flag: 0,
            gm: 0,
            gt: 0,
            gtf: 0,
            ji: 0,
            jmp: 0,
            jne: 0,
            jnei: 0,
            jnzi: 0,
            jmpf: 0,
            jmpb: 0,
            jnzf: 0,
            jnzb: 0,
            jnef: 0,
            jneb: 0,
            lb: 0,
            log: 0,
            lt: 0,
            lw: 0,
            mint: 0,
            mlog: 0,
            mod_op: 0,
            modi: 0,
            move_op: 0,
            movi: 0,
            mroo: 0,
            mul: 0,
            muli: 0,
            mldv: 0,
            noop: 0,
            not: 0,
            or: 0,
            ori: 0,
            poph: 0,
            popl: 0,
            pshh: 0,
            pshl: 0,
            ret: 0,
            rvrt: 0,
            sb: 0,
            sll: 0,
            slli: 0,
            srl: 0,
            srli: 0,
            srw: 0,
            sub: 0,
            subi: 0,
            sw: 0,
            sww: 0,
            time: 0,
            tr: 0,
            tro: 0,
            wdcm: 0,
            wqcm: 0,
            wdop: 0,
            wqop: 0,
            wdml: 0,
            wqml: 0,
            wddv: 0,
            wqdv: 0,
            wdmd: 0,
            wqmd: 0,
            wdam: 0,
            wqam: 0,
            wdmm: 0,
            wqmm: 0,
            xor: 0,
            xori: 0,
            call: DependentCost::free(),
            ccp: DependentCost::free(),
            croo: DependentCost::free(),
            csiz: DependentCost::free(),
            k256: DependentCost::free(),
            ldc: DependentCost::free(),
            logd: DependentCost::free(),
            mcl: DependentCost::free(),
            mcli: DependentCost::free(),
            mcp: DependentCost::free(),
            mcpi: DependentCost::free(),
            meq: DependentCost::free(),
            retd: DependentCost::free(),
            s256: DependentCost::free(),
            scwq: DependentCost::free(),
            smo: DependentCost::free(),
            srwq: DependentCost::free(),
            swwq: DependentCost::free(),

            // Non-opcode costs
            contract_root: DependentCost::free(),
            state_root: DependentCost::free(),
            new_storage_per_byte: 0,
            vm_initialization: DependentCost::free(),
        }
    }

    /// Create costs that are all set to one.
    pub fn unit() -> Self {
        Self {
            add: 1,
            addi: 1,
            aloc: 1,
            and: 1,
            andi: 1,
            bal: 1,
            bhei: 1,
            bhsh: 1,
            burn: 1,
            cb: 1,
            cfei: 1,
            cfsi: 1,
            div: 1,
            divi: 1,
            eck1: 1,
            ecr1: 1,
            ed19: 1,
            eq: 1,
            exp: 1,
            expi: 1,
            flag: 1,
            gm: 1,
            gt: 1,
            gtf: 1,
            ji: 1,
            jmp: 1,
            jne: 1,
            jnei: 1,
            jnzi: 1,
            jmpf: 1,
            jmpb: 1,
            jnzf: 1,
            jnzb: 1,
            jnef: 1,
            jneb: 1,
            lb: 1,
            log: 1,
            lt: 1,
            lw: 1,
            mint: 1,
            mlog: 1,
            mod_op: 1,
            modi: 1,
            move_op: 1,
            movi: 1,
            mroo: 1,
            mul: 1,
            muli: 1,
            mldv: 1,
            noop: 1,
            not: 1,
            or: 1,
            ori: 1,
            ret: 1,
            poph: 1,
            popl: 1,
            pshh: 1,
            pshl: 1,
            rvrt: 1,
            sb: 1,
            sll: 1,
            slli: 1,
            srl: 1,
            srli: 1,
            srw: 1,
            sub: 1,
            subi: 1,
            sw: 1,
            sww: 1,
            time: 1,
            tr: 1,
            tro: 1,
            wdcm: 1,
            wqcm: 1,
            wdop: 1,
            wqop: 1,
            wdml: 1,
            wqml: 1,
            wddv: 1,
            wqdv: 1,
            wdmd: 1,
            wqmd: 1,
            wdam: 1,
            wqam: 1,
            wdmm: 1,
            wqmm: 1,
            xor: 1,
            xori: 1,
            call: DependentCost::unit(),
            ccp: DependentCost::unit(),
            croo: DependentCost::unit(),
            csiz: DependentCost::unit(),
            k256: DependentCost::unit(),
            ldc: DependentCost::unit(),
            logd: DependentCost::unit(),
            mcl: DependentCost::unit(),
            mcli: DependentCost::unit(),
            mcp: DependentCost::unit(),
            mcpi: DependentCost::unit(),
            meq: DependentCost::unit(),
            retd: DependentCost::unit(),
            s256: DependentCost::unit(),
            scwq: DependentCost::unit(),
            smo: DependentCost::unit(),
            srwq: DependentCost::unit(),
            swwq: DependentCost::unit(),

            // Non-opcode costs
            contract_root: DependentCost::unit(),
            state_root: DependentCost::unit(),
            new_storage_per_byte: 1,
            vm_initialization: DependentCost::unit(),
        }
    }
}

impl GasCostsValuesV2 {
    /// Create costs that are all set to zero.
    pub fn free() -> Self {
        Self {
            add: 0,
            addi: 0,
            and: 0,
            andi: 0,
            bal: 0,
            bhei: 0,
            bhsh: 0,
            burn: 0,
            cb: 0,
            cfei: 0,
            cfsi: 0,
            div: 0,
            divi: 0,
            eck1: 0,
            ecr1: 0,
            ed19: 0,
            eq: 0,
            exp: 0,
            expi: 0,
            flag: 0,
            gm: 0,
            gt: 0,
            gtf: 0,
            ji: 0,
            jmp: 0,
            jne: 0,
            jnei: 0,
            jnzi: 0,
            jmpf: 0,
            jmpb: 0,
            jnzf: 0,
            jnzb: 0,
            jnef: 0,
            jneb: 0,
            lb: 0,
            log: 0,
            lt: 0,
            lw: 0,
            mint: 0,
            mlog: 0,
            mod_op: 0,
            modi: 0,
            move_op: 0,
            movi: 0,
            mroo: 0,
            mul: 0,
            muli: 0,
            mldv: 0,
            noop: 0,
            not: 0,
            or: 0,
            ori: 0,
            poph: 0,
            popl: 0,
            pshh: 0,
            pshl: 0,
            ret: 0,
            rvrt: 0,
            sb: 0,
            sll: 0,
            slli: 0,
            srl: 0,
            srli: 0,
            srw: 0,
            sub: 0,
            subi: 0,
            sw: 0,
            sww: 0,
            time: 0,
            tr: 0,
            tro: 0,
            wdcm: 0,
            wqcm: 0,
            wdop: 0,
            wqop: 0,
            wdml: 0,
            wqml: 0,
            wddv: 0,
            wqdv: 0,
            wdmd: 0,
            wqmd: 0,
            wdam: 0,
            wqam: 0,
            wdmm: 0,
            wqmm: 0,
            xor: 0,
            xori: 0,
            aloc: DependentCost::free(),
            call: DependentCost::free(),
            ccp: DependentCost::free(),
            croo: DependentCost::free(),
            csiz: DependentCost::free(),
            k256: DependentCost::free(),
            ldc: DependentCost::free(),
            logd: DependentCost::free(),
            mcl: DependentCost::free(),
            mcli: DependentCost::free(),
            mcp: DependentCost::free(),
            mcpi: DependentCost::free(),
            meq: DependentCost::free(),
            retd: DependentCost::free(),
            s256: DependentCost::free(),
            scwq: DependentCost::free(),
            smo: DependentCost::free(),
            srwq: DependentCost::free(),
            swwq: DependentCost::free(),

            // Non-opcode costs
            contract_root: DependentCost::free(),
            state_root: DependentCost::free(),
            new_storage_per_byte: 0,
            vm_initialization: DependentCost::free(),
        }
    }

    /// Create costs that are all set to one.
    pub fn unit() -> Self {
        Self {
            add: 1,
            addi: 1,
            and: 1,
            andi: 1,
            bal: 1,
            bhei: 1,
            bhsh: 1,
            burn: 1,
            cb: 1,
            cfei: 1,
            cfsi: 1,
            div: 1,
            divi: 1,
            eck1: 1,
            ecr1: 1,
            ed19: 1,
            eq: 1,
            exp: 1,
            expi: 1,
            flag: 1,
            gm: 1,
            gt: 1,
            gtf: 1,
            ji: 1,
            jmp: 1,
            jne: 1,
            jnei: 1,
            jnzi: 1,
            jmpf: 1,
            jmpb: 1,
            jnzf: 1,
            jnzb: 1,
            jnef: 1,
            jneb: 1,
            lb: 1,
            log: 1,
            lt: 1,
            lw: 1,
            mint: 1,
            mlog: 1,
            mod_op: 1,
            modi: 1,
            move_op: 1,
            movi: 1,
            mroo: 1,
            mul: 1,
            muli: 1,
            mldv: 1,
            noop: 1,
            not: 1,
            or: 1,
            ori: 1,
            ret: 1,
            poph: 1,
            popl: 1,
            pshh: 1,
            pshl: 1,
            rvrt: 1,
            sb: 1,
            sll: 1,
            slli: 1,
            srl: 1,
            srli: 1,
            srw: 1,
            sub: 1,
            subi: 1,
            sw: 1,
            sww: 1,
            time: 1,
            tr: 1,
            tro: 1,
            wdcm: 1,
            wqcm: 1,
            wdop: 1,
            wqop: 1,
            wdml: 1,
            wqml: 1,
            wddv: 1,
            wqdv: 1,
            wdmd: 1,
            wqmd: 1,
            wdam: 1,
            wqam: 1,
            wdmm: 1,
            wqmm: 1,
            xor: 1,
            xori: 1,
            aloc: DependentCost::unit(),
            call: DependentCost::unit(),
            ccp: DependentCost::unit(),
            croo: DependentCost::unit(),
            csiz: DependentCost::unit(),
            k256: DependentCost::unit(),
            ldc: DependentCost::unit(),
            logd: DependentCost::unit(),
            mcl: DependentCost::unit(),
            mcli: DependentCost::unit(),
            mcp: DependentCost::unit(),
            mcpi: DependentCost::unit(),
            meq: DependentCost::unit(),
            retd: DependentCost::unit(),
            s256: DependentCost::unit(),
            scwq: DependentCost::unit(),
            smo: DependentCost::unit(),
            srwq: DependentCost::unit(),
            swwq: DependentCost::unit(),

            // Non-opcode costs
            contract_root: DependentCost::unit(),
            state_root: DependentCost::unit(),
            new_storage_per_byte: 1,
            vm_initialization: DependentCost::unit(),
        }
    }
}

impl GasCostsValuesV3 {
    /// Create costs that are all set to zero.
    pub fn free() -> Self {
        Self {
            add: 0,
            addi: 0,
            and: 0,
            andi: 0,
            bal: 0,
            bhei: 0,
            bhsh: 0,
            burn: 0,
            cb: 0,
            cfsi: 0,
            div: 0,
            divi: 0,
            eck1: 0,
            ecr1: 0,
            ed19: 0,
            eq: 0,
            exp: 0,
            expi: 0,
            flag: 0,
            gm: 0,
            gt: 0,
            gtf: 0,
            ji: 0,
            jmp: 0,
            jne: 0,
            jnei: 0,
            jnzi: 0,
            jmpf: 0,
            jmpb: 0,
            jnzf: 0,
            jnzb: 0,
            jnef: 0,
            jneb: 0,
            lb: 0,
            log: 0,
            lt: 0,
            lw: 0,
            mint: 0,
            mlog: 0,
            mod_op: 0,
            modi: 0,
            move_op: 0,
            movi: 0,
            mroo: 0,
            mul: 0,
            muli: 0,
            mldv: 0,
            noop: 0,
            not: 0,
            or: 0,
            ori: 0,
            poph: 0,
            popl: 0,
            pshh: 0,
            pshl: 0,
            ret: 0,
            rvrt: 0,
            sb: 0,
            sll: 0,
            slli: 0,
            srl: 0,
            srli: 0,
            srw: 0,
            sub: 0,
            subi: 0,
            sw: 0,
            sww: 0,
            time: 0,
            tr: 0,
            tro: 0,
            wdcm: 0,
            wqcm: 0,
            wdop: 0,
            wqop: 0,
            wdml: 0,
            wqml: 0,
            wddv: 0,
            wqdv: 0,
            wdmd: 0,
            wqmd: 0,
            wdam: 0,
            wqam: 0,
            wdmm: 0,
            wqmm: 0,
            xor: 0,
            xori: 0,
            aloc: DependentCost::free(),
            cfe: DependentCost::free(),
            cfei: DependentCost::free(),
            call: DependentCost::free(),
            ccp: DependentCost::free(),
            croo: DependentCost::free(),
            csiz: DependentCost::free(),
            k256: DependentCost::free(),
            ldc: DependentCost::free(),
            logd: DependentCost::free(),
            mcl: DependentCost::free(),
            mcli: DependentCost::free(),
            mcp: DependentCost::free(),
            mcpi: DependentCost::free(),
            meq: DependentCost::free(),
            retd: DependentCost::free(),
            s256: DependentCost::free(),
            scwq: DependentCost::free(),
            smo: DependentCost::free(),
            srwq: DependentCost::free(),
            swwq: DependentCost::free(),

            // Non-opcode costs
            contract_root: DependentCost::free(),
            state_root: DependentCost::free(),
            new_storage_per_byte: 0,
            vm_initialization: DependentCost::free(),
        }
    }

    /// Create costs that are all set to one.
    pub fn unit() -> Self {
        Self {
            add: 1,
            addi: 1,
            and: 1,
            andi: 1,
            bal: 1,
            bhei: 1,
            bhsh: 1,
            burn: 1,
            cb: 1,
            cfsi: 1,
            div: 1,
            divi: 1,
            eck1: 1,
            ecr1: 1,
            ed19: 1,
            eq: 1,
            exp: 1,
            expi: 1,
            flag: 1,
            gm: 1,
            gt: 1,
            gtf: 1,
            ji: 1,
            jmp: 1,
            jne: 1,
            jnei: 1,
            jnzi: 1,
            jmpf: 1,
            jmpb: 1,
            jnzf: 1,
            jnzb: 1,
            jnef: 1,
            jneb: 1,
            lb: 1,
            log: 1,
            lt: 1,
            lw: 1,
            mint: 1,
            mlog: 1,
            mod_op: 1,
            modi: 1,
            move_op: 1,
            movi: 1,
            mroo: 1,
            mul: 1,
            muli: 1,
            mldv: 1,
            noop: 1,
            not: 1,
            or: 1,
            ori: 1,
            ret: 1,
            poph: 1,
            popl: 1,
            pshh: 1,
            pshl: 1,
            rvrt: 1,
            sb: 1,
            sll: 1,
            slli: 1,
            srl: 1,
            srli: 1,
            srw: 1,
            sub: 1,
            subi: 1,
            sw: 1,
            sww: 1,
            time: 1,
            tr: 1,
            tro: 1,
            wdcm: 1,
            wqcm: 1,
            wdop: 1,
            wqop: 1,
            wdml: 1,
            wqml: 1,
            wddv: 1,
            wqdv: 1,
            wdmd: 1,
            wqmd: 1,
            wdam: 1,
            wqam: 1,
            wdmm: 1,
            wqmm: 1,
            xor: 1,
            xori: 1,
            aloc: DependentCost::unit(),
            cfe: DependentCost::unit(),
            cfei: DependentCost::unit(),
            call: DependentCost::unit(),
            ccp: DependentCost::unit(),
            croo: DependentCost::unit(),
            csiz: DependentCost::unit(),
            k256: DependentCost::unit(),
            ldc: DependentCost::unit(),
            logd: DependentCost::unit(),
            mcl: DependentCost::unit(),
            mcli: DependentCost::unit(),
            mcp: DependentCost::unit(),
            mcpi: DependentCost::unit(),
            meq: DependentCost::unit(),
            retd: DependentCost::unit(),
            s256: DependentCost::unit(),
            scwq: DependentCost::unit(),
            smo: DependentCost::unit(),
            srwq: DependentCost::unit(),
            swwq: DependentCost::unit(),

            // Non-opcode costs
            contract_root: DependentCost::unit(),
            state_root: DependentCost::unit(),
            new_storage_per_byte: 1,
            vm_initialization: DependentCost::unit(),
        }
    }
}

impl GasCostsValuesV4 {
    /// Create costs that are all set to zero.
    pub fn free() -> Self {
        Self {
            add: 0,
            addi: 0,
            and: 0,
            andi: 0,
            bal: 0,
            bhei: 0,
            bhsh: 0,
            burn: 0,
            cb: 0,
            cfsi: 0,
            div: 0,
            divi: 0,
            eck1: 0,
            ecr1: 0,
            eq: 0,
            exp: 0,
            expi: 0,
            flag: 0,
            gm: 0,
            gt: 0,
            gtf: 0,
            ji: 0,
            jmp: 0,
            jne: 0,
            jnei: 0,
            jnzi: 0,
            jmpf: 0,
            jmpb: 0,
            jnzf: 0,
            jnzb: 0,
            jnef: 0,
            jneb: 0,
            lb: 0,
            log: 0,
            lt: 0,
            lw: 0,
            mint: 0,
            mlog: 0,
            mod_op: 0,
            modi: 0,
            move_op: 0,
            movi: 0,
            mroo: 0,
            mul: 0,
            muli: 0,
            mldv: 0,
            noop: 0,
            not: 0,
            or: 0,
            ori: 0,
            poph: 0,
            popl: 0,
            pshh: 0,
            pshl: 0,
            ret: 0,
            rvrt: 0,
            sb: 0,
            sll: 0,
            slli: 0,
            srl: 0,
            srli: 0,
            srw: 0,
            sub: 0,
            subi: 0,
            sw: 0,
            sww: 0,
            time: 0,
            tr: 0,
            tro: 0,
            wdcm: 0,
            wqcm: 0,
            wdop: 0,
            wqop: 0,
            wdml: 0,
            wqml: 0,
            wddv: 0,
            wqdv: 0,
            wdmd: 0,
            wqmd: 0,
            wdam: 0,
            wqam: 0,
            wdmm: 0,
            wqmm: 0,
            xor: 0,
            xori: 0,
            aloc: DependentCost::free(),
            bsiz: DependentCost::free(),
            bldd: DependentCost::free(),
            cfe: DependentCost::free(),
            cfei: DependentCost::free(),
            call: DependentCost::free(),
            ccp: DependentCost::free(),
            croo: DependentCost::free(),
            csiz: DependentCost::free(),
            ed19: DependentCost::free(),
            k256: DependentCost::free(),
            ldc: DependentCost::free(),
            logd: DependentCost::free(),
            mcl: DependentCost::free(),
            mcli: DependentCost::free(),
            mcp: DependentCost::free(),
            mcpi: DependentCost::free(),
            meq: DependentCost::free(),
            retd: DependentCost::free(),
            s256: DependentCost::free(),
            scwq: DependentCost::free(),
            smo: DependentCost::free(),
            srwq: DependentCost::free(),
            swwq: DependentCost::free(),

            // Non-opcode costs
            contract_root: DependentCost::free(),
            state_root: DependentCost::free(),
            new_storage_per_byte: 0,
            vm_initialization: DependentCost::free(),
        }
    }

    /// Create costs that are all set to one.
    pub fn unit() -> Self {
        Self {
            add: 1,
            addi: 1,
            and: 1,
            andi: 1,
            bal: 1,
            bhei: 1,
            bhsh: 1,
            burn: 1,
            cb: 1,
            cfsi: 1,
            div: 1,
            divi: 1,
            eck1: 1,
            ecr1: 1,
            eq: 1,
            exp: 1,
            expi: 1,
            flag: 1,
            gm: 1,
            gt: 1,
            gtf: 1,
            ji: 1,
            jmp: 1,
            jne: 1,
            jnei: 1,
            jnzi: 1,
            jmpf: 1,
            jmpb: 1,
            jnzf: 1,
            jnzb: 1,
            jnef: 1,
            jneb: 1,
            lb: 1,
            log: 1,
            lt: 1,
            lw: 1,
            mint: 1,
            mlog: 1,
            mod_op: 1,
            modi: 1,
            move_op: 1,
            movi: 1,
            mroo: 1,
            mul: 1,
            muli: 1,
            mldv: 1,
            noop: 1,
            not: 1,
            or: 1,
            ori: 1,
            ret: 1,
            poph: 1,
            popl: 1,
            pshh: 1,
            pshl: 1,
            rvrt: 1,
            sb: 1,
            sll: 1,
            slli: 1,
            srl: 1,
            srli: 1,
            srw: 1,
            sub: 1,
            subi: 1,
            sw: 1,
            sww: 1,
            time: 1,
            tr: 1,
            tro: 1,
            wdcm: 1,
            wqcm: 1,
            wdop: 1,
            wqop: 1,
            wdml: 1,
            wqml: 1,
            wddv: 1,
            wqdv: 1,
            wdmd: 1,
            wqmd: 1,
            wdam: 1,
            wqam: 1,
            wdmm: 1,
            wqmm: 1,
            xor: 1,
            xori: 1,
            aloc: DependentCost::unit(),
            bsiz: DependentCost::unit(),
            bldd: DependentCost::unit(),
            cfe: DependentCost::unit(),
            cfei: DependentCost::unit(),
            call: DependentCost::unit(),
            ccp: DependentCost::unit(),
            croo: DependentCost::unit(),
            csiz: DependentCost::unit(),
            ed19: DependentCost::unit(),
            k256: DependentCost::unit(),
            ldc: DependentCost::unit(),
            logd: DependentCost::unit(),
            mcl: DependentCost::unit(),
            mcli: DependentCost::unit(),
            mcp: DependentCost::unit(),
            mcpi: DependentCost::unit(),
            meq: DependentCost::unit(),
            retd: DependentCost::unit(),
            s256: DependentCost::unit(),
            scwq: DependentCost::unit(),
            smo: DependentCost::unit(),
            srwq: DependentCost::unit(),
            swwq: DependentCost::unit(),

            // Non-opcode costs
            contract_root: DependentCost::unit(),
            state_root: DependentCost::unit(),
            new_storage_per_byte: 1,
            vm_initialization: DependentCost::unit(),
        }
    }
}

impl DependentCost {
    /// Create costs that make operations free.
    pub fn free() -> Self {
        Self::HeavyOperation {
            base: 0,
            gas_per_unit: 0,
        }
    }

    /// Create costs that make operations cost `1`.
    pub fn unit() -> Self {
        Self::HeavyOperation {
            base: 1,
            gas_per_unit: 0,
        }
    }

    pub fn from_units_per_gas(base: Word, units_per_gas: Word) -> Self {
        debug_assert!(
            units_per_gas > 0,
            "Cannot create dependent gas cost with per-0-gas ratio"
        );
        DependentCost::LightOperation {
            base,
            units_per_gas,
        }
    }

    pub fn from_gas_per_unit(base: Word, gas_per_unit: Word) -> Self {
        DependentCost::HeavyOperation { base, gas_per_unit }
    }

    pub fn base(&self) -> Word {
        match self {
            DependentCost::LightOperation { base, .. } => *base,
            DependentCost::HeavyOperation { base, .. } => *base,
        }
    }

    pub fn set_base(&mut self, value: Word) {
        match self {
            DependentCost::LightOperation { base, .. } => *base = value,
            DependentCost::HeavyOperation { base, .. } => *base = value,
        };
    }

    pub fn resolve(&self, units: Word) -> Word {
        let base = self.base();
        let dependent_value = self.resolve_without_base(units);
        base.saturating_add(dependent_value)
    }

    pub fn resolve_without_base(&self, units: Word) -> Word {
        match self {
            DependentCost::LightOperation { units_per_gas, .. } => {
                // Apply the linear transformation:
                //   f(x) = 1/m * x = x/m
                // where:
                //   x is the number of units
                //   1/m is the gas_per_unit
                units
                    .checked_div(*units_per_gas)
                    .expect("units_per_gas cannot be zero")
            }
            DependentCost::HeavyOperation { gas_per_unit, .. } => {
                // Apply the linear transformation:
                //   f(x) = mx
                // where:
                //   x is the number of units
                //   m is the gas per unit
                units.saturating_mul(*gas_per_unit)
            }
        }
    }
}

#[cfg(feature = "alloc")]
impl Deref for GasCosts {
    type Target = GasCostsValues;

    fn deref(&self) -> &Self::Target {
        &(self.0)
    }
}

impl From<GasCostsValues> for GasCosts {
    fn from(i: GasCostsValues) -> Self {
        Self(Arc::new(i))
    }
}

impl From<GasCosts> for GasCostsValues {
    fn from(i: GasCosts) -> Self {
        (*i.0).clone()
    }
}

impl From<GasCostsValuesV1> for GasCostsValues {
    fn from(i: GasCostsValuesV1) -> Self {
        GasCostsValues::V1(i)
    }
}

impl From<GasCostsValuesV2> for GasCostsValues {
    fn from(i: GasCostsValuesV2) -> Self {
        GasCostsValues::V2(i)
    }
}

impl From<GasCostsValuesV3> for GasCostsValues {
    fn from(i: GasCostsValuesV3) -> Self {
        GasCostsValues::V3(i)
    }
}
impl From<GasCostsValuesV4> for GasCostsValues {
    fn from(i: GasCostsValuesV4) -> Self {
        GasCostsValues::V4(i)
    }
}

#[cfg(test)]
mod tests {
    use crate::DependentCost;

    #[test]
    fn light_operation_gas_cost_resolves_correctly() {
        // Create a linear gas cost function with a slope of 1/10
        let cost = DependentCost::from_units_per_gas(0, 10);
        let total = cost.resolve(0);
        assert_eq!(total, 0);

        let total = cost.resolve(5);
        assert_eq!(total, 0);

        let total = cost.resolve(10);
        assert_eq!(total, 1);

        let total = cost.resolve(100);
        assert_eq!(total, 10);

        let total = cost.resolve(721);
        assert_eq!(total, 72);
    }

    #[test]
    fn heavy_operation_gas_cost_resolves_correctly() {
        // Create a linear gas cost function with a slope of 10
        let cost = DependentCost::from_gas_per_unit(0, 10);
        let total = cost.resolve(0);
        assert_eq!(total, 0);

        let total = cost.resolve(5);
        assert_eq!(total, 50);

        let total = cost.resolve(10);
        assert_eq!(total, 100);

        let total = cost.resolve(100);
        assert_eq!(total, 1_000);

        let total = cost.resolve(721);
        assert_eq!(total, 7_210);
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/consensus_parameters/gas/default_gas_costs.rs

Source
use super::*;
/// File generated by fuel-core: benches/src/bin/collect.rs:440. With the following git
/// hash
pub const GIT: &str = "98341e564b75d1157e61d7d5f38612f6224a5b30";
/// Modified manually afterwards in https://github.com/FuelLabs/fuel-vm/pull/780
pub fn default_gas_costs() -> GasCostsValues {
    GasCostsValuesV4 {
        add: 1,
        addi: 1,
        and: 1,
        andi: 1,
        bal: 13,
        bhei: 1,
        bhsh: 1,
        burn: 132,
        cb: 1,
        cfsi: 1,
        div: 1,
        divi: 1,
        eck1: 951,
        ecr1: 3000,
        eq: 1,
        exp: 1,
        expi: 1,
        flag: 1,
        gm: 1,
        gt: 1,
        gtf: 1,
        ji: 1,
        jmp: 1,
        jne: 1,
        jnei: 1,
        jnzi: 1,
        jmpf: 1,
        jmpb: 1,
        jnzf: 1,
        jnzb: 1,
        jnef: 1,
        jneb: 1,
        lb: 1,
        log: 9,
        lt: 1,
        lw: 1,
        mint: 135,
        mlog: 1,
        modi: 1,
        mod_op: 1,
        movi: 1,
        mroo: 2,
        mul: 1,
        muli: 1,
        mldv: 1,
        noop: 1,
        not: 1,
        or: 1,
        ori: 1,
        poph: 2,
        popl: 2,
        pshh: 2,
        pshl: 2,
        move_op: 1,
        ret: 13,
        sb: 1,
        sll: 1,
        slli: 1,
        srl: 1,
        srli: 1,
        srw: 12,
        sub: 1,
        subi: 1,
        sw: 1,
        sww: 67,
        time: 1,
        tr: 105,
        tro: 60,
        wdcm: 1,
        wqcm: 1,
        wdop: 1,
        wqop: 1,
        wdml: 1,
        wqml: 1,
        wddv: 1,
        wqdv: 2,
        wdmd: 3,
        wqmd: 4,
        wdam: 2,
        wqam: 3,
        wdmm: 3,
        wqmm: 3,
        xor: 1,
        xori: 1,
        aloc: DependentCost::LightOperation {
            base: 2,
            units_per_gas: 214,
        },
        cfe: DependentCost::LightOperation {
            base: 2,
            units_per_gas: 214,
        },
        cfei: DependentCost::LightOperation {
            base: 2,
            units_per_gas: 214,
        },
        ed19: DependentCost::LightOperation {
            base: 3000,
            units_per_gas: 214,
        },
        k256: DependentCost::LightOperation {
            base: 11,
            units_per_gas: 214,
        },
        s256: DependentCost::LightOperation {
            base: 2,
            units_per_gas: 214,
        },
        call: DependentCost::LightOperation {
            base: 144,
            units_per_gas: 214,
        },
        ccp: DependentCost::LightOperation {
            base: 15,
            units_per_gas: 103,
        },
        croo: DependentCost::LightOperation {
            base: 1,
            units_per_gas: 1,
        },
        csiz: DependentCost::LightOperation {
            base: 17,
            units_per_gas: 790,
        },
        ldc: DependentCost::LightOperation {
            base: 15,
            units_per_gas: 272,
        },
        logd: DependentCost::LightOperation {
            base: 26,
            units_per_gas: 64,
        },
        mcl: DependentCost::LightOperation {
            base: 1,
            units_per_gas: 3333,
        },
        mcli: DependentCost::LightOperation {
            base: 1,
            units_per_gas: 3333,
        },
        mcp: DependentCost::LightOperation {
            base: 1,
            units_per_gas: 2000,
        },
        mcpi: DependentCost::LightOperation {
            base: 3,
            units_per_gas: 2000,
        },
        meq: DependentCost::LightOperation {
            base: 1,
            units_per_gas: 2500,
        },
        rvrt: 13,
        smo: DependentCost::LightOperation {
            base: 209,
            units_per_gas: 55,
        },
        retd: DependentCost::LightOperation {
            base: 29,
            units_per_gas: 62,
        },
        srwq: DependentCost::LightOperation {
            base: 47,
            units_per_gas: 5,
        },
        scwq: DependentCost::LightOperation {
            base: 13,
            units_per_gas: 5,
        },
        swwq: DependentCost::LightOperation {
            base: 44,
            units_per_gas: 5,
        },
        bsiz: DependentCost::LightOperation {
            base: 17,
            units_per_gas: 790,
        },
        bldd: DependentCost::LightOperation {
            base: 15,
            units_per_gas: 272,
        },

        // Non-opcode costs
        contract_root: DependentCost::LightOperation {
            base: 75,
            units_per_gas: 1,
        },
        state_root: DependentCost::LightOperation {
            base: 412,
            units_per_gas: 1,
        },
        new_storage_per_byte: 1,
        vm_initialization: DependentCost::HeavyOperation {
            base: 2000,
            gas_per_unit: 0,
        },
    }
    .into()
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/fee.rs

Source
use crate::{
    field,
    field::{
        MaxFeeLimit,
        Tip,
        WitnessLimit,
    },
    input::{
        coin::{
            CoinPredicate,
            CoinSigned,
        },
        message::{
            MessageCoinPredicate,
            MessageCoinSigned,
            MessageDataPredicate,
            MessageDataSigned,
        },
    },
    policies::PolicyType,
    FeeParameters,
    GasCosts,
    Input,
};
use fuel_asm::Word;
use fuel_types::canonical::Serialize;
use hashbrown::HashSet;

#[derive(
    Debug,
    Default,
    Clone,
    Copy,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Hash,
    serde::Serialize,
    serde::Deserialize,
)]
pub struct TransactionFee {
    pub(crate) min_fee: Word,
    pub(crate) max_fee: Word,
    pub(crate) min_gas: Word,
    pub(crate) max_gas: Word,
}

impl From<TransactionFee> for Word {
    fn from(fee: TransactionFee) -> Word {
        fee.max_fee
    }
}

impl TransactionFee {
    pub const fn new(min_fee: Word, max_fee: Word, min_gas: Word, max_gas: Word) -> Self {
        Self {
            min_fee,
            max_fee,
            min_gas,
            max_gas,
        }
    }

    /// Minimum fee value to pay for the base transaction without script execution.
    pub const fn min_fee(&self) -> Word {
        self.min_fee
    }

    /// Maximum fee value to pay for the transaction with script execution.
    pub const fn max_fee(&self) -> Word {
        self.max_fee
    }

    /// The minimum amount of gas (not fee!) used by this tx
    pub const fn min_gas(&self) -> Word {
        self.min_gas
    }

    /// The max amount of gas (not fee!) usable by this tx
    pub const fn max_gas(&self) -> Word {
        self.max_gas
    }

    /// Convert into a tuple containing the inner min & total fee values
    pub const fn into_inner(self) -> (Word, Word) {
        (self.min_fee, self.max_fee)
    }

    /// Attempt to subtract the maximum fee value from a given balance
    ///
    /// Will return `None` if arithmetic overflow occurs.
    pub fn checked_deduct_total(&self, balance: Word) -> Option<Word> {
        let fee = self.max_fee();

        balance.checked_sub(fee)
    }

    /// Attempt to create a transaction fee from parameters and transaction internals
    ///
    /// Will return `None` if arithmetic overflow occurs.
    pub fn checked_from_tx<T>(
        gas_costs: &GasCosts,
        params: &FeeParameters,
        tx: &T,
        gas_price: Word,
    ) -> Option<Self>
    where
        T: Chargeable,
    {
        let min_gas = tx.min_gas(gas_costs, params);
        let max_gas = tx.max_gas(gas_costs, params);
        let min_fee = tx.min_fee(gas_costs, params, gas_price).try_into().ok()?;
        let max_fee = tx.max_fee(gas_costs, params, gas_price).try_into().ok()?;

        if min_fee > max_fee {
            return None;
        }

        Some(Self::new(min_fee, max_fee, min_gas, max_gas))
    }
}

fn gas_to_fee(gas: Word, gas_price: Word, factor: Word) -> u128 {
    let total_price = (gas as u128)
        .checked_mul(gas_price as u128)
        .expect("Impossible to overflow because multiplication of two `u64` <= `u128`");
    total_price.div_ceil(factor as u128)
}

/// Returns the minimum gas required to start execution of any transaction.
pub fn min_gas<Tx>(tx: &Tx, gas_costs: &GasCosts, fee: &FeeParameters) -> Word
where
    Tx: Chargeable + ?Sized,
{
    let bytes_size = tx.metered_bytes_size();

    let vm_initialization_gas = gas_costs.vm_initialization().resolve(bytes_size as Word);

    // It's okay to saturate because we have the `max_gas_per_tx` rule for transaction
    // validity. In the production, the value always will be lower than
    // `u64::MAX`.
    let bytes_gas = fee.gas_per_byte().saturating_mul(bytes_size as u64);
    tx.gas_used_by_inputs(gas_costs)
        .saturating_add(tx.gas_used_by_metadata(gas_costs))
        .saturating_add(bytes_gas)
        .saturating_add(vm_initialization_gas)
}

/// Means that the blockchain charges fee for the transaction.
pub trait Chargeable: field::Inputs + field::Witnesses + field::Policies {
    /// Returns the minimum gas required to start transaction execution.
    fn min_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> Word {
        min_gas(self, gas_costs, fee)
    }

    /// Returns the maximum possible gas after the end of transaction execution.
    ///
    /// The function guarantees that the value is not less than [Self::min_gas].
    fn max_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> Word {
        let remaining_allowed_witness_gas = self
            .witness_limit()
            .saturating_sub(self.witnesses().size_dynamic() as u64)
            .saturating_mul(fee.gas_per_byte());

        self.min_gas(gas_costs, fee)
            .saturating_add(remaining_allowed_witness_gas)
    }

    /// Returns the minimum fee required to start transaction execution.
    fn min_fee(
        &self,
        gas_costs: &GasCosts,
        fee: &FeeParameters,
        gas_price: Word,
    ) -> u128 {
        let tip = self.tip();
        let gas_fee = gas_to_fee(
            self.min_gas(gas_costs, fee),
            gas_price,
            fee.gas_price_factor(),
        );
        gas_fee.saturating_add(tip as u128)
    }

    /// Returns the maximum possible fee after the end of transaction execution.
    ///
    /// The function guarantees that the value is not less than [Self::min_fee].
    fn max_fee(
        &self,
        gas_costs: &GasCosts,
        fee: &FeeParameters,
        gas_price: Word,
    ) -> u128 {
        let tip = self.tip();
        let gas_fee = gas_to_fee(
            self.max_gas(gas_costs, fee),
            gas_price,
            fee.gas_price_factor(),
        );
        gas_fee.saturating_add(tip as u128)
    }

    /// Returns the fee amount that can be refunded back based on the `used_gas` and
    /// current state of the transaction.
    ///
    /// Return `None` if overflow occurs.
    fn refund_fee(
        &self,
        gas_costs: &GasCosts,
        fee: &FeeParameters,
        used_gas: Word,
        gas_price: Word,
    ) -> Option<Word> {
        // We've already charged the user for witnesses as part of the minimal gas and all
        // execution required to validate transaction validity rules.
        let min_gas = self.min_gas(gas_costs, fee);

        let total_used_gas = min_gas.saturating_add(used_gas);
        let tip = self.policies().get(PolicyType::Tip).unwrap_or(0);
        let used_fee = gas_to_fee(total_used_gas, gas_price, fee.gas_price_factor())
            .saturating_add(tip as u128);

        // It is okay to saturate everywhere above because it only can decrease the value
        // of `refund`. But here, because we need to return the amount we
        // want to refund, we need to handle the overflow caused by the price.
        let used_fee: u64 = used_fee.try_into().ok()?;
        self.max_fee_limit().checked_sub(used_fee)
    }

    /// Used for accounting purposes when charging byte based fees.
    fn metered_bytes_size(&self) -> usize;

    /// Returns the gas used by the inputs.
    fn gas_used_by_inputs(&self, gas_costs: &GasCosts) -> Word {
        let mut witness_cache: HashSet<u16> = HashSet::new();
        self.inputs()
            .iter()
            .filter(|input| match input {
                // Include signed inputs of unique witness indices
                Input::CoinSigned(CoinSigned { witness_index, .. })
                | Input::MessageCoinSigned(MessageCoinSigned { witness_index, .. })
                | Input::MessageDataSigned(MessageDataSigned { witness_index, .. })
                    if !witness_cache.contains(witness_index) =>
                {
                    witness_cache.insert(*witness_index);
                    true
                }
                // Include all predicates
                Input::CoinPredicate(_)
                | Input::MessageCoinPredicate(_)
                | Input::MessageDataPredicate(_) => true,
                // Ignore all other inputs
                _ => false,
            })
            .map(|input| match input {
                // Charge EC recovery cost for signed inputs
                Input::CoinSigned(_)
                | Input::MessageCoinSigned(_)
                | Input::MessageDataSigned(_) => gas_costs.eck1(),
                // Charge the cost of the contract root for predicate inputs
                Input::CoinPredicate(CoinPredicate {
                    predicate,
                    predicate_gas_used,
                    ..
                })
                | Input::MessageCoinPredicate(MessageCoinPredicate {
                    predicate,
                    predicate_gas_used,
                    ..
                })
                | Input::MessageDataPredicate(MessageDataPredicate {
                    predicate,
                    predicate_gas_used,
                    ..
                }) => {
                    let bytes_size = self.metered_bytes_size();
                    let vm_initialization_gas =
                        gas_costs.vm_initialization().resolve(bytes_size as Word);
                    gas_costs
                        .contract_root()
                        .resolve(predicate.len() as u64)
                        .saturating_add(*predicate_gas_used)
                        .saturating_add(vm_initialization_gas)
                }
                // Charge nothing for all other inputs
                _ => 0,
            })
            .fold(0, |acc, cost| acc.saturating_add(cost))
    }

    /// Used for accounting purposes when charging for metadata creation.
    fn gas_used_by_metadata(&self, gas_costs: &GasCosts) -> Word;
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/metadata.rs

Source
use alloc::vec::Vec;
use fuel_types::{
    canonical::Serialize,
    Bytes32,
    ChainId,
};

use crate::{
    field,
    UniqueIdentifier,
    ValidityError,
};

/// Entity support metadata computation to cache results.
pub trait Cacheable {
    /// The cache is already computed.
    ///
    /// # Note: `true` doesn't mean that the cache is actual.
    fn is_computed(&self) -> bool;

    /// Computes the cache for the entity.
    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError>;
}

impl Cacheable for super::Transaction {
    fn is_computed(&self) -> bool {
        match self {
            Self::Script(tx) => tx.is_computed(),
            Self::Create(tx) => tx.is_computed(),
            Self::Mint(tx) => tx.is_computed(),
            Self::Upgrade(tx) => tx.is_computed(),
            Self::Upload(tx) => tx.is_computed(),
            Self::Blob(tx) => tx.is_computed(),
        }
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        match self {
            Self::Script(tx) => tx.precompute(chain_id),
            Self::Create(tx) => tx.precompute(chain_id),
            Self::Mint(tx) => tx.precompute(chain_id),
            Self::Upgrade(tx) => tx.precompute(chain_id),
            Self::Upload(tx) => tx.precompute(chain_id),
            Self::Blob(tx) => tx.precompute(chain_id),
        }
    }
}

/// Common metadata for `Script` and `Create` transactions.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CommonMetadata {
    pub id: Bytes32,
    pub inputs_offset: usize,
    pub inputs_offset_at: Vec<usize>,
    pub inputs_predicate_offset_at: Vec<Option<(usize, usize)>>,
    pub outputs_offset: usize,
    pub outputs_offset_at: Vec<usize>,
    pub witnesses_offset: usize,
    pub witnesses_offset_at: Vec<usize>,
}

impl CommonMetadata {
    /// Computes the `Metadata` for the `tx` transaction.
    /// Returns `None` if the transaction is invalid.
    pub fn compute<Tx>(tx: &Tx, chain_id: &ChainId) -> Result<Self, ValidityError>
    where
        Tx: UniqueIdentifier,
        Tx: field::Inputs,
        Tx: field::Outputs,
        Tx: field::Witnesses,
    {
        use itertools::Itertools;

        let id = tx.id(chain_id);

        let inputs_predicate_offset_at = tx
            .inputs()
            .iter()
            .enumerate()
            .map(|(i, _)| tx.inputs_predicate_offset_at(i))
            .collect_vec();

        let mut offset = tx.inputs_offset();
        let mut inputs_offset_at = Vec::new();
        for (index, input) in tx.inputs().iter().enumerate() {
            let i = offset;
            offset = offset
                .checked_add(input.size())
                .ok_or(ValidityError::SerializedInputTooLarge { index })?;
            inputs_offset_at.push(i);
        }

        let mut offset = tx.outputs_offset();
        let mut outputs_offset_at = Vec::new();
        for (index, output) in tx.outputs().iter().enumerate() {
            let i = offset;
            offset = offset
                .checked_add(output.size())
                .ok_or(ValidityError::SerializedOutputTooLarge { index })?;
            outputs_offset_at.push(i);
        }

        let mut offset = tx.witnesses_offset();
        let mut witnesses_offset_at = Vec::new();
        for (index, witnesses) in tx.witnesses().iter().enumerate() {
            let i = offset;
            offset = offset
                .checked_add(witnesses.size())
                .ok_or(ValidityError::SerializedWitnessTooLarge { index })?;
            witnesses_offset_at.push(i);
        }

        Ok(Self {
            id,
            inputs_offset: tx.inputs_offset(),
            inputs_offset_at,
            inputs_predicate_offset_at,
            outputs_offset: tx.outputs_offset(),
            outputs_offset_at,
            witnesses_offset: tx.witnesses_offset(),
            witnesses_offset_at,
        })
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/repr.rs

Source
use crate::Transaction;

#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Hash,
    serde::Serialize,
    serde::Deserialize,
    fuel_types::canonical::Serialize,
    fuel_types::canonical::Deserialize,
)]
#[repr(u64)]
pub enum TransactionRepr {
    Script = 0x00,
    Create = 0x01,
    Mint = 0x02,
    Upgrade = 0x03,
    Upload = 0x04,
    Blob = 0x05,
}

impl From<&Transaction> for TransactionRepr {
    fn from(tx: &Transaction) -> Self {
        match tx {
            Transaction::Script { .. } => Self::Script,
            Transaction::Create { .. } => Self::Create,
            Transaction::Mint { .. } => Self::Mint,
            Transaction::Upgrade { .. } => Self::Upgrade,
            Transaction::Upload { .. } => Self::Upload,
            Transaction::Blob { .. } => Self::Blob,
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types.rs

Source
mod blob;
mod chargeable_transaction;
mod create;
pub mod input;
mod mint;
pub mod output;
mod script;
mod storage;
mod upgrade;
mod upload;
mod utxo_id;
mod witness;

pub use blob::{
    Blob,
    BlobBody,
    BlobIdExt,
    BlobMetadata,
};
pub use chargeable_transaction::{
    ChargeableMetadata,
    ChargeableTransaction,
};
pub use create::{
    Create,
    CreateBody,
    CreateMetadata,
};
pub use mint::Mint;
pub use script::{
    Script,
    ScriptBody,
    ScriptCode,
};
pub use storage::StorageSlot;
pub use upgrade::{
    Upgrade,
    UpgradeBody,
    UpgradeMetadata,
    UpgradePurpose,
};
pub use upload::{
    Upload,
    UploadBody,
    UploadMetadata,
    UploadSubsection,
};
pub use utxo_id::UtxoId;
pub use witness::Witness;

#[cfg(feature = "da-compression")]
pub use self::{
    mint::CompressedMint,
    utxo_id::CompressedUtxoId,
};

pub fn compute_transaction_id<T: fuel_types::canonical::Serialize>(
    chain_id: &fuel_types::ChainId,
    tx: &mut T,
) -> crate::TxId {
    let mut hasher = fuel_crypto::Hasher::default();
    // chain ID
    hasher.input(chain_id.to_be_bytes());
    // transaction bytes
    hasher.input(tx.to_bytes().as_slice());
    hasher.finalize()
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/validity.rs

Source
use crate::{
    field::Maturity,
    input::{
        coin::{
            CoinPredicate,
            CoinSigned,
        },
        message::{
            MessageCoinPredicate,
            MessageCoinSigned,
            MessageDataPredicate,
            MessageDataSigned,
        },
    },
    output,
    policies::PolicyType,
    transaction::{
        consensus_parameters::{
            PredicateParameters,
            TxParameters,
        },
        field,
        Executable,
    },
    Chargeable,
    ConsensusParameters,
    Input,
    Output,
    Transaction,
    Witness,
};
use core::hash::Hash;
use fuel_types::{
    canonical,
    canonical::Serialize,
    Address,
    BlockHeight,
    Bytes32,
    ChainId,
};
use hashbrown::HashMap;
use itertools::Itertools;

mod error;

#[cfg(test)]
mod tests;

pub use error::ValidityError;

impl Input {
    pub fn check(
        &self,
        index: usize,
        txhash: &Bytes32,
        outputs: &[Output],
        witnesses: &[Witness],
        predicate_params: &PredicateParameters,
        recovery_cache: &mut Option<HashMap<u16, Address>>,
    ) -> Result<(), ValidityError> {
        self.check_without_signature(index, outputs, witnesses, predicate_params)?;
        self.check_signature(index, txhash, witnesses, recovery_cache)?;

        Ok(())
    }

    pub fn check_signature(
        &self,
        index: usize,
        txhash: &Bytes32,
        witnesses: &[Witness],
        recovery_cache: &mut Option<HashMap<u16, Address>>,
    ) -> Result<(), ValidityError> {
        match self {
            Self::CoinSigned(CoinSigned {
                witness_index,
                owner,
                ..
            })
            | Self::MessageCoinSigned(MessageCoinSigned {
                witness_index,
                recipient: owner,
                ..
            })
            | Self::MessageDataSigned(MessageDataSigned {
                witness_index,
                recipient: owner,
                ..
            }) => {
                // Helper function for recovering the address from a witness
                let recover_address = || -> Result<Address, ValidityError> {
                    let witness = witnesses
                        .get(*witness_index as usize)
                        .ok_or(ValidityError::InputWitnessIndexBounds { index })?;

                    witness.recover_witness(txhash, index)
                };

                // recover the address associated with a witness, using the cache if
                // available
                let recovered_address = if let Some(cache) = recovery_cache {
                    if let Some(recovered_address) = cache.get(witness_index) {
                        *recovered_address
                    } else {
                        // if this witness hasn't been recovered before,
                        // cache ecrecover by witness index
                        let recovered_address = recover_address()?;
                        cache.insert(*witness_index, recovered_address);
                        recovered_address
                    }
                } else {
                    recover_address()?
                };

                if owner != &recovered_address {
                    return Err(ValidityError::InputInvalidSignature { index });
                }

                Ok(())
            }

            Self::CoinPredicate(CoinPredicate {
                owner, predicate, ..
            })
            | Self::MessageCoinPredicate(MessageCoinPredicate {
                recipient: owner,
                predicate,
                ..
            })
            | Self::MessageDataPredicate(MessageDataPredicate {
                recipient: owner,
                predicate,
                ..
            }) if !Input::is_predicate_owner_valid(owner, &**predicate) => {
                Err(ValidityError::InputPredicateOwner { index })
            }

            _ => Ok(()),
        }
    }

    pub fn check_without_signature(
        &self,
        index: usize,
        outputs: &[Output],
        witnesses: &[Witness],
        predicate_params: &PredicateParameters,
    ) -> Result<(), ValidityError> {
        match self {
            Self::CoinPredicate(CoinPredicate { predicate, .. })
            | Self::MessageCoinPredicate(MessageCoinPredicate { predicate, .. })
            | Self::MessageDataPredicate(MessageDataPredicate { predicate, .. })
                if predicate.is_empty() =>
            {
                Err(ValidityError::InputPredicateEmpty { index })
            }

            Self::CoinPredicate(CoinPredicate { predicate, .. })
            | Self::MessageCoinPredicate(MessageCoinPredicate { predicate, .. })
            | Self::MessageDataPredicate(MessageDataPredicate { predicate, .. })
                if predicate.len() as u64 > predicate_params.max_predicate_length() =>
            {
                Err(ValidityError::InputPredicateLength { index })
            }

            Self::CoinPredicate(CoinPredicate { predicate_data, .. })
            | Self::MessageCoinPredicate(MessageCoinPredicate {
                predicate_data, ..
            })
            | Self::MessageDataPredicate(MessageDataPredicate {
                predicate_data, ..
            }) if predicate_data.len() as u64
                > predicate_params.max_predicate_data_length() =>
            {
                Err(ValidityError::InputPredicateDataLength { index })
            }

            Self::CoinSigned(CoinSigned { witness_index, .. })
            | Self::MessageCoinSigned(MessageCoinSigned { witness_index, .. })
            | Self::MessageDataSigned(MessageDataSigned { witness_index, .. })
                if *witness_index as usize >= witnesses.len() =>
            {
                Err(ValidityError::InputWitnessIndexBounds { index })
            }

            // ∀ inputContract ∃! outputContract : outputContract.inputIndex =
            // inputContract.index
            Self::Contract { .. }
                if 1 != outputs
                    .iter()
                    .filter_map(|output| match output {
                        Output::Contract(output::contract::Contract {
                            input_index,
                            ..
                        }) if *input_index as usize == index => Some(()),
                        _ => None,
                    })
                    .count() =>
            {
                Err(ValidityError::InputContractAssociatedOutputContract { index })
            }

            Self::MessageDataSigned(MessageDataSigned { data, .. })
            | Self::MessageDataPredicate(MessageDataPredicate { data, .. })
                if data.is_empty()
                    || data.len() as u64 > predicate_params.max_message_data_length() =>
            {
                Err(ValidityError::InputMessageDataLength { index })
            }

            // TODO: If h is the block height the UTXO being spent was created,
            // transaction is  invalid if `blockheight() < h + maturity`.
            _ => Ok(()),
        }
    }
}

impl Output {
    /// Validate the output of the transaction.
    ///
    /// This function is stateful - meaning it might validate a transaction during VM
    /// initialization, but this transaction will no longer be valid in post-execution
    /// because the VM might mutate the message outputs, producing invalid
    /// transactions.
    pub fn check(&self, index: usize, inputs: &[Input]) -> Result<(), ValidityError> {
        match self {
            Self::Contract(output::contract::Contract { input_index, .. }) => {
                match inputs.get(*input_index as usize) {
                    Some(Input::Contract { .. }) => Ok(()),
                    _ => Err(ValidityError::OutputContractInputIndex { index }),
                }
            }

            _ => Ok(()),
        }
    }
}

/// Contains logic for stateless validations that don't result in any reusable metadata
/// such as spendable input balances or remaining gas. Primarily involves validating that
/// transaction fields are correctly formatted and signed.
pub trait FormatValidityChecks {
    /// Performs all stateless transaction validity checks. This includes the validity
    /// of fields according to rules in the specification and validity of signatures.
    fn check(
        &self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        self.check_without_signatures(block_height, consensus_params)?;
        self.check_signatures(&consensus_params.chain_id())?;

        Ok(())
    }

    /// Validates that all required signatures are set in the transaction and that they
    /// are valid.
    fn check_signatures(&self, chain_id: &ChainId) -> Result<(), ValidityError>;

    /// Validates the transactions according to rules from the specification:
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md>
    fn check_without_signatures(
        &self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError>;
}

impl FormatValidityChecks for Transaction {
    fn check_signatures(&self, chain_id: &ChainId) -> Result<(), ValidityError> {
        match self {
            Self::Script(tx) => tx.check_signatures(chain_id),
            Self::Create(tx) => tx.check_signatures(chain_id),
            Self::Mint(tx) => tx.check_signatures(chain_id),
            Self::Upgrade(tx) => tx.check_signatures(chain_id),
            Self::Upload(tx) => tx.check_signatures(chain_id),
            Self::Blob(tx) => tx.check_signatures(chain_id),
        }
    }

    fn check_without_signatures(
        &self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        match self {
            Self::Script(tx) => {
                tx.check_without_signatures(block_height, consensus_params)
            }
            Self::Create(tx) => {
                tx.check_without_signatures(block_height, consensus_params)
            }
            Self::Mint(tx) => tx.check_without_signatures(block_height, consensus_params),
            Self::Upgrade(tx) => {
                tx.check_without_signatures(block_height, consensus_params)
            }
            Self::Upload(tx) => {
                tx.check_without_signatures(block_height, consensus_params)
            }
            Self::Blob(tx) => tx.check_without_signatures(block_height, consensus_params),
        }
    }
}

/// Validates the size of the transaction in bytes. Transactions cannot exceed
/// the total size specified by the transaction parameters. The size of a
/// transaction is calculated as the sum of the sizes of its static and dynamic
/// parts.
pub(crate) fn check_size<T>(tx: &T, tx_params: &TxParameters) -> Result<(), ValidityError>
where
    T: canonical::Serialize,
{
    if tx.size() as u64 > tx_params.max_size() {
        Err(ValidityError::TransactionSizeLimitExceeded)?;
    }

    Ok(())
}

pub(crate) fn check_common_part<T>(
    tx: &T,
    block_height: BlockHeight,
    consensus_params: &ConsensusParameters,
) -> Result<(), ValidityError>
where
    T: canonical::Serialize + Chargeable + field::Outputs,
{
    let tx_params = consensus_params.tx_params();
    let predicate_params = consensus_params.predicate_params();
    let base_asset_id = consensus_params.base_asset_id();
    let gas_costs = consensus_params.gas_costs();
    let fee_params = consensus_params.fee_params();

    check_size(tx, tx_params)?;

    if !tx.policies().is_valid() {
        Err(ValidityError::TransactionPoliciesAreInvalid)?
    }

    if let Some(witness_limit) = tx.policies().get(PolicyType::WitnessLimit) {
        let witness_size = tx.witnesses().size_dynamic();
        if witness_size as u64 > witness_limit {
            Err(ValidityError::TransactionWitnessLimitExceeded)?
        }
    }

    let max_gas = tx.max_gas(gas_costs, fee_params);
    if max_gas > tx_params.max_gas_per_tx() {
        Err(ValidityError::TransactionMaxGasExceeded)?
    }

    if !tx.policies().is_set(PolicyType::MaxFee) {
        Err(ValidityError::TransactionMaxFeeNotSet)?
    };

    if tx.maturity() > block_height {
        Err(ValidityError::TransactionMaturity)?;
    }

    if tx.inputs().len() > tx_params.max_inputs() as usize {
        Err(ValidityError::TransactionInputsMax)?
    }

    if tx.outputs().len() > tx_params.max_outputs() as usize {
        Err(ValidityError::TransactionOutputsMax)?
    }

    if tx.witnesses().len() > tx_params.max_witnesses() as usize {
        Err(ValidityError::TransactionWitnessesMax)?
    }

    let any_spendable_input = tx.inputs().iter().find(|input| match input {
        Input::CoinSigned(_)
        | Input::CoinPredicate(_)
        | Input::MessageCoinSigned(_)
        | Input::MessageCoinPredicate(_) => true,
        Input::MessageDataSigned(_)
        | Input::MessageDataPredicate(_)
        | Input::Contract(_) => false,
    });

    if any_spendable_input.is_none() {
        Err(ValidityError::NoSpendableInput)?
    }

    tx.input_asset_ids_unique(base_asset_id)
        .try_for_each(|input_asset_id| {
            // check for duplicate change outputs
            if tx
                .outputs()
                .iter()
                .filter_map(|output| match output {
                    Output::Change { asset_id, .. } if input_asset_id == asset_id => {
                        Some(())
                    }
                    _ => None,
                })
                .count()
                > 1
            {
                return Err(ValidityError::TransactionOutputChangeAssetIdDuplicated(
                    *input_asset_id,
                ));
            }

            Ok(())
        })?;

    // Check for duplicated input utxo id
    let duplicated_utxo_id = tx
        .inputs()
        .iter()
        .filter_map(|i| i.is_coin().then(|| i.utxo_id()).flatten());

    if let Some(utxo_id) = next_duplicate(duplicated_utxo_id).copied() {
        return Err(ValidityError::DuplicateInputUtxoId { utxo_id });
    }

    // Check for duplicated input contract id
    let duplicated_contract_id = tx.inputs().iter().filter_map(Input::contract_id);

    if let Some(contract_id) = next_duplicate(duplicated_contract_id).copied() {
        return Err(ValidityError::DuplicateInputContractId { contract_id });
    }

    // Check for duplicated input message id
    let duplicated_message_id = tx.inputs().iter().filter_map(Input::message_id);
    if let Some(message_id) = next_duplicate(duplicated_message_id) {
        return Err(ValidityError::DuplicateMessageInputId { message_id });
    }

    // Validate the inputs without checking signature
    tx.inputs()
        .iter()
        .enumerate()
        .try_for_each(|(index, input)| {
            input.check_without_signature(
                index,
                tx.outputs(),
                tx.witnesses(),
                predicate_params,
            )
        })?;

    tx.outputs()
        .iter()
        .enumerate()
        .try_for_each(|(index, output)| {
            output.check(index, tx.inputs())?;

            if let Output::Change { asset_id, .. } = output {
                if !tx
                    .input_asset_ids(base_asset_id)
                    .any(|input_asset_id| input_asset_id == asset_id)
                {
                    return Err(ValidityError::TransactionOutputChangeAssetIdNotFound(
                        *asset_id,
                    ));
                }
            }

            if let Output::Coin { asset_id, .. } = output {
                if !tx
                    .input_asset_ids(base_asset_id)
                    .any(|input_asset_id| input_asset_id == asset_id)
                {
                    return Err(ValidityError::TransactionOutputCoinAssetIdNotFound(
                        *asset_id,
                    ));
                }
            }

            Ok(())
        })?;

    Ok(())
}

// TODO https://github.com/FuelLabs/fuel-tx/issues/148
pub(crate) fn next_duplicate<U>(iter: impl Iterator<Item = U>) -> Option<U>
where
    U: PartialEq + Ord + Copy + Hash,
{
    #[cfg(not(feature = "std"))]
    {
        iter.sorted()
            .as_slice()
            .windows(2)
            .filter_map(|u| (u[0] == u[1]).then(|| u[0]))
            .next()
    }

    #[cfg(feature = "std")]
    {
        iter.duplicates().next()
    }
}

#[cfg(feature = "typescript")]
mod typescript {
    use crate::{
        transaction::consensus_parameters::typescript::PredicateParameters,
        Witness,
    };
    use fuel_types::Bytes32;
    use wasm_bindgen::JsValue;

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

    use crate::transaction::{
        input_ts::Input,
        output_ts::Output,
    };

    #[wasm_bindgen::prelude::wasm_bindgen]
    pub fn check_input(
        input: &Input,
        index: usize,
        txhash: &Bytes32,
        outputs: Vec<JsValue>,
        witnesses: Vec<JsValue>,
        predicate_params: &PredicateParameters,
    ) -> Result<(), js_sys::Error> {
        let outputs: Vec<crate::Output> = outputs
            .into_iter()
            .map(|v| serde_wasm_bindgen::from_value::<Output>(v).map(|v| *v.0))
            .collect::<Result<Vec<_>, _>>()
            .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))?;

        let witnesses: Vec<Witness> = witnesses
            .into_iter()
            .map(serde_wasm_bindgen::from_value::<Witness>)
            .collect::<Result<Vec<_>, _>>()
            .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))?;

        input
            .0
            .check(
                index,
                txhash,
                &outputs,
                &witnesses,
                predicate_params.as_ref(),
                &mut None,
            )
            .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
    }

    #[wasm_bindgen::prelude::wasm_bindgen]
    pub fn check_output(
        output: &Output,
        index: usize,
        inputs: Vec<JsValue>,
    ) -> Result<(), js_sys::Error> {
        let inputs: Vec<crate::Input> = inputs
            .into_iter()
            .map(|v| serde_wasm_bindgen::from_value::<Input>(v).map(|v| *v.0))
            .collect::<Result<Vec<_>, _>>()
            .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))?;

        output
            .0
            .check(index, &inputs)
            .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/script.rs

Source
use core::ops::{
    Deref,
    DerefMut,
};

use crate::{
    field::WitnessLimit,
    transaction::{
        field::{
            ReceiptsRoot,
            Script as ScriptField,
            ScriptData,
            ScriptGasLimit,
            Witnesses,
        },
        id::PrepareSign,
        metadata::CommonMetadata,
        types::chargeable_transaction::{
            ChargeableMetadata,
            ChargeableTransaction,
            UniqueFormatValidityChecks,
        },
        Chargeable,
    },
    ConsensusParameters,
    FeeParameters,
    GasCosts,
    Output,
    TransactionRepr,
    ValidityError,
};
use derivative::Derivative;
use fuel_types::{
    bytes,
    bytes::WORD_SIZE,
    canonical::Serialize,
    fmt_truncated_hex,
    Bytes32,
    ChainId,
    Word,
};

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

pub type Script = ChargeableTransaction<ScriptBody, ScriptMetadata>;

#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
pub struct ScriptMetadata {
    pub script_data_offset: usize,
}

#[derive(Clone, Default, Derivative, serde::Serialize, serde::Deserialize)]
#[serde(transparent)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub struct ScriptCode {
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))]
    pub bytes: Vec<u8>,
}

impl From<Vec<u8>> for ScriptCode {
    fn from(bytes: Vec<u8>) -> Self {
        Self { bytes }
    }
}

impl From<&[u8]> for ScriptCode {
    fn from(bytes: &[u8]) -> Self {
        Self {
            bytes: bytes.to_vec(),
        }
    }
}

impl AsRef<[u8]> for ScriptCode {
    fn as_ref(&self) -> &[u8] {
        &self.bytes
    }
}

impl AsMut<[u8]> for ScriptCode {
    fn as_mut(&mut self) -> &mut [u8] {
        &mut self.bytes
    }
}

impl Deref for ScriptCode {
    type Target = Vec<u8>;

    fn deref(&self) -> &Self::Target {
        &self.bytes
    }
}

impl DerefMut for ScriptCode {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.bytes
    }
}

#[cfg(feature = "da-compression")]
impl fuel_compression::Compressible for ScriptCode {
    type Compressed = fuel_compression::RegistryKey;
}

#[derive(
    Clone,
    Derivative,
    serde::Serialize,
    serde::Deserialize,
    fuel_types::canonical::Deserialize,
    fuel_types::canonical::Serialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[canonical(prefix = TransactionRepr::Script)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub struct ScriptBody {
    pub(crate) script_gas_limit: Word,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub(crate) receipts_root: Bytes32,
    pub(crate) script: ScriptCode,
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))]
    pub(crate) script_data: Vec<u8>,
}

impl Default for ScriptBody {
    fn default() -> Self {
        // Create a valid transaction with a single return instruction
        //
        // The Return op is mandatory for the execution of any context
        let script = fuel_asm::op::ret(0x10).to_bytes().to_vec();

        Self {
            script_gas_limit: Default::default(),
            receipts_root: Default::default(),
            script: script.into(),
            script_data: Default::default(),
        }
    }
}

impl PrepareSign for ScriptBody {
    fn prepare_sign(&mut self) {
        // Prepare script for execution by clearing malleable fields.
        self.receipts_root = Default::default();
    }
}

impl Chargeable for Script {
    #[inline(always)]
    fn max_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> fuel_asm::Word {
        // The basic implementation of the `max_gas` + `gas_limit`.
        let remaining_allowed_witness = self
            .witness_limit()
            .saturating_sub(self.witnesses().size_dynamic() as u64)
            .saturating_mul(fee.gas_per_byte());

        self.min_gas(gas_costs, fee)
            .saturating_add(remaining_allowed_witness)
            .saturating_add(self.body.script_gas_limit)
    }

    #[inline(always)]
    fn metered_bytes_size(&self) -> usize {
        Serialize::size(self)
    }

    #[inline(always)]
    fn gas_used_by_metadata(&self, gas_cost: &GasCosts) -> Word {
        let bytes = Serialize::size(self);
        // Gas required to calculate the `tx_id`.
        gas_cost.s256().resolve(bytes as u64)
    }
}

impl UniqueFormatValidityChecks for Script {
    fn check_unique_rules(
        &self,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        let script_params = consensus_params.script_params();
        if self.body.script.len() as u64 > script_params.max_script_length() {
            Err(ValidityError::TransactionScriptLength)?;
        }

        if self.body.script_data.len() as u64 > script_params.max_script_data_length() {
            Err(ValidityError::TransactionScriptDataLength)?;
        }

        self.outputs
            .iter()
            .enumerate()
            .try_for_each(|(index, output)| match output {
                Output::ContractCreated { .. } => {
                    Err(ValidityError::TransactionOutputContainsContractCreated { index })
                }
                _ => Ok(()),
            })?;

        Ok(())
    }
}

impl crate::Cacheable for Script {
    fn is_computed(&self) -> bool {
        self.metadata.is_some()
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        self.metadata = None;
        self.metadata = Some(ChargeableMetadata {
            common: CommonMetadata::compute(self, chain_id)?,
            body: ScriptMetadata {
                script_data_offset: self.script_data_offset(),
            },
        });
        Ok(())
    }
}

mod field {
    use super::*;
    use crate::field::ChargeableBody;

    impl ScriptGasLimit for Script {
        #[inline(always)]
        fn script_gas_limit(&self) -> &Word {
            &self.body.script_gas_limit
        }

        #[inline(always)]
        fn script_gas_limit_mut(&mut self) -> &mut Word {
            &mut self.body.script_gas_limit
        }

        #[inline(always)]
        fn script_gas_limit_offset_static() -> usize {
            WORD_SIZE // `Transaction` enum discriminant
        }
    }

    impl ReceiptsRoot for Script {
        #[inline(always)]
        fn receipts_root(&self) -> &Bytes32 {
            &self.body.receipts_root
        }

        #[inline(always)]
        fn receipts_root_mut(&mut self) -> &mut Bytes32 {
            &mut self.body.receipts_root
        }

        #[inline(always)]
        fn receipts_root_offset_static() -> usize {
            Self::script_gas_limit_offset_static().saturating_add(WORD_SIZE)
        }
    }

    impl ScriptField for Script {
        #[inline(always)]
        fn script(&self) -> &Vec<u8> {
            &self.body.script
        }

        #[inline(always)]
        fn script_mut(&mut self) -> &mut Vec<u8> {
            &mut self.body.script
        }

        #[inline(always)]
        fn script_offset_static() -> usize {
            Self::receipts_root_offset_static().saturating_add(
                Bytes32::LEN // Receipts root
                + WORD_SIZE // Script size
                + WORD_SIZE // Script data size
                + WORD_SIZE // Policies size
                + WORD_SIZE // Inputs size
                + WORD_SIZE // Outputs size
                + WORD_SIZE, // Witnesses size
            )
        }
    }

    impl ScriptData for Script {
        #[inline(always)]
        fn script_data(&self) -> &Vec<u8> {
            &self.body.script_data
        }

        #[inline(always)]
        fn script_data_mut(&mut self) -> &mut Vec<u8> {
            &mut self.body.script_data
        }

        #[inline(always)]
        fn script_data_offset(&self) -> usize {
            if let Some(ChargeableMetadata { body, .. }) = &self.metadata {
                return body.script_data_offset;
            }

            self.script_offset().saturating_add(
                bytes::padded_len(self.body.script.as_slice()).unwrap_or(usize::MAX),
            )
        }
    }

    impl ChargeableBody<ScriptBody> for Script {
        fn body(&self) -> &ScriptBody {
            &self.body
        }

        fn body_mut(&mut self) -> &mut ScriptBody {
            &mut self.body
        }

        fn body_offset_end(&self) -> usize {
            self.script_data_offset().saturating_add(
                bytes::padded_len(self.body.script_data.as_slice()).unwrap_or(usize::MAX),
            )
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/create.rs

Source
use crate::{
    transaction::{
        field::{
            BytecodeWitnessIndex,
            Salt as SaltField,
            StorageSlots,
        },
        metadata::CommonMetadata,
        types::chargeable_transaction::{
            ChargeableMetadata,
            ChargeableTransaction,
            UniqueFormatValidityChecks,
        },
    },
    Chargeable,
    ConsensusParameters,
    Contract,
    GasCosts,
    Input,
    Output,
    PrepareSign,
    StorageSlot,
    TransactionRepr,
    ValidityError,
};
use derivative::Derivative;
use fuel_types::{
    bytes::WORD_SIZE,
    canonical,
    Bytes32,
    Bytes4,
    ChainId,
    ContractId,
    Salt,
    Word,
};

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

#[cfg(all(test, feature = "std"))]
mod ser_de_tests;

pub type Create = ChargeableTransaction<CreateBody, CreateMetadata>;

#[derive(Default, Debug, Clone, Derivative)]
#[derivative(Eq, PartialEq, Hash)]
pub struct CreateMetadata {
    pub contract_id: ContractId,
    pub contract_root: Bytes32,
    pub state_root: Bytes32,
}

impl CreateMetadata {
    /// Computes the `Metadata` for the `tx` transaction.
    pub fn compute(tx: &Create) -> Result<Self, ValidityError> {
        let salt = tx.salt();
        let storage_slots = tx.storage_slots();
        let contract = Contract::try_from(tx)?;
        let contract_root = contract.root();
        let state_root = Contract::initial_state_root(storage_slots.iter());
        let contract_id = contract.id(salt, &contract_root, &state_root);

        Ok(Self {
            contract_id,
            contract_root,
            state_root,
        })
    }
}

#[derive(Default, Debug, Clone, Derivative, serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[canonical(prefix = TransactionRepr::Create)]
#[derivative(Eq, PartialEq, Hash)]
pub struct CreateBody {
    pub(crate) bytecode_witness_index: u16,
    pub(crate) salt: Salt,
    pub(crate) storage_slots: Vec<StorageSlot>,
}

impl PrepareSign for CreateBody {
    fn prepare_sign(&mut self) {}
}

impl Chargeable for Create {
    #[inline(always)]
    fn metered_bytes_size(&self) -> usize {
        canonical::Serialize::size(self)
    }

    fn gas_used_by_metadata(&self, gas_costs: &GasCosts) -> Word {
        let Create {
            body:
                CreateBody {
                    bytecode_witness_index,
                    storage_slots,
                    ..
                },
            witnesses,
            ..
        } = self;

        let contract_len = witnesses
            .get(*bytecode_witness_index as usize)
            .map(|c| c.as_ref().len())
            .unwrap_or(0);

        let contract_root_gas = gas_costs.contract_root().resolve(contract_len as Word);
        let state_root_length = storage_slots.len() as Word;
        let state_root_gas = gas_costs.state_root().resolve(state_root_length);

        // See https://github.com/FuelLabs/fuel-specs/blob/master/src/identifiers/contract-id.md
        let contract_id_input_length =
            Bytes4::LEN + Salt::LEN + Bytes32::LEN + Bytes32::LEN;
        let contract_id_gas = gas_costs.s256().resolve(contract_id_input_length as Word);
        let bytes = canonical::Serialize::size(self);
        // Gas required to calculate the `tx_id`.
        let tx_id_gas = gas_costs.s256().resolve(bytes as u64);

        contract_root_gas
            .saturating_add(state_root_gas)
            .saturating_add(contract_id_gas)
            .saturating_add(tx_id_gas)
    }
}

impl UniqueFormatValidityChecks for Create {
    fn check_unique_rules(
        &self,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        let contract_params = consensus_params.contract_params();
        let base_asset_id = consensus_params.base_asset_id();

        let bytecode_witness_len = self
            .witnesses
            .get(self.body.bytecode_witness_index as usize)
            .map(|w| w.as_ref().len() as Word)
            .ok_or(ValidityError::TransactionCreateBytecodeWitnessIndex)?;

        if bytecode_witness_len > contract_params.contract_max_size() {
            return Err(ValidityError::TransactionCreateBytecodeLen);
        }

        // Restrict to subset of u16::MAX, allowing this to be increased in the future
        // in a non-breaking way.
        if self.body.storage_slots.len() as u64 > contract_params.max_storage_slots() {
            return Err(ValidityError::TransactionCreateStorageSlotMax);
        }

        // Verify storage slots are sorted
        if !self
            .body
            .storage_slots
            .as_slice()
            .windows(2)
            .all(|s| s[0] < s[1])
        {
            return Err(ValidityError::TransactionCreateStorageSlotOrder);
        }

        self.inputs
            .iter()
            .enumerate()
            .try_for_each(|(index, input)| {
                if let Some(asset_id) = input.asset_id(consensus_params.base_asset_id()) {
                    if asset_id != consensus_params.base_asset_id() {
                        return Err(
                            ValidityError::TransactionInputContainsNonBaseAssetId {
                                index,
                            },
                        );
                    }
                }

                match input {
                    Input::Contract(_) => {
                        Err(ValidityError::TransactionInputContainsContract { index })
                    }
                    Input::MessageDataSigned(_) | Input::MessageDataPredicate(_) => {
                        Err(ValidityError::TransactionInputContainsMessageData { index })
                    }
                    _ => Ok(()),
                }
            })?;

        debug_assert!(
            self.metadata.is_some(),
            "`check_without_signatures` is called without cached metadata"
        );
        let (state_root_calculated, contract_id_calculated) =
            if let Some(metadata) = &self.metadata {
                (metadata.body.state_root, metadata.body.contract_id)
            } else {
                let metadata = CreateMetadata::compute(self)?;
                (metadata.state_root, metadata.contract_id)
            };

        let mut contract_created = false;
        self.outputs
            .iter()
            .enumerate()
            .try_for_each(|(index, output)| match output {
                Output::Contract(_) => {
                    Err(ValidityError::TransactionOutputContainsContract { index })
                }

                Output::Variable { .. } => {
                    Err(ValidityError::TransactionOutputContainsVariable { index })
                }

                Output::Change { asset_id, .. } if asset_id != base_asset_id => {
                    Err(ValidityError::TransactionChangeChangeUsesNotBaseAsset { index })
                }

                Output::ContractCreated {
                    contract_id,
                    state_root,
                } if contract_id != &contract_id_calculated
                    || state_root != &state_root_calculated =>
                    {
                        Err(
                            ValidityError::TransactionCreateOutputContractCreatedDoesntMatch {
                                index,
                            },
                        )
                    }

                // TODO: Output::ContractCreated { contract_id, state_root } if
                // contract_id == &id && state_root == &storage_root
                //  maybe move from `fuel-vm` to here
                Output::ContractCreated { .. } if contract_created => {
                    Err(ValidityError::TransactionCreateOutputContractCreatedMultiple {
                        index,
                    })
                }

                Output::ContractCreated { .. } => {
                    contract_created = true;

                    Ok(())
                }

                _ => Ok(()),
            })?;

        if !contract_created {
            return Err(ValidityError::TransactionOutputDoesntContainContractCreated);
        }

        Ok(())
    }
}

impl crate::Cacheable for Create {
    fn is_computed(&self) -> bool {
        self.metadata.is_some()
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        self.metadata = None;
        self.metadata = Some(ChargeableMetadata {
            common: CommonMetadata::compute(self, chain_id)?,
            body: CreateMetadata::compute(self)?,
        });
        Ok(())
    }
}

mod field {
    use super::*;
    use crate::field::{
        ChargeableBody,
        StorageSlotRef,
    };

    impl BytecodeWitnessIndex for Create {
        #[inline(always)]
        fn bytecode_witness_index(&self) -> &u16 {
            &self.body.bytecode_witness_index
        }

        #[inline(always)]
        fn bytecode_witness_index_mut(&mut self) -> &mut u16 {
            &mut self.body.bytecode_witness_index
        }

        #[inline(always)]
        fn bytecode_witness_index_offset_static() -> usize {
            WORD_SIZE // `Transaction` enum discriminant
        }
    }

    impl SaltField for Create {
        #[inline(always)]
        fn salt(&self) -> &Salt {
            &self.body.salt
        }

        #[inline(always)]
        fn salt_mut(&mut self) -> &mut Salt {
            &mut self.body.salt
        }

        #[inline(always)]
        fn salt_offset_static() -> usize {
            Self::bytecode_witness_index_offset_static().saturating_add(WORD_SIZE)
        }
    }

    impl StorageSlots for Create {
        #[inline(always)]
        fn storage_slots(&self) -> &Vec<StorageSlot> {
            &self.body.storage_slots
        }

        #[inline(always)]
        fn storage_slots_mut(&mut self) -> StorageSlotRef {
            StorageSlotRef {
                storage_slots: &mut self.body.storage_slots,
            }
        }

        #[inline(always)]
        fn storage_slots_offset_static() -> usize {
            Self::salt_offset_static().saturating_add(
                Salt::LEN
                + WORD_SIZE // Storage slots size
                + WORD_SIZE // Policies size
                + WORD_SIZE // Inputs size
                + WORD_SIZE // Outputs size
                + WORD_SIZE, // Witnesses size
            )
        }

        fn storage_slots_offset_at(&self, idx: usize) -> Option<usize> {
            if idx < self.body.storage_slots.len() {
                Some(
                    Self::storage_slots_offset_static()
                        .checked_add(idx.checked_mul(StorageSlot::SLOT_SIZE)?)?,
                )
            } else {
                None
            }
        }
    }

    impl ChargeableBody<CreateBody> for Create {
        fn body(&self) -> &CreateBody {
            &self.body
        }

        fn body_mut(&mut self) -> &mut CreateBody {
            &mut self.body
        }

        fn body_offset_end(&self) -> usize {
            Self::storage_slots_offset_static().saturating_add(
                self.body
                    .storage_slots
                    .len()
                    .saturating_mul(StorageSlot::SLOT_SIZE),
            )
        }
    }
}

impl TryFrom<&Create> for Contract {
    type Error = ValidityError;

    fn try_from(tx: &Create) -> Result<Self, Self::Error> {
        let Create {
            body:
                CreateBody {
                    bytecode_witness_index,
                    ..
                },
            witnesses,
            ..
        } = tx;

        witnesses
            .get(*bytecode_witness_index as usize)
            .map(|c| c.as_ref().into())
            .ok_or(ValidityError::TransactionCreateBytecodeWitnessIndex)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        builder::Finalizable,
        transaction::validity::FormatValidityChecks,
    };
    use fuel_types::Bytes32;

    #[test]
    fn storage_slots_sorting() {
        // Test that storage slots must be sorted correctly
        let mut slot_data = [0u8; 64];

        let storage_slots = (0..10u64)
            .map(|i| {
                slot_data[..8].copy_from_slice(&i.to_be_bytes());
                StorageSlot::from(&slot_data.into())
            })
            .collect::<Vec<StorageSlot>>();

        let mut tx = crate::TransactionBuilder::create(
            vec![].into(),
            Salt::zeroed(),
            storage_slots,
        )
        .add_fee_input()
        .finalize();
        tx.body.storage_slots.reverse();

        let err = tx
            .check(0.into(), &ConsensusParameters::standard())
            .expect_err("Expected erroneous transaction");

        assert_eq!(ValidityError::TransactionCreateStorageSlotOrder, err);
    }

    #[test]
    fn storage_slots_no_duplicates() {
        let storage_slots = vec![
            StorageSlot::new(Bytes32::zeroed(), Bytes32::zeroed()),
            StorageSlot::new(Bytes32::zeroed(), Bytes32::zeroed()),
        ];

        let err = crate::TransactionBuilder::create(
            vec![].into(),
            Salt::zeroed(),
            storage_slots,
        )
        .add_fee_input()
        .finalize()
        .check(0.into(), &ConsensusParameters::standard())
        .expect_err("Expected erroneous transaction");

        assert_eq!(ValidityError::TransactionCreateStorageSlotOrder, err);
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/input.rs

Source
use crate::{
    TxPointer,
    UtxoId,
};
use alloc::{
    string::ToString,
    vec::Vec,
};
use coin::*;
use consts::*;
use contract::*;
use core::fmt::{
    self,
    Formatter,
};
use fuel_crypto::{
    Hasher,
    PublicKey,
};
use fuel_types::{
    bytes,
    canonical,
    canonical::{
        Deserialize,
        Error,
        Output,
        Serialize,
    },
    fmt_truncated_hex,
    Address,
    AssetId,
    Bytes32,
    ContractId,
    MessageId,
    Nonce,
    Word,
};
use message::*;

pub mod coin;
mod consts;
pub mod contract;
pub mod message;
mod predicate;
mod repr;

pub use predicate::PredicateCode;
pub use repr::InputRepr;

#[cfg(all(test, feature = "std"))]
mod ser_de_tests;

pub trait AsField<Type>: AsFieldFmt {
    fn as_field(&self) -> Option<&Type>;

    fn as_mut_field(&mut self) -> Option<&mut Type>;
}

pub trait AsFieldFmt {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result;
}

pub fn fmt_as_field<T>(field: &T, f: &mut Formatter) -> fmt::Result
where
    T: AsFieldFmt,
{
    field.fmt_as_field(f)
}

/// The empty field used by sub-types of the specification.
#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[cfg_attr(feature = "da-compression", compress(discard(Type)))]
pub struct Empty<Type>(
    #[cfg_attr(feature = "da-compression", compress(skip))]
    ::core::marker::PhantomData<Type>,
);

impl<Type> Empty<Type> {
    /// Creates `Self`.
    pub const fn new() -> Self {
        Self(::core::marker::PhantomData {})
    }
}

impl<Type> Default for Empty<Type> {
    fn default() -> Self {
        Self::new()
    }
}

impl<Type: Serialize + Default> Serialize for Empty<Type> {
    #[inline(always)]
    fn size_static(&self) -> usize {
        Type::default().size_static()
    }

    #[inline(always)]
    fn size_dynamic(&self) -> usize {
        0
    }

    #[inline(always)]
    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        Type::default().encode_static(buffer)
    }
}

impl<Type: Deserialize> Deserialize for Empty<Type> {
    #[inline(always)]
    fn decode_static<I: canonical::Input + ?Sized>(
        buffer: &mut I,
    ) -> Result<Self, Error> {
        Type::decode_static(buffer)?;
        Ok(Default::default())
    }
}

impl<Type> AsFieldFmt for Empty<Type> {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result {
        f.write_str("Empty")
    }
}

impl<Type> AsField<Type> for Empty<Type> {
    #[inline(always)]
    fn as_field(&self) -> Option<&Type> {
        None
    }

    fn as_mut_field(&mut self) -> Option<&mut Type> {
        None
    }
}

impl AsField<u8> for u8 {
    #[inline(always)]
    fn as_field(&self) -> Option<&u8> {
        Some(self)
    }

    fn as_mut_field(&mut self) -> Option<&mut u8> {
        Some(self)
    }
}

impl AsFieldFmt for u8 {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result {
        f.write_str(self.to_string().as_str())
    }
}

impl AsField<u16> for u16 {
    #[inline(always)]
    fn as_field(&self) -> Option<&u16> {
        Some(self)
    }

    fn as_mut_field(&mut self) -> Option<&mut u16> {
        Some(self)
    }
}

impl AsFieldFmt for u16 {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result {
        f.write_str(self.to_string().as_str())
    }
}

impl AsField<u64> for u64 {
    #[inline(always)]
    fn as_field(&self) -> Option<&u64> {
        Some(self)
    }

    fn as_mut_field(&mut self) -> Option<&mut u64> {
        Some(self)
    }
}

impl AsFieldFmt for u64 {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result {
        f.write_str(self.to_string().as_str())
    }
}

impl AsField<Vec<u8>> for Vec<u8> {
    #[inline(always)]
    fn as_field(&self) -> Option<&Vec<u8>> {
        Some(self)
    }

    fn as_mut_field(&mut self) -> Option<&mut Vec<u8>> {
        Some(self)
    }
}

impl AsFieldFmt for Vec<u8> {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result {
        fmt_truncated_hex::<16>(self, f)
    }
}

impl AsField<PredicateCode> for PredicateCode {
    #[inline(always)]
    fn as_field(&self) -> Option<&PredicateCode> {
        Some(self)
    }

    fn as_mut_field(&mut self) -> Option<&mut PredicateCode> {
        Some(self)
    }
}

impl AsFieldFmt for PredicateCode {
    fn fmt_as_field(&self, f: &mut Formatter) -> fmt::Result {
        fmt_truncated_hex::<16>(self, f)
    }
}

#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Hash,
    strum_macros::EnumCount,
    serde::Serialize,
    serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
pub enum Input {
    CoinSigned(CoinSigned),
    CoinPredicate(CoinPredicate),
    Contract(Contract),
    MessageCoinSigned(MessageCoinSigned),
    MessageCoinPredicate(MessageCoinPredicate),
    MessageDataSigned(MessageDataSigned),
    MessageDataPredicate(MessageDataPredicate),
}

impl Default for Input {
    fn default() -> Self {
        Self::contract(
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
        )
    }
}

impl Input {
    pub const fn repr(&self) -> InputRepr {
        InputRepr::from_input(self)
    }

    pub fn owner(pk: &PublicKey) -> Address {
        let owner: [u8; Address::LEN] = pk.hash().into();

        owner.into()
    }

    pub const fn coin_predicate(
        utxo_id: UtxoId,
        owner: Address,
        amount: Word,
        asset_id: AssetId,
        tx_pointer: TxPointer,
        predicate_gas_used: Word,
        predicate: Vec<u8>,
        predicate_data: Vec<u8>,
    ) -> Self {
        Self::CoinPredicate(CoinPredicate {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index: Empty::new(),
            predicate_gas_used,
            predicate: PredicateCode { bytes: predicate },
            predicate_data,
        })
    }

    pub const fn coin_signed(
        utxo_id: UtxoId,
        owner: Address,
        amount: Word,
        asset_id: AssetId,
        tx_pointer: TxPointer,
        witness_index: u16,
    ) -> Self {
        Self::CoinSigned(CoinSigned {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
            predicate_gas_used: Empty::new(),
            predicate: Empty::new(),
            predicate_data: Empty::new(),
        })
    }

    pub const fn contract(
        utxo_id: UtxoId,
        balance_root: Bytes32,
        state_root: Bytes32,
        tx_pointer: TxPointer,
        contract_id: ContractId,
    ) -> Self {
        Self::Contract(Contract {
            utxo_id,
            balance_root,
            state_root,
            tx_pointer,
            contract_id,
        })
    }

    pub const fn message_coin_signed(
        sender: Address,
        recipient: Address,
        amount: Word,
        nonce: Nonce,
        witness_index: u16,
    ) -> Self {
        Self::MessageCoinSigned(MessageCoinSigned {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            predicate_gas_used: Empty::new(),
            data: Empty::new(),
            predicate: Empty::new(),
            predicate_data: Empty::new(),
        })
    }

    pub const fn message_coin_predicate(
        sender: Address,
        recipient: Address,
        amount: Word,
        nonce: Nonce,
        predicate_gas_used: Word,
        predicate: Vec<u8>,
        predicate_data: Vec<u8>,
    ) -> Self {
        Self::MessageCoinPredicate(MessageCoinPredicate {
            sender,
            recipient,
            amount,
            nonce,
            witness_index: Empty::new(),
            predicate_gas_used,
            data: Empty::new(),
            predicate: PredicateCode { bytes: predicate },
            predicate_data,
        })
    }

    pub const fn message_data_signed(
        sender: Address,
        recipient: Address,
        amount: Word,
        nonce: Nonce,
        witness_index: u16,
        data: Vec<u8>,
    ) -> Self {
        Self::MessageDataSigned(MessageDataSigned {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            data,
            predicate: Empty::new(),
            predicate_data: Empty::new(),
            predicate_gas_used: Empty::new(),
        })
    }

    pub const fn message_data_predicate(
        sender: Address,
        recipient: Address,
        amount: Word,
        nonce: Nonce,
        predicate_gas_used: Word,
        data: Vec<u8>,
        predicate: Vec<u8>,
        predicate_data: Vec<u8>,
    ) -> Self {
        Self::MessageDataPredicate(MessageDataPredicate {
            sender,
            recipient,
            amount,
            nonce,
            witness_index: Empty::new(),
            predicate_gas_used,
            data,
            predicate: PredicateCode { bytes: predicate },
            predicate_data,
        })
    }

    pub const fn utxo_id(&self) -> Option<&UtxoId> {
        match self {
            Self::CoinSigned(CoinSigned { utxo_id, .. })
            | Self::CoinPredicate(CoinPredicate { utxo_id, .. })
            | Self::Contract(Contract { utxo_id, .. }) => Some(utxo_id),
            Self::MessageCoinSigned(_) => None,
            Self::MessageCoinPredicate(_) => None,
            Self::MessageDataSigned(_) => None,
            Self::MessageDataPredicate(_) => None,
        }
    }

    pub const fn input_owner(&self) -> Option<&Address> {
        match self {
            Self::CoinSigned(CoinSigned { owner, .. })
            | Self::CoinPredicate(CoinPredicate { owner, .. }) => Some(owner),
            Self::MessageCoinSigned(MessageCoinSigned { recipient, .. })
            | Self::MessageCoinPredicate(MessageCoinPredicate { recipient, .. })
            | Self::MessageDataSigned(MessageDataSigned { recipient, .. })
            | Self::MessageDataPredicate(MessageDataPredicate { recipient, .. }) => {
                Some(recipient)
            }
            Self::Contract(_) => None,
        }
    }

    pub const fn asset_id<'a>(
        &'a self,
        base_asset_id: &'a AssetId,
    ) -> Option<&'a AssetId> {
        match self {
            Input::CoinSigned(CoinSigned { asset_id, .. })
            | Input::CoinPredicate(CoinPredicate { asset_id, .. }) => Some(asset_id),
            Input::MessageCoinSigned(_)
            | Input::MessageCoinPredicate(_)
            | Input::MessageDataSigned(_)
            | Input::MessageDataPredicate(_) => Some(base_asset_id),
            Input::Contract(_) => None,
        }
    }

    pub const fn contract_id(&self) -> Option<&ContractId> {
        match self {
            Self::Contract(Contract { contract_id, .. }) => Some(contract_id),
            _ => None,
        }
    }

    pub const fn amount(&self) -> Option<Word> {
        match self {
            Input::CoinSigned(CoinSigned { amount, .. })
            | Input::CoinPredicate(CoinPredicate { amount, .. })
            | Input::MessageCoinSigned(MessageCoinSigned { amount, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { amount, .. })
            | Input::MessageDataSigned(MessageDataSigned { amount, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { amount, .. }) => {
                Some(*amount)
            }
            Input::Contract(_) => None,
        }
    }

    pub const fn witness_index(&self) -> Option<u16> {
        match self {
            Input::CoinSigned(CoinSigned { witness_index, .. })
            | Input::MessageCoinSigned(MessageCoinSigned { witness_index, .. })
            | Input::MessageDataSigned(MessageDataSigned { witness_index, .. }) => {
                Some(*witness_index)
            }
            Input::CoinPredicate(_)
            | Input::Contract(_)
            | Input::MessageCoinPredicate(_)
            | Input::MessageDataPredicate(_) => None,
        }
    }

    pub fn predicate_offset(&self) -> Option<usize> {
        match self {
            Input::CoinPredicate(_) => InputRepr::Coin.coin_predicate_offset(),
            Input::MessageCoinPredicate(_) => InputRepr::Message.data_offset(),
            Input::MessageDataPredicate(MessageDataPredicate { data, .. }) => {
                InputRepr::Message.data_offset().map(|o| {
                    o.saturating_add(bytes::padded_len(data).unwrap_or(usize::MAX))
                })
            }
            Input::CoinSigned(_)
            | Input::Contract(_)
            | Input::MessageCoinSigned(_)
            | Input::MessageDataSigned(_) => None,
        }
    }

    pub fn predicate_data_offset(&self) -> Option<usize> {
        match self {
            Input::CoinPredicate(CoinPredicate { predicate, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { predicate, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { predicate, .. }) => {
                self.predicate_offset().map(|o| {
                    o.saturating_add(bytes::padded_len(predicate).unwrap_or(usize::MAX))
                })
            }
            Input::CoinSigned(_)
            | Input::Contract(_)
            | Input::MessageCoinSigned(_)
            | Input::MessageDataSigned(_) => None,
        }
    }

    pub fn predicate_len(&self) -> Option<usize> {
        match self {
            Input::CoinPredicate(CoinPredicate { predicate, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { predicate, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { predicate, .. }) => {
                Some(predicate.len())
            }
            Input::CoinSigned(_)
            | Input::MessageCoinSigned(_)
            | Input::MessageDataSigned(_) => Some(0),
            Input::Contract(_) => None,
        }
    }

    pub fn predicate_data_len(&self) -> Option<usize> {
        match self {
            Input::CoinPredicate(CoinPredicate { predicate_data, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate {
                predicate_data, ..
            })
            | Input::MessageDataPredicate(MessageDataPredicate {
                predicate_data, ..
            }) => Some(predicate_data.len()),
            Input::CoinSigned(_)
            | Input::MessageCoinSigned(_)
            | Input::MessageDataSigned(_) => Some(0),
            Input::Contract(_) => None,
        }
    }

    pub fn predicate_gas_used(&self) -> Option<Word> {
        match self {
            Input::CoinPredicate(CoinPredicate {
                predicate_gas_used, ..
            })
            | Input::MessageCoinPredicate(MessageCoinPredicate {
                predicate_gas_used,
                ..
            })
            | Input::MessageDataPredicate(MessageDataPredicate {
                predicate_gas_used,
                ..
            }) => Some(*predicate_gas_used),
            Input::CoinSigned(_)
            | Input::MessageCoinSigned(_)
            | Input::MessageDataSigned(_)
            | Input::Contract(_) => None,
        }
    }

    pub fn set_predicate_gas_used(&mut self, gas: Word) {
        match self {
            Input::CoinPredicate(CoinPredicate {
                predicate_gas_used, ..
            })
            | Input::MessageCoinPredicate(MessageCoinPredicate {
                predicate_gas_used,
                ..
            })
            | Input::MessageDataPredicate(MessageDataPredicate {
                predicate_gas_used,
                ..
            }) => *predicate_gas_used = gas,
            Input::CoinSigned(_)
            | Input::MessageCoinSigned(_)
            | Input::MessageDataSigned(_)
            | Input::Contract(_) => {}
        }
    }

    pub fn message_id(&self) -> Option<MessageId> {
        match self {
            Self::MessageCoinSigned(message) => Some(message.message_id()),
            Self::MessageCoinPredicate(message) => Some(message.message_id()),
            Self::MessageDataPredicate(message) => Some(message.message_id()),
            Self::MessageDataSigned(message) => Some(message.message_id()),
            _ => None,
        }
    }

    pub const fn tx_pointer(&self) -> Option<&TxPointer> {
        match self {
            Input::CoinSigned(CoinSigned { tx_pointer, .. })
            | Input::CoinPredicate(CoinPredicate { tx_pointer, .. })
            | Input::Contract(Contract { tx_pointer, .. }) => Some(tx_pointer),
            _ => None,
        }
    }

    pub fn input_data(&self) -> Option<&[u8]> {
        match self {
            Input::MessageDataSigned(MessageDataSigned { data, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { data, .. }) => {
                Some(data)
            }
            _ => None,
        }
    }

    pub fn input_data_len(&self) -> Option<usize> {
        match self {
            Input::MessageDataSigned(MessageDataSigned { data, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { data, .. }) => {
                Some(data.len())
            }
            Input::MessageCoinSigned(_) | Input::MessageCoinPredicate(_) => Some(0),
            _ => None,
        }
    }

    pub fn input_predicate(&self) -> Option<&[u8]> {
        match self {
            Input::CoinPredicate(CoinPredicate { predicate, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { predicate, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { predicate, .. }) => {
                Some(predicate)
            }

            _ => None,
        }
    }

    pub fn input_predicate_data(&self) -> Option<&[u8]> {
        match self {
            Input::CoinPredicate(CoinPredicate { predicate_data, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate {
                predicate_data, ..
            })
            | Input::MessageDataPredicate(MessageDataPredicate {
                predicate_data, ..
            }) => Some(predicate_data),

            _ => None,
        }
    }

    /// Return a tuple containing the predicate, its data and used gas if the input is of
    /// type `CoinPredicate` or `MessageCoinPredicate` or `MessageDataPredicate`
    pub fn predicate(&self) -> Option<(&[u8], &[u8], &Word)> {
        match self {
            Input::CoinPredicate(CoinPredicate {
                predicate,
                predicate_data,
                predicate_gas_used,
                ..
            })
            | Input::MessageCoinPredicate(MessageCoinPredicate {
                predicate,
                predicate_data,
                predicate_gas_used,
                ..
            })
            | Input::MessageDataPredicate(MessageDataPredicate {
                predicate,
                predicate_data,
                predicate_gas_used,
                ..
            }) => Some((
                predicate.as_slice(),
                predicate_data.as_slice(),
                predicate_gas_used,
            )),

            _ => None,
        }
    }

    pub const fn is_coin(&self) -> bool {
        self.is_coin_signed() | self.is_coin_predicate()
    }

    pub const fn is_coin_signed(&self) -> bool {
        matches!(self, Input::CoinSigned(_))
    }

    pub const fn is_coin_predicate(&self) -> bool {
        matches!(self, Input::CoinPredicate(_))
    }

    pub const fn is_message(&self) -> bool {
        self.is_message_coin_signed()
            | self.is_message_coin_predicate()
            | self.is_message_data_signed()
            | self.is_message_data_predicate()
    }

    pub const fn is_message_coin_signed(&self) -> bool {
        matches!(self, Input::MessageCoinSigned(_))
    }

    pub const fn is_message_coin_predicate(&self) -> bool {
        matches!(self, Input::MessageCoinPredicate(_))
    }

    pub const fn is_message_data_signed(&self) -> bool {
        matches!(self, Input::MessageDataSigned(_))
    }

    pub const fn is_message_data_predicate(&self) -> bool {
        matches!(self, Input::MessageDataPredicate(_))
    }

    pub const fn is_contract(&self) -> bool {
        matches!(self, Input::Contract(_))
    }

    pub const fn coin_predicate_offset() -> usize {
        INPUT_COIN_FIXED_SIZE
    }

    pub const fn message_data_offset() -> usize {
        INPUT_MESSAGE_FIXED_SIZE
    }

    pub const fn balance_root(&self) -> Option<&Bytes32> {
        match self {
            Input::Contract(Contract { balance_root, .. }) => Some(balance_root),
            _ => None,
        }
    }

    pub const fn state_root(&self) -> Option<&Bytes32> {
        match self {
            Input::Contract(Contract { state_root, .. }) => Some(state_root),
            _ => None,
        }
    }

    pub const fn sender(&self) -> Option<&Address> {
        match self {
            Input::MessageCoinSigned(MessageCoinSigned { sender, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { sender, .. })
            | Input::MessageDataSigned(MessageDataSigned { sender, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { sender, .. }) => {
                Some(sender)
            }
            _ => None,
        }
    }

    pub const fn recipient(&self) -> Option<&Address> {
        match self {
            Input::MessageCoinSigned(MessageCoinSigned { recipient, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { recipient, .. })
            | Input::MessageDataSigned(MessageDataSigned { recipient, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { recipient, .. }) => {
                Some(recipient)
            }
            _ => None,
        }
    }

    pub const fn nonce(&self) -> Option<&Nonce> {
        match self {
            Input::MessageCoinSigned(MessageCoinSigned { nonce, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { nonce, .. })
            | Input::MessageDataSigned(MessageDataSigned { nonce, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { nonce, .. }) => {
                Some(nonce)
            }
            _ => None,
        }
    }

    /// Empties fields that should be zero during the signing.
    pub fn prepare_sign(&mut self) {
        match self {
            Input::CoinSigned(coin) => coin.prepare_sign(),
            Input::CoinPredicate(coin) => coin.prepare_sign(),
            Input::Contract(contract) => contract.prepare_sign(),
            Input::MessageCoinSigned(message) => message.prepare_sign(),
            Input::MessageCoinPredicate(message) => message.prepare_sign(),
            Input::MessageDataSigned(message) => message.prepare_sign(),
            Input::MessageDataPredicate(message) => message.prepare_sign(),
        }
    }

    pub fn compute_message_id(
        sender: &Address,
        recipient: &Address,
        nonce: &Nonce,
        amount: Word,
        data: &[u8],
    ) -> MessageId {
        compute_message_id(sender, recipient, nonce, amount, data)
    }

    pub fn predicate_owner<P>(predicate: P) -> Address
    where
        P: AsRef<[u8]>,
    {
        use crate::Contract;

        let root = Contract::root_from_code(predicate);

        let mut hasher = Hasher::default();

        hasher.input(ContractId::SEED);
        hasher.input(root);

        (*hasher.digest()).into()
    }

    pub fn is_predicate_owner_valid<P>(owner: &Address, predicate: P) -> bool
    where
        P: AsRef<[u8]>,
    {
        owner == &Self::predicate_owner(predicate)
    }
}

impl Serialize for Input {
    fn size_static(&self) -> usize {
        (match self {
            Input::CoinSigned(coin) => coin.size_static(),
            Input::CoinPredicate(coin) => coin.size_static(),
            Input::Contract(contract) => contract.size_static(),
            Input::MessageCoinSigned(message) => message.size_static(),
            Input::MessageCoinPredicate(message) => message.size_static(),
            Input::MessageDataSigned(message) => message.size_static(),
            Input::MessageDataPredicate(message) => message.size_static(),
        })
        .saturating_add(8) // Discriminant
    }

    fn size_dynamic(&self) -> usize {
        match self {
            Input::CoinSigned(coin) => coin.size_dynamic(),
            Input::CoinPredicate(coin) => coin.size_dynamic(),
            Input::Contract(contract) => contract.size_dynamic(),
            Input::MessageCoinSigned(message) => message.size_dynamic(),
            Input::MessageCoinPredicate(message) => message.size_dynamic(),
            Input::MessageDataSigned(message) => message.size_dynamic(),
            Input::MessageDataPredicate(message) => message.size_dynamic(),
        }
    }

    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        let discr = InputRepr::from(self);
        discr.encode_static(buffer)?;
        match self {
            Input::CoinSigned(coin) => coin.encode_static(buffer),
            Input::CoinPredicate(coin) => coin.encode_static(buffer),
            Input::Contract(contract) => contract.encode_static(buffer),
            Input::MessageCoinSigned(message) => message.encode_static(buffer),
            Input::MessageCoinPredicate(message) => message.encode_static(buffer),
            Input::MessageDataSigned(message) => message.encode_static(buffer),
            Input::MessageDataPredicate(message) => message.encode_static(buffer),
        }
    }

    fn encode_dynamic<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        let discr = InputRepr::from(self);
        discr.encode_dynamic(buffer)?;
        match self {
            Input::CoinSigned(coin) => coin.encode_dynamic(buffer),
            Input::CoinPredicate(coin) => coin.encode_dynamic(buffer),
            Input::Contract(contract) => contract.encode_dynamic(buffer),
            Input::MessageCoinSigned(message) => message.encode_dynamic(buffer),
            Input::MessageCoinPredicate(message) => message.encode_dynamic(buffer),
            Input::MessageDataSigned(message) => message.encode_dynamic(buffer),
            Input::MessageDataPredicate(message) => message.encode_dynamic(buffer),
        }
    }
}

impl Deserialize for Input {
    fn decode_static<I: canonical::Input + ?Sized>(
        buffer: &mut I,
    ) -> Result<Self, Error> {
        Ok(
            match <InputRepr as Deserialize>::decode(buffer)
                .map_err(|_| Error::UnknownDiscriminant)?
            {
                InputRepr::Coin => {
                    let coin = CoinFull::decode_static(buffer)?;
                    if coin.predicate.capacity() == 0 {
                        Input::CoinSigned(coin.into_signed())
                    } else {
                        Input::CoinPredicate(coin.into_predicate())
                    }
                }
                InputRepr::Contract => {
                    let contract = Contract::decode_static(buffer)?;
                    Input::Contract(contract)
                }
                InputRepr::Message => {
                    let message = FullMessage::decode_static(buffer)?;
                    match (
                        message.data.capacity() == 0,
                        message.predicate.capacity() == 0,
                    ) {
                        (true, true) => {
                            Input::MessageCoinSigned(message.into_coin_signed())
                        }
                        (true, false) => {
                            Input::MessageCoinPredicate(message.into_coin_predicate())
                        }
                        (false, true) => {
                            Input::MessageDataSigned(message.into_message_data_signed())
                        }
                        (false, false) => Input::MessageDataPredicate(
                            message.into_message_data_predicate(),
                        ),
                    }
                }
            },
        )
    }

    fn decode_dynamic<I: canonical::Input + ?Sized>(
        &mut self,
        buffer: &mut I,
    ) -> Result<(), Error> {
        match self {
            Input::CoinSigned(coin) => coin.decode_dynamic(buffer),
            Input::CoinPredicate(coin) => coin.decode_dynamic(buffer),
            Input::Contract(contract) => contract.decode_dynamic(buffer),
            Input::MessageCoinSigned(message) => message.decode_dynamic(buffer),
            Input::MessageCoinPredicate(message) => message.decode_dynamic(buffer),
            Input::MessageDataSigned(message) => message.decode_dynamic(buffer),
            Input::MessageDataPredicate(message) => message.decode_dynamic(buffer),
        }
    }
}

#[cfg(all(test, feature = "std"))]
mod snapshot_tests;

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use super::*;

    use crate::{
        TxPointer,
        UtxoId,
    };
    use fuel_types::{
        Address,
        AssetId,
        Bytes32,
        Word,
    };

    use alloc::{
        boxed::Box,
        format,
        string::String,
        vec::Vec,
    };

    #[derive(Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize)]
    #[wasm_bindgen]
    pub struct Input(#[wasm_bindgen(skip)] pub Box<crate::Input>);

    #[wasm_bindgen]
    impl Input {
        #[wasm_bindgen(js_name = toJSON)]
        pub fn to_json(&self) -> String {
            serde_json::to_string(&self.0).expect("unable to json format")
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:?}", self.0)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            self.0.to_bytes()
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<Input, js_sys::Error> {
            use fuel_types::canonical::Deserialize;
            crate::Input::from_bytes(value)
                .map(|v| Input(Box::new(v)))
                .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
        }

        #[wasm_bindgen]
        pub fn coin_predicate(
            utxo_id: UtxoId,
            owner: Address,
            amount: Word,
            asset_id: AssetId,
            tx_pointer: TxPointer,
            predicate_gas_used: Word,
            predicate: Vec<u8>,
            predicate_data: Vec<u8>,
        ) -> Input {
            Input(Box::new(crate::Input::CoinPredicate(CoinPredicate {
                utxo_id,
                owner,
                amount,
                asset_id,
                tx_pointer,
                witness_index: Empty::new(),
                predicate_gas_used,
                predicate: PredicateCode { bytes: predicate },
                predicate_data,
            })))
        }

        #[wasm_bindgen]
        pub fn coin_signed(
            utxo_id: UtxoId,
            owner: Address,
            amount: Word,
            asset_id: AssetId,
            tx_pointer: TxPointer,
            witness_index: u16,
        ) -> Input {
            Input(Box::new(crate::Input::CoinSigned(CoinSigned {
                utxo_id,
                owner,
                amount,
                asset_id,
                tx_pointer,
                witness_index,
                predicate_gas_used: Empty::new(),
                predicate: Empty::new(),
                predicate_data: Empty::new(),
            })))
        }

        #[wasm_bindgen]
        pub fn contract(
            utxo_id: UtxoId,
            balance_root: Bytes32,
            state_root: Bytes32,
            tx_pointer: TxPointer,
            contract_id: ContractId,
        ) -> Input {
            Input(Box::new(crate::Input::Contract(Contract {
                utxo_id,
                balance_root,
                state_root,
                tx_pointer,
                contract_id,
            })))
        }

        #[wasm_bindgen]
        pub fn message_coin_signed(
            sender: Address,
            recipient: Address,
            amount: Word,
            nonce: Nonce,
            witness_index: u16,
        ) -> Input {
            Input(Box::new(crate::Input::MessageCoinSigned(
                MessageCoinSigned {
                    sender,
                    recipient,
                    amount,
                    nonce,
                    witness_index,
                    predicate_gas_used: Empty::new(),
                    data: Empty::new(),
                    predicate: Empty::new(),
                    predicate_data: Empty::new(),
                },
            )))
        }

        #[wasm_bindgen]
        pub fn message_coin_predicate(
            sender: Address,
            recipient: Address,
            amount: Word,
            nonce: Nonce,
            predicate_gas_used: Word,
            predicate: Vec<u8>,
            predicate_data: Vec<u8>,
        ) -> Input {
            Input(Box::new(crate::Input::MessageCoinPredicate(
                MessageCoinPredicate {
                    sender,
                    recipient,
                    amount,
                    nonce,
                    witness_index: Empty::new(),
                    predicate_gas_used,
                    data: Empty::new(),
                    predicate: PredicateCode { bytes: predicate },
                    predicate_data,
                },
            )))
        }

        #[wasm_bindgen]
        pub fn message_data_signed(
            sender: Address,
            recipient: Address,
            amount: Word,
            nonce: Nonce,
            witness_index: u16,
            data: Vec<u8>,
        ) -> Input {
            Input(Box::new(crate::Input::MessageDataSigned(
                MessageDataSigned {
                    sender,
                    recipient,
                    amount,
                    nonce,
                    witness_index,
                    data,
                    predicate: Empty::new(),
                    predicate_data: Empty::new(),
                    predicate_gas_used: Empty::new(),
                },
            )))
        }

        #[wasm_bindgen]
        pub fn message_data_predicate(
            sender: Address,
            recipient: Address,
            amount: Word,
            nonce: Nonce,
            predicate_gas_used: Word,
            data: Vec<u8>,
            predicate: Vec<u8>,
            predicate_data: Vec<u8>,
        ) -> Input {
            Input(Box::new(crate::Input::MessageDataPredicate(
                MessageDataPredicate {
                    sender,
                    recipient,
                    amount,
                    nonce,
                    witness_index: Empty::new(),
                    predicate_gas_used,
                    data,
                    predicate: PredicateCode { bytes: predicate },
                    predicate_data,
                },
            )))
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/storage.rs

Source
use fuel_types::{
    canonical::{
        Deserialize,
        Serialize,
    },
    Bytes32,
    Bytes64,
};
#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

use core::cmp::Ordering;

#[derive(
    Debug, Default, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[derive(Deserialize, Serialize)]
pub struct StorageSlot {
    key: Bytes32,
    value: Bytes32,
}

impl StorageSlot {
    pub const SLOT_SIZE: usize = Bytes32::LEN + Bytes32::LEN;

    pub const fn new(key: Bytes32, value: Bytes32) -> Self {
        StorageSlot { key, value }
    }

    pub const fn key(&self) -> &Bytes32 {
        &self.key
    }

    pub const fn value(&self) -> &Bytes32 {
        &self.value
    }
}

impl From<&StorageSlot> for Bytes64 {
    fn from(s: &StorageSlot) -> Self {
        let mut buf = [0u8; StorageSlot::SLOT_SIZE];

        buf[..Bytes32::LEN].copy_from_slice(s.key.as_ref());
        buf[Bytes32::LEN..].copy_from_slice(s.value.as_ref());

        buf.into()
    }
}

impl From<&Bytes64> for StorageSlot {
    fn from(b: &Bytes64) -> Self {
        let key = <Bytes32 as Deserialize>::from_bytes(&b[..Bytes32::LEN])
            .expect("Infallible deserialization");
        let value = <Bytes32 as Deserialize>::from_bytes(&b[Bytes32::LEN..])
            .expect("Infallible deserialization");
        Self::new(key, value)
    }
}

#[cfg(feature = "random")]
impl Distribution<StorageSlot> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> StorageSlot {
        StorageSlot {
            key: rng.gen(),
            value: rng.gen(),
        }
    }
}

impl PartialOrd for StorageSlot {
    fn partial_cmp(&self, other: &StorageSlot) -> Option<Ordering> {
        Some(self.key.cmp(&other.key))
    }
}

impl Ord for StorageSlot {
    fn cmp(&self, other: &Self) -> Ordering {
        self.key.cmp(&other.key)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rand::SeedableRng;
    use std::{
        fs::File,
        path::PathBuf,
    };

    const FILE_PATH: &str = "storage-slots.json";

    #[test]
    fn test_storage_slot_serialization() {
        let rng = &mut rand::rngs::StdRng::seed_from_u64(8586);
        let key: Bytes32 = rng.gen();
        let value: Bytes32 = rng.gen();

        let slot = StorageSlot::new(key, value);
        let slots = vec![slot.clone()];

        // `from_str` works
        let slot_str = serde_json::to_string(&slots).expect("to string");
        let storage_slots: Vec<StorageSlot> =
            serde_json::from_str(&slot_str).expect("read from string");
        assert_eq!(storage_slots.len(), 1);

        let path = std::env::temp_dir().join(PathBuf::from(FILE_PATH));

        // writes to file works
        let storage_slots_file = File::create(&path).expect("create file");
        serde_json::to_writer(&storage_slots_file, &slots).expect("write file");

        // `from_reader` works
        let storage_slots_file = File::open(&path).expect("open file");
        let storage_slots: Vec<StorageSlot> =
            serde_json::from_reader(storage_slots_file).expect("read file");
        assert_eq!(storage_slots.len(), 1);
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/mint.rs

Source
use crate::{
    input,
    output,
    transaction::{
        field::TxPointer as TxPointerField,
        validity::{
            check_size,
            FormatValidityChecks,
        },
    },
    ConsensusParameters,
    TransactionRepr,
    TxPointer,
    ValidityError,
};
use derivative::Derivative;
use fuel_asm::Word;
use fuel_types::{
    bytes::WORD_SIZE,
    AssetId,
    BlockHeight,
    Bytes32,
};

use fuel_types::ChainId;

use fuel_types::canonical::Serialize;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub(crate) struct MintMetadata {
    pub id: Bytes32,
}

impl MintMetadata {
    fn compute<Tx>(tx: &Tx, chain_id: &ChainId) -> Self
    where
        Tx: crate::UniqueIdentifier,
    {
        let id = tx.id(chain_id);

        Self { id }
    }
}

/// The definition of the `Mint` transaction from the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md#transactionmint>
///
/// This transaction can be created by the block producer and included in the block only
/// by it.
#[derive(Default, Debug, Clone, Derivative, serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "da-compression", derive(fuel_compression::Compress))]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[canonical(prefix = TransactionRepr::Mint)]
#[derivative(Eq, PartialEq, Hash)]
pub struct Mint {
    /// The location of the transaction in the block.
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub(crate) tx_pointer: TxPointer,
    /// The `Input::Contract` that assets are minted to.
    pub(crate) input_contract: input::contract::Contract,
    /// The `Output::Contract` that assets are being minted to.
    pub(crate) output_contract: output::contract::Contract,
    /// The amount of funds minted.
    pub(crate) mint_amount: Word,
    /// The asset IDs corresponding to the minted amount.
    pub(crate) mint_asset_id: AssetId,
    /// Gas Price used for current block
    pub(crate) gas_price: Word,
    #[serde(skip)]
    #[derivative(PartialEq = "ignore", Hash = "ignore")]
    #[canonical(skip)]
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub(crate) metadata: Option<MintMetadata>,
}

impl crate::UniqueIdentifier for Mint {
    fn id(&self, chain_id: &ChainId) -> Bytes32 {
        if let Some(id) = self.cached_id() {
            return id;
        }

        let mut clone = self.clone();
        clone.input_contract.prepare_sign();
        clone.output_contract.prepare_sign();

        crate::transaction::compute_transaction_id(chain_id, &mut clone)
    }

    fn cached_id(&self) -> Option<Bytes32> {
        self.metadata.as_ref().map(|m| m.id)
    }
}

impl FormatValidityChecks for Mint {
    fn check_signatures(&self, _: &ChainId) -> Result<(), ValidityError> {
        Ok(())
    }

    fn check_without_signatures(
        &self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        check_size(self, consensus_params.tx_params())?;

        if self.tx_pointer().block_height() != block_height {
            return Err(ValidityError::TransactionMintIncorrectBlockHeight);
        }

        if self.output_contract.input_index != 0 {
            return Err(ValidityError::TransactionMintIncorrectOutputIndex);
        }

        // It is temporary check until https://github.com/FuelLabs/fuel-core/issues/1205
        if &self.mint_asset_id != consensus_params.base_asset_id() {
            return Err(ValidityError::TransactionMintNonBaseAsset);
        }

        Ok(())
    }
}

impl crate::Cacheable for Mint {
    fn is_computed(&self) -> bool {
        self.metadata.is_some()
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        self.metadata = None;
        self.metadata = Some(MintMetadata::compute(self, chain_id));
        Ok(())
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl Mint {
    // This is a function to clear malleable fields just like it
    // does on other transactions types. Mint never needs this,
    // but we use it for some tests.
    pub fn prepare_sign(&mut self) {
        self.input_contract.prepare_sign();
        self.output_contract.prepare_sign();
    }
}

mod field {
    use super::*;
    use crate::field::{
        InputContract,
        MintAmount,
        MintAssetId,
        MintGasPrice,
        OutputContract,
    };

    impl TxPointerField for Mint {
        #[inline(always)]
        fn tx_pointer(&self) -> &TxPointer {
            &self.tx_pointer
        }

        #[inline(always)]
        fn tx_pointer_mut(&mut self) -> &mut TxPointer {
            &mut self.tx_pointer
        }

        #[inline(always)]
        fn tx_pointer_static() -> usize {
            WORD_SIZE // `Transaction` enum discriminant
        }
    }

    impl InputContract for Mint {
        #[inline(always)]
        fn input_contract(&self) -> &input::contract::Contract {
            &self.input_contract
        }

        #[inline(always)]
        fn input_contract_mut(&mut self) -> &mut input::contract::Contract {
            &mut self.input_contract
        }

        #[inline(always)]
        fn input_contract_offset(&self) -> usize {
            Self::tx_pointer_static().saturating_add(TxPointer::LEN)
        }
    }

    impl OutputContract for Mint {
        #[inline(always)]
        fn output_contract(&self) -> &output::contract::Contract {
            &self.output_contract
        }

        #[inline(always)]
        fn output_contract_mut(&mut self) -> &mut output::contract::Contract {
            &mut self.output_contract
        }

        #[inline(always)]
        fn output_contract_offset(&self) -> usize {
            self.input_contract_offset()
                .saturating_add(self.input_contract.size())
        }
    }

    impl MintAmount for Mint {
        #[inline(always)]
        fn mint_amount(&self) -> &fuel_types::Word {
            &self.mint_amount
        }

        #[inline(always)]
        fn mint_amount_mut(&mut self) -> &mut fuel_types::Word {
            &mut self.mint_amount
        }

        #[inline(always)]
        fn mint_amount_offset(&self) -> usize {
            self.output_contract_offset()
                .saturating_add(self.output_contract.size())
        }
    }

    impl MintAssetId for Mint {
        #[inline(always)]
        fn mint_asset_id(&self) -> &AssetId {
            &self.mint_asset_id
        }

        #[inline(always)]
        fn mint_asset_id_mut(&mut self) -> &mut AssetId {
            &mut self.mint_asset_id
        }

        #[inline(always)]
        fn mint_asset_id_offset(&self) -> usize {
            self.mint_amount_offset().saturating_add(WORD_SIZE)
        }
    }

    impl MintGasPrice for Mint {
        #[inline(always)]
        fn gas_price(&self) -> &Word {
            &self.gas_price
        }

        #[inline(always)]
        fn gas_price_mut(&mut self) -> &mut Word {
            &mut self.gas_price
        }

        #[inline(always)]
        fn gas_price_offset(&self) -> usize {
            self.mint_asset_id_offset().saturating_add(AssetId::LEN)
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/input/coin.rs

Source
use core::default::Default;

use crate::{
    input::{
        fmt_as_field,
        Empty,
    },
    transaction::types::input::AsField,
    TxPointer,
    UtxoId,
};
use alloc::vec::Vec;
use derivative::Derivative;
#[cfg(feature = "da-compression")]
use fuel_compression::Compressible;
use fuel_types::{
    Address,
    AssetId,
    Word,
};

use super::PredicateCode;

pub type CoinFull = Coin<Full>;
pub type CoinSigned = Coin<Signed>;
pub type CoinPredicate = Coin<Predicate>;

mod private {
    pub trait Seal {}

    impl Seal for super::Full {}
    impl Seal for super::Signed {}
    impl Seal for super::Predicate {}
}

/// Specifies the coin based on the usage context. See [`Coin`].
#[cfg(feature = "da-compression")]
pub trait CoinSpecification: private::Seal {
    type Witness: AsField<u16>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
    type Predicate: AsField<PredicateCode>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
    type PredicateData: AsField<Vec<u8>>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
    type PredicateGasUsed: AsField<Word>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
}
#[cfg(not(feature = "da-compression"))]
pub trait CoinSpecification: private::Seal {
    type Witness: AsField<u16>;
    type Predicate: AsField<PredicateCode>;
    type PredicateData: AsField<Vec<u8>>;
    type PredicateGasUsed: AsField<Word>;
}

#[derive(
    Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
pub struct Signed;

impl CoinSpecification for Signed {
    type Predicate = Empty<PredicateCode>;
    type PredicateData = Empty<Vec<u8>>;
    type PredicateGasUsed = Empty<Word>;
    type Witness = u16;
}

#[derive(
    Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
pub struct Predicate;

impl CoinSpecification for Predicate {
    type Predicate = PredicateCode;
    type PredicateData = Vec<u8>;
    type PredicateGasUsed = Word;
    type Witness = Empty<u16>;
}

#[derive(
    Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct Full;

impl CoinSpecification for Full {
    type Predicate = PredicateCode;
    type PredicateData = Vec<u8>;
    type PredicateGasUsed = Word;
    type Witness = u16;
}

/// It is a full representation of the coin from the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputcoin>.
///
/// The specification defines the layout of the [`Coin`] in the serialized form for the
/// `fuel-vm`. But on the business logic level, we don't use all fields at the same time.
/// It is why in the [`super::Input`] the coin is represented by several forms based on
/// the usage context. Leaving some fields empty reduces the memory consumption by the
/// structure and erases the empty useless fields.
///
/// The [`CoinSpecification`] trait specifies the sub-coin for the corresponding usage
/// context. It allows us to write the common logic of all sub-coins without the overhead
/// and duplication.
///
/// Sub-coin:
/// - [`Signed`] - means that the coin should be signed by the `owner`, and the
///   signature(witness) should be stored under the `witness_index` index in the
///   `witnesses` vector of the [`crate::Transaction`].
/// - [`Predicate`] - means that the coin is not signed, and the `owner` is a `predicate`
///   bytecode. The merkle root from the `predicate` should be equal to the `owner`.
/// - [`Full`] - is used during the deserialization of the coin. It should be transformed
///   into [`Signed`] or [`Predicate`] sub-coin. If the `predicate` is empty, it is
///   [`Signed`], else [`Predicate`].
#[derive(Default, Derivative, Clone, PartialEq, Eq, Hash)]
#[derivative(Debug)]
#[derive(serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "da-compression", derive(fuel_compression::Compress))]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
pub struct Coin<Specification>
where
    Specification: CoinSpecification,
{
    pub utxo_id: UtxoId,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub owner: Address,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub amount: Word,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub asset_id: AssetId,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub tx_pointer: TxPointer,
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub witness_index: Specification::Witness,
    /// Exact amount of gas used by the predicate.
    /// If the predicate consumes different amount of gas,
    /// it's considered to be false.
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub predicate_gas_used: Specification::PredicateGasUsed,
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub predicate: Specification::Predicate,
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub predicate_data: Specification::PredicateData,
}

impl<Specification> Coin<Specification>
where
    Specification: CoinSpecification,
{
    /// The "Note" section from the specification:
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputcoin>.
    pub fn prepare_sign(&mut self) {
        self.tx_pointer = Default::default();
        if let Some(predicate_gas_used_field) = self.predicate_gas_used.as_mut_field() {
            *predicate_gas_used_field = Default::default();
        }
    }
}

impl Coin<Full> {
    pub fn into_signed(self) -> Coin<Signed> {
        let Self {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
            ..
        } = self;

        Coin {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
            ..Default::default()
        }
    }

    pub fn into_predicate(self) -> Coin<Predicate> {
        let Self {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..
        } = self;

        Coin {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..Default::default()
        }
    }
}

impl Coin<Signed> {
    pub fn into_full(self) -> Coin<Full> {
        let Self {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
            ..
        } = self;

        Coin {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            witness_index,
            ..Default::default()
        }
    }
}

impl Coin<Predicate> {
    pub fn into_full(self) -> Coin<Full> {
        let Self {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..
        } = self;

        Coin {
            utxo_id,
            owner,
            amount,
            asset_id,
            tx_pointer,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..Default::default()
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/input/predicate.rs

Source
use core::ops::{
    Deref,
    DerefMut,
};
use derivative::Derivative;
use fuel_types::fmt_truncated_hex;

use alloc::vec::Vec;

#[derive(Clone, Default, Derivative, serde::Serialize, serde::Deserialize)]
#[serde(transparent)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub struct PredicateCode {
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))]
    pub bytes: Vec<u8>,
}

impl From<Vec<u8>> for PredicateCode {
    fn from(bytes: Vec<u8>) -> Self {
        Self { bytes }
    }
}

impl From<&[u8]> for PredicateCode {
    fn from(bytes: &[u8]) -> Self {
        Self {
            bytes: bytes.to_vec(),
        }
    }
}

impl AsRef<[u8]> for PredicateCode {
    fn as_ref(&self) -> &[u8] {
        &self.bytes
    }
}

impl AsMut<[u8]> for PredicateCode {
    fn as_mut(&mut self) -> &mut [u8] {
        &mut self.bytes
    }
}

impl Deref for PredicateCode {
    type Target = Vec<u8>;

    fn deref(&self) -> &Self::Target {
        &self.bytes
    }
}

impl DerefMut for PredicateCode {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.bytes
    }
}

#[cfg(feature = "da-compression")]
impl fuel_compression::Compressible for PredicateCode {
    type Compressed = fuel_compression::RegistryKey;
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/input/repr.rs

Source
use super::{
    consts::*,
    Input,
};

#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Hash,
    fuel_types::canonical::Serialize,
    fuel_types::canonical::Deserialize,
)]
#[repr(u64)]
pub enum InputRepr {
    Coin = 0x00,
    Contract = 0x01,
    Message = 0x02,
}

impl InputRepr {
    pub const fn utxo_id_offset(&self) -> Option<usize> {
        match self {
            Self::Coin | Self::Contract => Some(INPUT_UTXO_ID_OFFSET),
            Self::Message => None,
        }
    }

    pub const fn owner_offset(&self) -> Option<usize> {
        match self {
            Self::Coin => Some(INPUT_COIN_OWNER_OFFSET),
            Self::Message => Some(INPUT_MESSAGE_RECIPIENT_OFFSET),
            Self::Contract => None,
        }
    }

    pub const fn asset_id_offset(&self) -> Option<usize> {
        match self {
            Self::Coin => Some(INPUT_COIN_ASSET_ID_OFFSET),
            Self::Message | Self::Contract => None,
        }
    }

    pub const fn data_offset(&self) -> Option<usize> {
        match self {
            Self::Message => Some(INPUT_MESSAGE_FIXED_SIZE),
            Self::Coin | Self::Contract => None,
        }
    }

    pub const fn coin_predicate_offset(&self) -> Option<usize> {
        match self {
            Self::Coin => Some(INPUT_COIN_FIXED_SIZE),
            Self::Message | Self::Contract => None,
        }
    }

    pub const fn contract_balance_root_offset(&self) -> Option<usize> {
        match self {
            Self::Contract => Some(INPUT_CONTRACT_BALANCE_ROOT_OFFSET),
            Self::Message | Self::Coin => None,
        }
    }

    pub const fn contract_state_root_offset(&self) -> Option<usize> {
        match self {
            Self::Contract => Some(INPUT_CONTRACT_STATE_ROOT_OFFSET),
            Self::Message | Self::Coin => None,
        }
    }

    pub const fn contract_id_offset(&self) -> Option<usize> {
        match self {
            Self::Contract => Some(INPUT_CONTRACT_ID_OFFSET),
            Self::Message | Self::Coin => None,
        }
    }

    pub const fn message_sender_offset(&self) -> Option<usize> {
        match self {
            Self::Message => Some(INPUT_MESSAGE_SENDER_OFFSET),
            Self::Contract | Self::Coin => None,
        }
    }

    pub const fn message_recipient_offset(&self) -> Option<usize> {
        match self {
            Self::Message => Some(INPUT_MESSAGE_RECIPIENT_OFFSET),
            Self::Contract | Self::Coin => None,
        }
    }

    pub const fn message_nonce_offset(&self) -> Option<usize> {
        match self {
            Self::Message => Some(INPUT_NONCE_RECIPIENT_OFFSET),
            Self::Contract | Self::Coin => None,
        }
    }

    pub const fn tx_pointer_offset(&self) -> Option<usize> {
        match self {
            Self::Coin => Some(INPUT_COIN_TX_POINTER_OFFSET),
            Self::Contract => Some(INPUT_CONTRACT_TX_POINTER_OFFSET),
            Self::Message => None,
        }
    }

    pub const fn from_input(input: &Input) -> Self {
        match input {
            Input::CoinSigned(_) | Input::CoinPredicate(_) => InputRepr::Coin,
            Input::Contract(_) => InputRepr::Contract,
            Input::MessageCoinSigned(_)
            | Input::MessageCoinPredicate(_)
            | Input::MessageDataSigned(_)
            | Input::MessageDataPredicate(_) => InputRepr::Message,
        }
    }
}

impl From<&Input> for InputRepr {
    fn from(input: &Input) -> Self {
        Self::from_input(input)
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/input/contract.rs

Source
use crate::{
    TxPointer,
    UtxoId,
};
use fuel_types::{
    Bytes32,
    ContractId,
};

/// It is a full representation of the contract input from the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputcontract>.
///
/// The specification defines the layout of the [`Contract`] in the serialized form for
/// the `fuel-vm`.
#[derive(
    Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen(js_name = InputContract))]
pub struct Contract {
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub utxo_id: UtxoId,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub balance_root: Bytes32,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub state_root: Bytes32,
    /// Pointer to transction that last modified the contract state.
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub tx_pointer: TxPointer,
    pub contract_id: ContractId,
}

impl Contract {
    /// The "Note" section from the specification:
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputcontract>.
    pub fn prepare_sign(&mut self) {
        self.utxo_id = Default::default();
        self.balance_root = Default::default();
        self.state_root = Default::default();
        self.tx_pointer = Default::default();
    }
}

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

#[cfg(feature = "random")]
impl Distribution<Contract> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Contract {
        Contract {
            utxo_id: rng.gen(),
            balance_root: rng.gen(),
            state_root: rng.gen(),
            tx_pointer: rng.gen(),
            contract_id: rng.gen(),
        }
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use super::*;

    use crate::{
        TxPointer,
        UtxoId,
    };
    use fuel_types::{
        Bytes32,
        ContractId,
    };

    #[wasm_bindgen(js_class = InputContract)]
    impl Contract {
        #[wasm_bindgen(constructor)]
        pub fn typescript_new(
            utxo_id: UtxoId,
            balance_root: Bytes32,
            state_root: Bytes32,
            tx_pointer: TxPointer,
            contract_id: ContractId,
        ) -> Self {
            Self {
                utxo_id,
                balance_root,
                state_root,
                tx_pointer,
                contract_id,
            }
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/input/message.rs

Source
use crate::{
    input::fmt_as_field,
    transaction::types::input::AsField,
};
use alloc::vec::Vec;
use derivative::Derivative;
#[cfg(feature = "da-compression")]
use fuel_compression::Compressible;
use fuel_types::{
    Address,
    MessageId,
    Nonce,
    Word,
};

use super::PredicateCode;

pub type FullMessage = Message<specifications::Full>;
pub type MessageDataSigned = Message<specifications::MessageData<specifications::Signed>>;
pub type MessageDataPredicate =
    Message<specifications::MessageData<specifications::Predicate>>;
pub type MessageCoinSigned = Message<specifications::MessageCoin<specifications::Signed>>;
pub type MessageCoinPredicate =
    Message<specifications::MessageCoin<specifications::Predicate>>;

mod private {
    pub trait Seal {}

    impl Seal for super::specifications::Full {}
    impl Seal for super::specifications::MessageData<super::specifications::Signed> {}
    impl Seal for super::specifications::MessageData<super::specifications::Predicate> {}
    impl Seal for super::specifications::MessageCoin<super::specifications::Signed> {}
    impl Seal for super::specifications::MessageCoin<super::specifications::Predicate> {}
}

/// Specifies the message based on the usage context. See [`Message`].
#[cfg(feature = "da-compression")]
pub trait MessageSpecification: private::Seal {
    type Data: AsField<Vec<u8>>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
    type Predicate: AsField<PredicateCode>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
    type PredicateData: AsField<Vec<u8>>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
    type PredicateGasUsed: AsField<Word>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        > + Default;
    type Witness: AsField<u16>
        + for<'a> Compressible<
            Compressed: core::fmt::Debug
                            + PartialEq
                            + Clone
                            + serde::Serialize
                            + serde::Deserialize<'a>,
        >;
}

#[cfg(not(feature = "da-compression"))]
pub trait MessageSpecification: private::Seal {
    type Data: AsField<Vec<u8>>;
    type Predicate: AsField<PredicateCode>;
    type PredicateData: AsField<Vec<u8>>;
    type PredicateGasUsed: AsField<Word>;
    type Witness: AsField<u16>;
}

pub mod specifications {
    use alloc::vec::Vec;

    use super::MessageSpecification;
    use crate::input::{
        Empty,
        PredicateCode,
    };
    use fuel_types::Word;

    /// The type means that the message should be signed by the `recipient`, and the
    /// signature(witness) should be stored under the `witness_index` index in the
    /// `witnesses` vector of the [`crate::Transaction`].
    #[derive(
        Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
    )]
    #[cfg_attr(
        feature = "da-compression",
        derive(fuel_compression::Compress, fuel_compression::Decompress)
    )]
    pub struct Signed;

    /// The type means that the message is not signed, and the `owner` is a `predicate`
    /// bytecode. The merkle root from the `predicate` should be equal to the `owner`.
    #[derive(
        Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
    )]
    #[cfg_attr(
        feature = "da-compression",
        derive(fuel_compression::Compress, fuel_compression::Decompress)
    )]
    pub struct Predicate;

    /// The retrayable message metadata. It is a message that can't be used as a coin to
    /// pay for fees but can be used to pass metadata to the contract. It may have a
    /// non-zero `value` that will be transferred to the contract as a native asset
    /// during the execution. If the execution of the transaction fails, the metadata
    /// is not consumed and can be used later until successful execution.
    #[derive(
        Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
    )]
    pub struct MessageData<UsageRules>(core::marker::PhantomData<UsageRules>);

    impl MessageSpecification for MessageData<Signed> {
        type Data = Vec<u8>;
        type Predicate = Empty<PredicateCode>;
        type PredicateData = Empty<Vec<u8>>;
        type PredicateGasUsed = Empty<Word>;
        type Witness = u16;
    }

    impl MessageSpecification for MessageData<Predicate> {
        type Data = Vec<u8>;
        type Predicate = PredicateCode;
        type PredicateData = Vec<u8>;
        type PredicateGasUsed = Word;
        type Witness = Empty<u16>;
    }

    /// The spendable message acts as a standard coin.
    #[derive(
        Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
    )]
    pub struct MessageCoin<UsageRules>(core::marker::PhantomData<UsageRules>);

    impl MessageSpecification for MessageCoin<Signed> {
        type Data = Empty<Vec<u8>>;
        type Predicate = Empty<PredicateCode>;
        type PredicateData = Empty<Vec<u8>>;
        type PredicateGasUsed = Empty<Word>;
        type Witness = u16;
    }

    impl MessageSpecification for MessageCoin<Predicate> {
        type Data = Empty<Vec<u8>>;
        type Predicate = PredicateCode;
        type PredicateData = Vec<u8>;
        type PredicateGasUsed = Word;
        type Witness = Empty<u16>;
    }

    /// The type is used to represent the full message. It is used during the
    /// deserialization of the message to determine the final type.
    /// If the `data` field is empty, it should be transformed into [`MessageData`].
    /// Otherwise into [`MessageCoin`].
    /// If the `predicate` is empty, the usage rules should be [`Signed`], else
    /// [`Predicate`].
    #[derive(
        Default, Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
    )]
    pub struct Full;

    impl MessageSpecification for Full {
        type Data = Vec<u8>;
        type Predicate = PredicateCode;
        type PredicateData = Vec<u8>;
        type PredicateGasUsed = Word;
        type Witness = u16;
    }
}

/// It is a full representation of the message from the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/input.md#inputmessage>.
///
/// The specification defines the layout of the [`Message`] in the serialized form for
/// the `fuel-vm`. But on the business logic level, we don't use all fields at the same
/// time. It is why in the [`super::Input`] the message is represented by several forms
/// based on the usage context. Leaving some fields empty reduces the memory consumption
/// by the structure and erases the empty useless fields.
///
/// The [`MessageSpecification`] trait specifies the sub-messages for the corresponding
/// usage context. It allows us to write the common logic of all sub-messages without the
/// overhead and duplication.
///
/// Sub-messages from [`specifications`]:
/// - [`specifications::MessageData`] with [`specifications::Signed`] usage rules.
/// - [`specifications::MessageData`] with [`specifications::Predicate`] usage rules.
/// - [`specifications::Full`].
#[derive(Default, Derivative, Clone, PartialEq, Eq, Hash)]
#[derivative(Debug)]
#[derive(serde::Serialize, serde::Deserialize)]
#[cfg_attr(feature = "da-compression", derive(fuel_compression::Compress))]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
pub struct Message<Specification>
where
    Specification: MessageSpecification,
{
    /// The sender from the L1 chain.
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub sender: Address,
    /// The receiver on the `Fuel` chain.
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub recipient: Address,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub amount: Word,
    // Unique identifier of the message
    pub nonce: Nonce,
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub witness_index: Specification::Witness,
    /// Exact amount of gas used by the predicate.
    /// If the predicate consumes different amount of gas,
    /// it's considered to be false.
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub predicate_gas_used: Specification::PredicateGasUsed,
    #[cfg_attr(feature = "da-compression", compress(skip))]
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub data: Specification::Data,
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub predicate: Specification::Predicate,
    #[derivative(Debug(format_with = "fmt_as_field"))]
    pub predicate_data: Specification::PredicateData,
}

impl<Specification> Message<Specification>
where
    Specification: MessageSpecification,
{
    pub fn prepare_sign(&mut self) {
        if let Some(predicate_gas_used_field) = self.predicate_gas_used.as_mut_field() {
            *predicate_gas_used_field = Default::default();
        }
    }

    pub fn message_id(&self) -> MessageId {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            data,
            ..
        } = self;
        if let Some(data) = data.as_field() {
            compute_message_id(sender, recipient, nonce, *amount, data)
        } else {
            compute_message_id(sender, recipient, nonce, *amount, &[])
        }
    }
}

impl FullMessage {
    pub fn into_message_data_signed(self) -> MessageDataSigned {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            data,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            data,
            ..Default::default()
        }
    }

    pub fn into_message_data_predicate(self) -> MessageDataPredicate {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            data,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            data,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..Default::default()
        }
    }

    pub fn into_coin_signed(self) -> MessageCoinSigned {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            ..Default::default()
        }
    }

    pub fn into_coin_predicate(self) -> MessageCoinPredicate {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..Default::default()
        }
    }
}

impl MessageCoinSigned {
    pub fn into_full(self) -> FullMessage {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            ..Default::default()
        }
    }
}

impl MessageCoinPredicate {
    pub fn into_full(self) -> FullMessage {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..Default::default()
        }
    }
}

impl MessageDataPredicate {
    pub fn into_full(self) -> FullMessage {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            data,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            data,
            predicate,
            predicate_data,
            predicate_gas_used,
            ..Default::default()
        }
    }
}

impl MessageDataSigned {
    pub fn into_full(self) -> FullMessage {
        let Self {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            data,
            ..
        } = self;

        Message {
            sender,
            recipient,
            amount,
            nonce,
            witness_index,
            data,
            ..Default::default()
        }
    }
}

pub fn compute_message_id(
    sender: &Address,
    recipient: &Address,
    nonce: &Nonce,
    amount: Word,
    data: &[u8],
) -> MessageId {
    let hasher = fuel_crypto::Hasher::default()
        .chain(sender)
        .chain(recipient)
        .chain(nonce)
        .chain(amount.to_be_bytes())
        .chain(data);

    (*hasher.finalize()).into()
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/utxo_id.rs

Source
use crate::TxId;

use fuel_types::Bytes32;

use core::{
    fmt,
    str,
};

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

/// Identification of unspend transaction output.
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[derive(
    serde::Serialize,
    serde::Deserialize,
    fuel_types::canonical::Deserialize,
    fuel_types::canonical::Serialize,
)]
pub struct UtxoId {
    /// transaction id
    tx_id: TxId,
    /// output index
    output_index: u16,
}

#[cfg(feature = "da-compression")]
#[derive(
    Debug,
    Default,
    Copy,
    Clone,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Hash,
    serde::Serialize,
    serde::Deserialize,
)]
pub struct CompressedUtxoId {
    pub tx_pointer: crate::TxPointer,
    pub output_index: u16,
}

#[cfg(feature = "da-compression")]
impl fuel_compression::Compressible for UtxoId {
    type Compressed = CompressedUtxoId;
}

impl UtxoId {
    pub const LEN: usize = TxId::LEN + 8;

    pub const fn new(tx_id: TxId, output_index: u16) -> Self {
        Self {
            tx_id,
            output_index,
        }
    }

    pub const fn tx_id(&self) -> &TxId {
        &self.tx_id
    }

    pub const fn output_index(&self) -> u16 {
        self.output_index
    }

    pub fn replace_tx_id(&mut self, tx_id: TxId) {
        self.tx_id = tx_id;
    }
}

#[cfg(feature = "random")]
impl Distribution<UtxoId> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> UtxoId {
        let mut tx_id = Bytes32::default();
        rng.fill_bytes(tx_id.as_mut());
        UtxoId::new(tx_id, rng.gen())
    }
}

impl fmt::LowerHex for UtxoId {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if f.alternate() {
            write!(f, "{:#x}{:04x}", self.tx_id, self.output_index)
        } else {
            write!(f, "{:x}{:04x}", self.tx_id, self.output_index)
        }
    }
}

impl fmt::UpperHex for UtxoId {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if f.alternate() {
            write!(f, "{:#X}{:04X}", self.tx_id, self.output_index)
        } else {
            write!(f, "{:X}{:04X}", self.tx_id, self.output_index)
        }
    }
}

impl core::fmt::Display for UtxoId {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if f.alternate() {
            write!(f, "{:#x}{:04x}", self.tx_id, self.output_index)
        } else {
            write!(f, "{:x}{:04x}", self.tx_id, self.output_index)
        }
    }
}

impl str::FromStr for UtxoId {
    type Err = &'static str;

    /// UtxoId is encoded as hex string with optional 0x prefix, where
    /// the last two characters are the output index and the part
    /// optionally preceeding it is the transaction id.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        const ERR: &str = "Invalid encoded byte in UtxoId";
        let s = s.strip_prefix("0x").unwrap_or(s);

        Ok(if s.is_empty() {
            UtxoId::new(Bytes32::default(), 0)
        } else if s.len() <= 4 {
            UtxoId::new(
                TxId::default(),
                u16::from_str_radix(s, 16).map_err(|_| ERR)?,
            )
        } else {
            #[allow(clippy::arithmetic_side_effects)] // Checked above
            let i = s.len() - 4;
            if !s.is_char_boundary(i) {
                return Err(ERR)
            }
            let (tx_id, output_index) = s.split_at(i);
            let tx_id = tx_id.strip_suffix(':').unwrap_or(tx_id);

            UtxoId::new(
                Bytes32::from_str(tx_id)?,
                u16::from_str_radix(output_index, 16).map_err(|_| ERR)?,
            )
        })
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use super::*;

    use wasm_bindgen::prelude::*;

    use alloc::{
        format,
        string::String,
        vec::Vec,
    };

    #[wasm_bindgen]
    impl UtxoId {
        #[wasm_bindgen(constructor)]
        pub fn typescript_new(value: &str) -> Result<UtxoId, js_sys::Error> {
            use core::str::FromStr;
            UtxoId::from_str(value).map_err(js_sys::Error::new)
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:#x}", self)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            <Self as Serialize>::to_bytes(self)
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<UtxoId, js_sys::Error> {
            use fuel_types::canonical::Deserialize;

            <Self as Deserialize>::from_bytes(value)
                .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use core::str::FromStr;
    use fuel_types::Bytes32;

    #[test]
    fn fmt_utxo_id_with_one_bytes_output_index() {
        let mut tx_id = Bytes32::zeroed();
        *tx_id.get_mut(0).unwrap() = 12;
        *tx_id.get_mut(31).unwrap() = 11;

        let utxo_id = UtxoId {
            tx_id,
            output_index: 0xab,
        };
        assert_eq!(
            format!("{utxo_id:#x}"),
            "0x0c0000000000000000000000000000000000000000000000000000000000000b00ab"
        );
        assert_eq!(
            format!("{utxo_id:x}"),
            "0c0000000000000000000000000000000000000000000000000000000000000b00ab"
        );
    }

    #[test]
    fn fmt_utxo_id_with_two_bytes_output_index() {
        let mut tx_id = Bytes32::zeroed();
        *tx_id.get_mut(0).unwrap() = 12;
        *tx_id.get_mut(31).unwrap() = 11;

        let utxo_id = UtxoId {
            tx_id,
            output_index: 0xabcd,
        };
        assert_eq!(
            format!("{utxo_id:#x}"),
            "0x0c0000000000000000000000000000000000000000000000000000000000000babcd"
        );
        assert_eq!(
            format!("{utxo_id:x}"),
            "0c0000000000000000000000000000000000000000000000000000000000000babcd"
        );
    }

    #[test]
    fn from_str_utxo_id() -> Result<(), &'static str> {
        let utxo_id = UtxoId::from_str(
            "0x0c0000000000000000000000000000000000000000000000000000000000000babcd",
        )?;

        assert_eq!(utxo_id.output_index, 0xabcd);
        assert_eq!(utxo_id.tx_id[31], 11);
        assert_eq!(utxo_id.tx_id[0], 12);
        Ok(())
    }

    #[test]
    fn from_str_utxo_id_colon_separator() -> Result<(), &'static str> {
        let utxo_id = UtxoId::from_str(
            "0c0000000000000000000000000000000000000000000000000000000000000b:abcd",
        )?;

        assert_eq!(utxo_id.output_index, 0xabcd);
        assert_eq!(utxo_id.tx_id[31], 11);
        assert_eq!(utxo_id.tx_id[0], 12);
        Ok(())
    }

    /// See https://github.com/FuelLabs/fuel-vm/issues/521
    #[test]
    fn from_str_utxo_id_multibyte_bug() {
        UtxoId::from_str("0x00😎").expect_err("Should fail on incorrect input");
        UtxoId::from_str("0x000😎").expect_err("Should fail on incorrect input");
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/witness.rs

Source
use derivative::Derivative;
use fuel_types::fmt_truncated_hex;

use alloc::vec::Vec;

use crate::{
    Input,
    TxId,
    ValidityError,
};
use fuel_crypto::{
    Message,
    Signature,
};

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

#[derive(Derivative, Default, Clone, PartialEq, Eq, Hash)]
#[derivative(Debug)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[derive(serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
pub struct Witness {
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))]
    data: Vec<u8>,
}

impl Witness {
    pub const fn as_vec(&self) -> &Vec<u8> {
        &self.data
    }

    pub fn as_vec_mut(&mut self) -> &mut Vec<u8> {
        &mut self.data
    }

    pub fn into_inner(self) -> Vec<u8> {
        self.data
    }

    /// ECRecover an address from a witness
    pub fn recover_witness(
        &self,
        txhash: &TxId,
        input_index: usize,
    ) -> Result<fuel_types::Address, ValidityError> {
        let bytes = <[u8; Signature::LEN]>::try_from(self.as_ref())
            .map_err(|_| ValidityError::InputInvalidSignature { index: input_index })?;
        let signature = Signature::from_bytes(bytes);

        let message = Message::from_bytes_ref(txhash);

        signature
            .recover(message)
            .map_err(|_| ValidityError::InputInvalidSignature { index: input_index })
            .map(|pk| Input::owner(&pk))
    }
}

impl From<Vec<u8>> for Witness {
    fn from(data: Vec<u8>) -> Self {
        Self { data }
    }
}

impl From<&[u8]> for Witness {
    fn from(data: &[u8]) -> Self {
        data.to_vec().into()
    }
}

impl AsRef<[u8]> for Witness {
    fn as_ref(&self) -> &[u8] {
        self.data.as_ref()
    }
}

impl AsMut<[u8]> for Witness {
    fn as_mut(&mut self) -> &mut [u8] {
        self.data.as_mut()
    }
}

impl Extend<u8> for Witness {
    fn extend<T: IntoIterator<Item = u8>>(&mut self, iter: T) {
        self.data.extend(iter);
    }
}

#[cfg(feature = "random")]
impl Distribution<Witness> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Witness {
        let len = rng.gen_range(0..512);

        let mut data = alloc::vec![0u8; len];
        rng.fill_bytes(data.as_mut_slice());

        data.into()
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use super::Witness;

    use alloc::{
        format,
        string::String,
        vec::Vec,
    };

    #[wasm_bindgen]
    impl Witness {
        #[wasm_bindgen(js_name = toJSON)]
        pub fn to_json(&self) -> String {
            serde_json::to_string(&self.data).expect("unable to json format")
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:?}", self.data)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            self.to_bytes()
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<Witness, js_sys::Error> {
            use alloc::string::ToString;
            use fuel_types::canonical::Deserialize;
            <Self as Deserialize>::from_bytes(value)
                .map_err(|e| js_sys::Error::new(&e.to_string()))
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/output/repr.rs

Source
use super::{
    consts::*,
    Output,
};

#[cfg(feature = "std")]
use fuel_types::Word;

#[cfg(feature = "std")]
use std::io;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum OutputRepr {
    Coin = 0x00,
    Contract = 0x01,
    Change = 0x02,
    Variable = 0x03,
    ContractCreated = 0x04,
}

impl OutputRepr {
    pub const fn to_offset(&self) -> Option<usize> {
        match self {
            OutputRepr::Coin | OutputRepr::Change | OutputRepr::Variable => {
                Some(OUTPUT_CCV_TO_OFFSET)
            }
            _ => None,
        }
    }

    pub const fn asset_id_offset(&self) -> Option<usize> {
        match self {
            OutputRepr::Coin | OutputRepr::Change | OutputRepr::Variable => {
                Some(OUTPUT_CCV_ASSET_ID_OFFSET)
            }
            _ => None,
        }
    }

    pub const fn contract_balance_root_offset(&self) -> Option<usize> {
        match self {
            Self::Contract => Some(OUTPUT_CONTRACT_BALANCE_ROOT_OFFSET),
            _ => None,
        }
    }

    pub const fn contract_state_root_offset(&self) -> Option<usize> {
        match self {
            Self::Contract => Some(OUTPUT_CONTRACT_STATE_ROOT_OFFSET),
            _ => None,
        }
    }

    pub const fn contract_created_state_root_offset(&self) -> Option<usize> {
        match self {
            Self::ContractCreated => Some(OUTPUT_CONTRACT_CREATED_STATE_ROOT_OFFSET),
            _ => None,
        }
    }

    pub const fn contract_id_offset(&self) -> Option<usize> {
        match self {
            Self::ContractCreated => Some(OUTPUT_CONTRACT_CREATED_ID_OFFSET),
            _ => None,
        }
    }

    pub const fn from_output(output: &Output) -> Self {
        match output {
            Output::Coin { .. } => Self::Coin,
            Output::Contract(_) => Self::Contract,
            Output::Change { .. } => Self::Change,
            Output::Variable { .. } => Self::Variable,
            Output::ContractCreated { .. } => Self::ContractCreated,
        }
    }
}

#[cfg(feature = "std")]
impl TryFrom<Word> for OutputRepr {
    type Error = io::Error;

    fn try_from(b: Word) -> Result<Self, Self::Error> {
        match b {
            0x00 => Ok(Self::Coin),
            0x01 => Ok(Self::Contract),
            0x02 => Ok(Self::Change),
            0x03 => Ok(Self::Variable),
            0x04 => Ok(Self::ContractCreated),
            i => Err(io::Error::new(
                io::ErrorKind::InvalidData,
                format!("The provided output identifier ({i}) is invalid!"),
            )),
        }
    }
}

impl From<&Output> for OutputRepr {
    fn from(o: &Output) -> Self {
        Self::from_output(o)
    }
}

impl From<&mut Output> for OutputRepr {
    fn from(o: &mut Output) -> Self {
        Self::from_output(o)
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/output/contract.rs

Source
use fuel_types::Bytes32;

/// It is a full representation of the contract output from the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/output.md#outputcontract>.
///
/// The specification defines the layout of the [`Contract`] in the serialized form for
/// the `fuel-vm`.
#[derive(
    Default, Debug, Copy, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen(js_name = OutputContract))]
pub struct Contract {
    /// Index of input contract.
    pub input_index: u16,
    /// Root of amount of coins owned by contract after transaction execution.
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub balance_root: Bytes32,
    /// State root of contract after transaction execution.
    #[cfg_attr(feature = "da-compression", compress(skip))]
    pub state_root: Bytes32,
}

impl Contract {
    /// The "Note" section from the specification:
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/output.md#outputcontract>.
    pub fn prepare_sign(&mut self) {
        self.balance_root = Default::default();
        self.state_root = Default::default();
    }
}

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

#[cfg(feature = "random")]
impl Distribution<Contract> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Contract {
        Contract {
            input_index: rng.gen(),
            balance_root: rng.gen(),
            state_root: rng.gen(),
        }
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use super::*;

    use fuel_types::Bytes32;

    #[wasm_bindgen(js_class = OutputContract)]
    impl Contract {
        #[wasm_bindgen(constructor)]
        pub fn typescript_new(
            input_index: u16,
            balance_root: Bytes32,
            state_root: Bytes32,
        ) -> Self {
            Self {
                input_index,
                balance_root,
                state_root,
            }
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/blob.rs

Source
use crate::{
    transaction::{
        fee::min_gas,
        id::PrepareSign,
        metadata::CommonMetadata,
        types::chargeable_transaction::{
            ChargeableMetadata,
            ChargeableTransaction,
            UniqueFormatValidityChecks,
        },
        Chargeable,
    },
    ConsensusParameters,
    FeeParameters,
    GasCosts,
    Input,
    Output,
    TransactionRepr,
    ValidityError,
};
use derivative::Derivative;
use fuel_types::{
    bytes::WORD_SIZE,
    canonical::Serialize,
    BlobId,
    ChainId,
    Word,
};

/// Adds method to `BlobId` to compute the it from blob data.
pub trait BlobIdExt {
    /// Computes the `BlobId` from by hashing the given data.
    fn compute(data: &[u8]) -> BlobId;
}

impl BlobIdExt for BlobId {
    fn compute(data: &[u8]) -> Self {
        Self::new(*fuel_crypto::Hasher::hash(data))
    }
}

pub type Blob = ChargeableTransaction<BlobBody, BlobMetadata>;

#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
pub struct BlobMetadata;

/// The body of the [`Blob`] transaction.
#[derive(Clone, Default, Derivative, serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[canonical(prefix = TransactionRepr::Blob)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub struct BlobBody {
    /// Hash of the bytecode. Used both as a unique identifier and to verify the
    /// bytecode.
    pub id: BlobId,
    /// The witness index of the payload.
    pub witness_index: u16,
}

impl PrepareSign for BlobBody {
    fn prepare_sign(&mut self) {}
}

impl Chargeable for Blob {
    fn min_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> fuel_asm::Word {
        min_gas(self, gas_costs, fee)
    }

    #[inline(always)]
    fn metered_bytes_size(&self) -> usize {
        Serialize::size(self)
    }

    #[inline(always)]
    fn gas_used_by_metadata(&self, gas_cost: &GasCosts) -> Word {
        let bytes = Serialize::size(self);
        let blob_len = self
            .witnesses
            .get(self.body.witness_index as usize)
            .map(|c| c.as_ref().len())
            .unwrap_or(0);

        // Gas required to calculate the `tx_id` and `blob_id`.
        gas_cost
            .s256()
            .resolve(bytes as u64)
            .saturating_add(gas_cost.s256().resolve(blob_len as u64))
    }
}

impl UniqueFormatValidityChecks for Blob {
    fn check_unique_rules(
        &self,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        let index = self.body.witness_index as usize;
        let witness = self
            .witnesses
            .get(index)
            .ok_or(ValidityError::InputWitnessIndexBounds { index })?;

        // Verify that blob id is correct
        if BlobId::compute(witness.as_ref()) != self.body.id {
            return Err(ValidityError::TransactionBlobIdVerificationFailed);
        }

        self.inputs
            .iter()
            .enumerate()
            .try_for_each(|(index, input)| {
                if let Some(asset_id) = input.asset_id(consensus_params.base_asset_id()) {
                    if asset_id != consensus_params.base_asset_id() {
                        return Err(
                            ValidityError::TransactionInputContainsNonBaseAssetId {
                                index,
                            },
                        );
                    }
                }

                match input {
                    Input::Contract(_) => {
                        Err(ValidityError::TransactionInputContainsContract { index })
                    }
                    Input::MessageDataSigned(_) | Input::MessageDataPredicate(_) => {
                        Err(ValidityError::TransactionInputContainsMessageData { index })
                    }
                    _ => Ok(()),
                }
            })?;

        self.outputs
            .iter()
            .enumerate()
            .try_for_each(|(index, output)| match output {
                Output::Contract(_) => {
                    Err(ValidityError::TransactionOutputContainsContract { index })
                }

                Output::Variable { .. } => {
                    Err(ValidityError::TransactionOutputContainsVariable { index })
                }

                Output::Change { asset_id, .. } => {
                    if asset_id != consensus_params.base_asset_id() {
                        Err(ValidityError::TransactionChangeChangeUsesNotBaseAsset {
                            index,
                        })
                    } else {
                        Ok(())
                    }
                }

                Output::ContractCreated { .. } => {
                    Err(ValidityError::TransactionOutputContainsContractCreated { index })
                }

                Output::Coin { .. } => Ok(()),
            })?;

        Ok(())
    }
}

impl crate::Cacheable for Blob {
    fn is_computed(&self) -> bool {
        self.metadata.is_some()
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        self.metadata = None;
        self.metadata = Some(ChargeableMetadata {
            common: CommonMetadata::compute(self, chain_id)?,
            body: BlobMetadata {},
        });
        Ok(())
    }
}

mod field {
    use super::*;
    use crate::field::{
        self,
        BlobId as BlobIdField,
        BytecodeWitnessIndex,
    };

    impl field::BlobId for Blob {
        #[inline(always)]
        fn blob_id(&self) -> &BlobId {
            &self.body.id
        }

        #[inline(always)]
        fn blob_id_mut(&mut self) -> &mut BlobId {
            &mut self.body.id
        }

        #[inline(always)]
        fn blob_id_offset_static() -> usize {
            WORD_SIZE // `Transaction` enum discriminant
        }
    }

    impl field::BytecodeWitnessIndex for Blob {
        #[inline(always)]
        fn bytecode_witness_index(&self) -> &u16 {
            &self.body.witness_index
        }

        #[inline(always)]
        fn bytecode_witness_index_mut(&mut self) -> &mut u16 {
            &mut self.body.witness_index
        }

        #[inline(always)]
        fn bytecode_witness_index_offset_static() -> usize {
            Self::blob_id_offset_static().saturating_add(BlobId::LEN)
        }
    }

    impl field::ChargeableBody<BlobBody> for Blob {
        fn body(&self) -> &BlobBody {
            &self.body
        }

        fn body_mut(&mut self) -> &mut BlobBody {
            &mut self.body
        }

        #[allow(clippy::arithmetic_side_effects)] // Statically known to be ok
        fn body_offset_end(&self) -> usize {
            Self::bytecode_witness_index_offset_static().saturating_add(
                WORD_SIZE // witness_index
                + WORD_SIZE // Policies size
                + WORD_SIZE // Inputs size
                + WORD_SIZE // Outputs size
                + WORD_SIZE, // Witnesses size
            )
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/upgrade.rs

Source
use crate::{
    transaction::{
        id::PrepareSign,
        metadata::CommonMetadata,
        types::chargeable_transaction::{
            ChargeableMetadata,
            ChargeableTransaction,
            UniqueFormatValidityChecks,
        },
        Chargeable,
    },
    ConsensusParameters,
    GasCosts,
    Input,
    Output,
    TransactionRepr,
    ValidityError,
};
use derivative::Derivative;
use fuel_types::{
    bytes::WORD_SIZE,
    canonical::Serialize,
    Bytes32,
    ChainId,
    Word,
};

use fuel_crypto::Hasher;

#[cfg(feature = "alloc")]
use alloc::boxed::Box;

pub type Upgrade = ChargeableTransaction<UpgradeBody, UpgradeMetadata>;

#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
pub enum UpgradeMetadata {
    /// The metadata for the upgrade transaction that changes the consensus parameters.
    ConsensusParameters {
        /// Deserialized consensus parameters from the witness.
        consensus_parameters: Box<ConsensusParameters>,
        /// The actual checksum of the serialized consensus parameters.
        calculated_checksum: Bytes32,
    },
    /// Currently there is no metadata for state transition upgrades, so leave it empty.
    #[default]
    StateTransition,
}

impl UpgradeMetadata {
    pub fn compute(tx: &Upgrade) -> Result<Self, ValidityError> {
        match &tx.body.purpose {
            UpgradePurpose::ConsensusParameters {
                witness_index,
                checksum,
            } => {
                let index = *witness_index as usize;
                let witness = tx
                    .witnesses
                    .get(index)
                    .ok_or(ValidityError::InputWitnessIndexBounds { index })?;

                let serialized_consensus_parameters = witness.as_vec();
                let actual_checksum = Hasher::hash(serialized_consensus_parameters);

                if &actual_checksum != checksum {
                    Err(ValidityError::TransactionUpgradeConsensusParametersChecksumMismatch)?;
                }

                // The code that creates/verifies the `Upgrade` transaction should always
                // be able to decode the current consensus parameters
                // type. The state transition function should always know
                // how to decode consensus parameters. Otherwise, the next
                // block will be impossible to produce. If deserialization fails, it is a
                // sign that the code/state transition function should be updated.
                let consensus_parameters = postcard::from_bytes::<ConsensusParameters>(
                    serialized_consensus_parameters,
                )
                .map_err(|_| {
                    ValidityError::TransactionUpgradeConsensusParametersDeserialization
                })?;

                Ok(Self::ConsensusParameters {
                    consensus_parameters: Box::new(consensus_parameters),
                    calculated_checksum: actual_checksum,
                })
            }
            UpgradePurpose::StateTransition { .. } => {
                // Nothing metadata for state transition upgrades.
                Ok(Self::StateTransition)
            }
        }
    }
}

/// The types describe the purpose of the upgrade performed by the [`Upgrade`]
/// transaction.
#[derive(
    Copy, Clone, Derivative, strum_macros::EnumCount, serde::Serialize, serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub enum UpgradePurpose {
    /// The upgrade is performed to change the consensus parameters.
    ConsensusParameters {
        /// The index of the witness in the [`Witnesses`] field that contains
        /// the serialized consensus parameters.
        witness_index: u16,
        /// The hash of the serialized consensus parameters.
        /// Since the serialized consensus parameters live inside witnesses(malleable
        /// data), any party can override them. The `checksum` is used to verify that the
        /// data was not modified.
        checksum: Bytes32,
    },
    /// The upgrade is performed to change the state transition function.
    StateTransition {
        /// The Merkle root of the new bytecode of the state transition function.
        /// The bytecode must be present on the blockchain(should be known by the
        /// network) at the moment of inclusion of this transaction.
        root: Bytes32,
    },
}

/// The body of the [`Upgrade`] transaction.
#[derive(Clone, Derivative, serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[canonical(prefix = TransactionRepr::Upgrade)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub struct UpgradeBody {
    /// The purpose of the upgrade.
    pub(crate) purpose: UpgradePurpose,
}

impl Default for UpgradeBody {
    fn default() -> Self {
        Self {
            purpose: UpgradePurpose::StateTransition {
                root: Default::default(),
            },
        }
    }
}

impl PrepareSign for UpgradeBody {
    fn prepare_sign(&mut self) {}
}

impl Chargeable for Upgrade {
    #[inline(always)]
    fn metered_bytes_size(&self) -> usize {
        Serialize::size(self)
    }

    #[inline(always)]
    fn gas_used_by_metadata(&self, gas_cost: &GasCosts) -> Word {
        let bytes = Serialize::size(self);
        // Gas required to calculate the `tx_id`.
        let tx_id_gas = gas_cost.s256().resolve(bytes as u64);

        let purpose_gas = match &self.body.purpose {
            UpgradePurpose::ConsensusParameters { witness_index, .. } => {
                let len = self
                    .witnesses
                    .get(*witness_index as usize)
                    .map_or(0, |w| w.as_vec().len());
                gas_cost.s256().resolve(len as u64)
            }
            UpgradePurpose::StateTransition { .. } => {
                // In the case of the state transition upgrade, we only require the
                // existence of the bytecode on the blockchain. So we
                // verify nothing and charge nothing.
                0
            }
        };

        tx_id_gas.saturating_add(purpose_gas)
    }
}

impl UniqueFormatValidityChecks for Upgrade {
    fn check_unique_rules(
        &self,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        // At least one of inputs must be owned by the privileged address.
        self.inputs
            .iter()
            .find(|input| {
                if let Some(owner) = input.input_owner() {
                    owner == consensus_params.privileged_address()
                } else {
                    false
                }
            })
            .ok_or(ValidityError::TransactionUpgradeNoPrivilegedAddress)?;

        // We verify validity of the `UpgradePurpose` in the
        // `UpgradeMetadata::compute`.
        let calculated_metadata = UpgradeMetadata::compute(self)?;

        if let Some(metadata) = self.metadata.as_ref() {
            if metadata.body != calculated_metadata {
                return Err(ValidityError::TransactionMetadataMismatch);
            }
        }

        // The upgrade transaction cant touch the contract.
        self.inputs
            .iter()
            .enumerate()
            .try_for_each(|(index, input)| {
                if let Some(asset_id) = input.asset_id(consensus_params.base_asset_id()) {
                    if asset_id != consensus_params.base_asset_id() {
                        return Err(
                            ValidityError::TransactionInputContainsNonBaseAssetId {
                                index,
                            },
                        );
                    }
                }

                match input {
                    Input::Contract(_) => {
                        Err(ValidityError::TransactionInputContainsContract { index })
                    }
                    Input::MessageDataSigned(_) | Input::MessageDataPredicate(_) => {
                        Err(ValidityError::TransactionInputContainsMessageData { index })
                    }
                    _ => Ok(()),
                }
            })?;

        // The upgrade transaction can't create a contract.
        self.outputs
            .iter()
            .enumerate()
            .try_for_each(|(index, output)| match output {
                Output::Contract(_) => {
                    Err(ValidityError::TransactionOutputContainsContract { index })
                }

                Output::Variable { .. } => {
                    Err(ValidityError::TransactionOutputContainsVariable { index })
                }

                Output::Change { asset_id, .. }
                    if asset_id != consensus_params.base_asset_id() =>
                {
                    Err(ValidityError::TransactionChangeChangeUsesNotBaseAsset { index })
                }

                Output::ContractCreated { .. } => {
                    Err(ValidityError::TransactionOutputContainsContractCreated { index })
                }
                _ => Ok(()),
            })?;

        Ok(())
    }
}

impl crate::Cacheable for Upgrade {
    fn is_computed(&self) -> bool {
        self.metadata.is_some()
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        self.metadata = None;
        self.metadata = Some(ChargeableMetadata {
            common: CommonMetadata::compute(self, chain_id)?,
            body: UpgradeMetadata::compute(self)?,
        });
        Ok(())
    }
}

mod field {
    use super::*;
    use crate::field::{
        ChargeableBody,
        UpgradePurpose as UpgradePurposeTrait,
    };

    impl UpgradePurposeTrait for Upgrade {
        #[inline(always)]
        fn upgrade_purpose(&self) -> &UpgradePurpose {
            &self.body.purpose
        }

        #[inline(always)]
        fn upgrade_purpose_mut(&mut self) -> &mut UpgradePurpose {
            &mut self.body.purpose
        }

        #[inline(always)]
        fn upgrade_purpose_offset_static() -> usize {
            WORD_SIZE // `Transaction` enum discriminant
        }
    }

    impl ChargeableBody<UpgradeBody> for Upgrade {
        fn body(&self) -> &UpgradeBody {
            &self.body
        }

        fn body_mut(&mut self) -> &mut UpgradeBody {
            &mut self.body
        }

        fn body_offset_end(&self) -> usize {
            Self::upgrade_purpose_offset_static()
                .saturating_add(self.body.purpose.size())
                .saturating_add(
                    WORD_SIZE  // Policies size
                    + WORD_SIZE // Inputs size
                    + WORD_SIZE // Outputs size
                    + WORD_SIZE, // Witnesses size
                )
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/upload.rs

Source
use crate::{
    transaction::{
        fee::min_gas,
        id::PrepareSign,
        metadata::CommonMetadata,
        types::chargeable_transaction::{
            ChargeableMetadata,
            ChargeableTransaction,
            UniqueFormatValidityChecks,
        },
        Chargeable,
    },
    ConsensusParameters,
    FeeParameters,
    GasCosts,
    Input,
    Output,
    TransactionRepr,
    ValidityError,
};
use core::ops::Deref;
use derivative::Derivative;
use fuel_types::{
    bytes::WORD_SIZE,
    canonical::Serialize,
    Bytes32,
    ChainId,
    Word,
};

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

pub type Upload = ChargeableTransaction<UploadBody, UploadMetadata>;

#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
pub struct UploadMetadata;

/// The body of the [`Upload`] transaction.
#[derive(Clone, Default, Derivative, serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
#[canonical(prefix = TransactionRepr::Upload)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub struct UploadBody {
    /// The root of the Merkle tree is created over the bytecode.
    pub root: Bytes32,
    /// The witness index of the subsection of the bytecode.
    pub witness_index: u16,
    /// The index of the subsection of the bytecode.
    pub subsection_index: u16,
    /// The total number of subsections on which bytecode was divided.
    pub subsections_number: u16,
    /// The proof set helps to verify the connection of the subsection to the `root`.
    pub proof_set: Vec<Bytes32>,
}

#[derive(
    Clone, Default, Eq, PartialEq, Hash, Debug, serde::Serialize, serde::Deserialize,
)]
pub struct UploadSubsection {
    /// The root of the Merkle tree is created over the bytecode.
    pub root: Bytes32,
    /// The subsection of the bytecode.
    pub subsection: Vec<u8>,
    /// The index of the subsection.
    pub subsection_index: u16,
    /// The total number of subsections on which bytecode was divided.
    pub subsections_number: u16,
    /// The proof set helps to verify the connection of the subsection to the `root`.
    pub proof_set: Vec<Bytes32>,
}

#[derive(
    Copy, Clone, Eq, PartialEq, Hash, Debug, serde::Serialize, serde::Deserialize,
)]
pub enum SplitError {
    /// The size of the subsection is too small to fit all subsections into `u16::MAX`.
    SubsectionSizeTooSmall,
}

impl UploadSubsection {
    /// Splits the bytecode into verifiable subsections and returns a vector of
    /// [`UploadSubsection`]s.
    pub fn split_bytecode(
        bytecode: &[u8],
        subsection_size: usize,
    ) -> Result<Vec<UploadSubsection>, SplitError> {
        let subsections = bytecode
            .chunks(subsection_size)
            .map(|subsection| subsection.to_vec())
            .collect::<Vec<_>>();

        if subsections.len() > u16::MAX as usize {
            return Err(SplitError::SubsectionSizeTooSmall);
        }
        let subsections_number =
            u16::try_from(subsections.len()).expect("We've just checked it; qed");

        let mut merkle_tree = fuel_merkle::binary::in_memory::MerkleTree::new();
        subsections
            .iter()
            .for_each(|subsection| merkle_tree.push(subsection));

        let merkle_root = merkle_tree.root();

        let subsections = subsections
            .into_iter()
            .enumerate()
            .map(|(index, subsection)| {
                let (root, proof_set) = merkle_tree
                    .prove(index as u64)
                    .expect("We've just created a merkle tree, so it is valid; qed");
                debug_assert_eq!(root, merkle_root);

                UploadSubsection {
                    root: merkle_root.into(),
                    subsection,
                    subsection_index: u16::try_from(index).expect(
                        "The total number of subsections is less than u16::MAX; qed",
                    ),
                    subsections_number,
                    proof_set: proof_set.into_iter().map(Into::into).collect(),
                }
            })
            .collect();

        Ok(subsections)
    }
}

impl PrepareSign for UploadBody {
    fn prepare_sign(&mut self) {}
}

impl Chargeable for Upload {
    fn min_gas(&self, gas_costs: &GasCosts, fee: &FeeParameters) -> fuel_asm::Word {
        let bytecode_len = self
            .witnesses
            .get(self.body.witness_index as usize)
            .map(|c| c.as_ref().len())
            .unwrap_or(0);

        // Since the `Upload` transaction occupies much of the storage, we want to
        // discourage people from using it too much. For that, we charge additional gas
        // for the storage.
        let additional_charge_for_storage = gas_costs
            .new_storage_per_byte()
            .saturating_mul(bytecode_len as u64);

        min_gas(self, gas_costs, fee).saturating_add(additional_charge_for_storage)
    }

    #[inline(always)]
    fn metered_bytes_size(&self) -> usize {
        Serialize::size(self)
    }

    #[inline(always)]
    fn gas_used_by_metadata(&self, gas_cost: &GasCosts) -> Word {
        let bytes = Serialize::size(self);
        // Gas required to calculate the `tx_id`.
        let tx_id_gas = gas_cost.s256().resolve(bytes as u64);

        let bytecode_len = self
            .witnesses
            .get(self.body.witness_index as usize)
            .map(|c| c.as_ref().len())
            .unwrap_or(0);

        let leaf_hash_gas = gas_cost.s256().resolve(bytecode_len as u64);
        let verify_proof_gas = gas_cost
            .state_root()
            .resolve(self.body.subsections_number as u64);

        tx_id_gas
            .saturating_add(leaf_hash_gas)
            .saturating_add(verify_proof_gas)
    }
}

impl UniqueFormatValidityChecks for Upload {
    fn check_unique_rules(
        &self,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        if self.body.subsections_number
            > consensus_params.tx_params().max_bytecode_subsections()
        {
            return Err(ValidityError::TransactionUploadTooManyBytecodeSubsections);
        }

        let index = self.body.witness_index as usize;
        let witness = self
            .witnesses
            .get(index)
            .ok_or(ValidityError::InputWitnessIndexBounds { index })?;

        let proof_set = self
            .body
            .proof_set
            .iter()
            .map(|proof| (*proof).into())
            .collect::<Vec<_>>();

        // Verify that subsection of the bytecode is connected to the `root` of the
        // bytecode.
        let result = fuel_merkle::binary::verify(
            self.body.root.deref(),
            witness,
            &proof_set,
            self.body.subsection_index as u64,
            self.body.subsections_number as u64,
        );

        if !result {
            return Err(ValidityError::TransactionUploadRootVerificationFailed);
        }

        self.inputs
            .iter()
            .enumerate()
            .try_for_each(|(index, input)| {
                if let Some(asset_id) = input.asset_id(consensus_params.base_asset_id()) {
                    if asset_id != consensus_params.base_asset_id() {
                        return Err(
                            ValidityError::TransactionInputContainsNonBaseAssetId {
                                index,
                            },
                        );
                    }
                }

                match input {
                    Input::Contract(_) => {
                        Err(ValidityError::TransactionInputContainsContract { index })
                    }
                    Input::MessageDataSigned(_) | Input::MessageDataPredicate(_) => {
                        Err(ValidityError::TransactionInputContainsMessageData { index })
                    }
                    _ => Ok(()),
                }
            })?;

        self.outputs
            .iter()
            .enumerate()
            .try_for_each(|(index, output)| match output {
                Output::Contract(_) => {
                    Err(ValidityError::TransactionOutputContainsContract { index })
                }

                Output::Variable { .. } => {
                    Err(ValidityError::TransactionOutputContainsVariable { index })
                }

                Output::Change { asset_id, .. }
                    if asset_id != consensus_params.base_asset_id() =>
                {
                    Err(ValidityError::TransactionChangeChangeUsesNotBaseAsset { index })
                }

                Output::ContractCreated { .. } => {
                    Err(ValidityError::TransactionOutputContainsContractCreated { index })
                }
                _ => Ok(()),
            })?;

        Ok(())
    }
}

impl crate::Cacheable for Upload {
    fn is_computed(&self) -> bool {
        self.metadata.is_some()
    }

    fn precompute(&mut self, chain_id: &ChainId) -> Result<(), ValidityError> {
        self.metadata = None;
        self.metadata = Some(ChargeableMetadata {
            common: CommonMetadata::compute(self, chain_id)?,
            body: UploadMetadata {},
        });
        Ok(())
    }
}

mod field {
    use super::*;
    use crate::field::{
        BytecodeRoot,
        BytecodeWitnessIndex,
        ChargeableBody,
        ProofSet,
        SubsectionIndex,
        SubsectionsNumber,
    };

    impl BytecodeRoot for Upload {
        #[inline(always)]
        fn bytecode_root(&self) -> &Bytes32 {
            &self.body.root
        }

        #[inline(always)]
        fn bytecode_root_mut(&mut self) -> &mut Bytes32 {
            &mut self.body.root
        }

        #[inline(always)]
        fn bytecode_root_offset_static() -> usize {
            WORD_SIZE // `Transaction` enum discriminant
        }
    }

    impl BytecodeWitnessIndex for Upload {
        #[inline(always)]
        fn bytecode_witness_index(&self) -> &u16 {
            &self.body.witness_index
        }

        #[inline(always)]
        fn bytecode_witness_index_mut(&mut self) -> &mut u16 {
            &mut self.body.witness_index
        }

        #[inline(always)]
        fn bytecode_witness_index_offset_static() -> usize {
            Self::bytecode_root_offset_static().saturating_add(Bytes32::LEN)
        }
    }

    impl SubsectionIndex for Upload {
        #[inline(always)]
        fn subsection_index(&self) -> &u16 {
            &self.body.subsection_index
        }

        #[inline(always)]
        fn subsection_index_mut(&mut self) -> &mut u16 {
            &mut self.body.subsection_index
        }

        #[inline(always)]
        fn subsection_index_offset_static() -> usize {
            Self::bytecode_witness_index_offset_static().saturating_add(WORD_SIZE)
        }
    }

    impl SubsectionsNumber for Upload {
        #[inline(always)]
        fn subsections_number(&self) -> &u16 {
            &self.body.subsections_number
        }

        #[inline(always)]
        fn subsections_number_mut(&mut self) -> &mut u16 {
            &mut self.body.subsections_number
        }

        #[inline(always)]
        fn subsections_number_offset_static() -> usize {
            Self::subsection_index_offset_static().saturating_add(WORD_SIZE)
        }
    }

    impl ProofSet for Upload {
        #[inline(always)]
        fn proof_set(&self) -> &Vec<Bytes32> {
            &self.body.proof_set
        }

        #[inline(always)]
        fn proof_set_mut(&mut self) -> &mut Vec<Bytes32> {
            &mut self.body.proof_set
        }

        #[inline(always)]
        fn proof_set_offset_static() -> usize {
            Self::subsections_number_offset_static().saturating_add(
                WORD_SIZE
                + WORD_SIZE // Proof set size
                + WORD_SIZE // Policies size
                + WORD_SIZE // Inputs size
                + WORD_SIZE // Outputs size
                + WORD_SIZE, // Witnesses size
            )
        }
    }

    impl ChargeableBody<UploadBody> for Upload {
        fn body(&self) -> &UploadBody {
            &self.body
        }

        fn body_mut(&mut self) -> &mut UploadBody {
            &mut self.body
        }

        fn body_offset_end(&self) -> usize {
            Self::proof_set_offset_static()
                .saturating_add(self.body.proof_set.len().saturating_mul(Bytes32::LEN))
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/chargeable_transaction.rs

Source
use crate::{
    field::ChargeableBody,
    policies::Policies,
    transaction::{
        field::{
            Inputs,
            Outputs,
            Policies as PoliciesField,
            Witnesses,
        },
        id::PrepareSign,
        metadata::CommonMetadata,
        validity::{
            check_common_part,
            FormatValidityChecks,
        },
        Chargeable,
    },
    ConsensusParameters,
    Input,
    Output,
    UniqueIdentifier,
    ValidityError,
    Witness,
};
use derivative::Derivative;
use fuel_types::{
    bytes,
    canonical::Serialize,
    BlockHeight,
    Bytes32,
    ChainId,
};
use hashbrown::HashMap;

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ChargeableMetadata<Body> {
    pub common: CommonMetadata,
    pub body: Body,
}

#[cfg(feature = "da-compression")]
use fuel_compression::Compressible;

#[cfg(feature = "da-compression")]
pub trait BodyConstraints:
    for<'a> Compressible<
    Compressed: core::fmt::Debug
                    + PartialEq
                    + Clone
                    + serde::Serialize
                    + serde::Deserialize<'a>,
>
{
}

#[cfg(feature = "da-compression")]
impl<T> BodyConstraints for T where
    T: for<'a> Compressible<
        Compressed: core::fmt::Debug
                        + PartialEq
                        + Clone
                        + serde::Serialize
                        + serde::Deserialize<'a>,
    >
{
}

#[cfg(not(feature = "da-compression"))]
pub trait BodyConstraints {}
#[cfg(not(feature = "da-compression"))]
impl<T> BodyConstraints for T {}

#[derive(Clone, Derivative)]
#[derivative(Eq, PartialEq, Hash, Debug)]
#[derive(serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[cfg_attr(feature = "da-compression", compress(discard(MetadataBody)))]
#[derive(fuel_types::canonical::Deserialize, fuel_types::canonical::Serialize)]
pub struct ChargeableTransaction<Body, MetadataBody>
where
    Body: BodyConstraints,
{
    pub(crate) body: Body,
    pub(crate) policies: Policies,
    pub(crate) inputs: Vec<Input>,
    pub(crate) outputs: Vec<Output>,
    pub(crate) witnesses: Vec<Witness>,
    #[serde(skip)]
    #[cfg_attr(feature = "da-compression", compress(skip))]
    #[derivative(PartialEq = "ignore", Hash = "ignore")]
    #[canonical(skip)]
    pub(crate) metadata: Option<ChargeableMetadata<MetadataBody>>,
}

impl<Body, MetadataBody> Default for ChargeableTransaction<Body, MetadataBody>
where
    Body: BodyConstraints + Default,
{
    fn default() -> Self {
        Self {
            body: Default::default(),
            policies: Policies::new()
                .with_maturity(0.into())
                .with_witness_limit(10000),
            inputs: Default::default(),
            outputs: Default::default(),
            witnesses: Default::default(),
            metadata: None,
        }
    }
}

impl<Body, MetadataBody> ChargeableTransaction<Body, MetadataBody>
where
    Body: BodyConstraints,
{
    pub fn metadata(&self) -> &Option<ChargeableMetadata<MetadataBody>> {
        &self.metadata
    }
}

impl<Body, MetadataBody> PrepareSign for ChargeableTransaction<Body, MetadataBody>
where
    Body: BodyConstraints + PrepareSign,
    Self: ChargeableBody<Body>,
{
    fn prepare_sign(&mut self) {
        self.body.prepare_sign();
        self.inputs_mut().iter_mut().for_each(Input::prepare_sign);
        self.outputs_mut().iter_mut().for_each(Output::prepare_sign);
    }
}

impl<Body, MetadataBody> UniqueIdentifier for ChargeableTransaction<Body, MetadataBody>
where
    Body: BodyConstraints + PrepareSign,
    Self: Clone,
    Self: ChargeableBody<Body>,
    Self: fuel_types::canonical::Serialize,
{
    fn id(&self, chain_id: &ChainId) -> Bytes32 {
        if let Some(id) = self.cached_id() {
            return id;
        }

        let mut clone = self.clone();

        // Empties fields that should be zero during the signing.
        clone.prepare_sign();
        clone.witnesses_mut().clear();

        crate::transaction::compute_transaction_id(chain_id, &mut clone)
    }

    fn cached_id(&self) -> Option<Bytes32> {
        self.metadata.as_ref().map(|m| m.common.id)
    }
}

pub(crate) trait UniqueFormatValidityChecks {
    /// Checks unique rules inherited from the `Body` for chargeable transaction.
    fn check_unique_rules(
        &self,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError>;
}

impl<Body, MetadataBody> FormatValidityChecks
    for ChargeableTransaction<Body, MetadataBody>
where
    Body: BodyConstraints + PrepareSign,
    Self: Clone,
    Self: ChargeableBody<Body>,
    Self: fuel_types::canonical::Serialize,
    Self: Chargeable,
    Self: UniqueFormatValidityChecks,
{
    fn check_signatures(&self, chain_id: &ChainId) -> Result<(), ValidityError> {
        let id = self.id(chain_id);

        // There will be at most len(witnesses) signatures to cache
        let mut recovery_cache = Some(HashMap::with_capacity(self.witnesses().len()));

        self.inputs()
            .iter()
            .enumerate()
            .try_for_each(|(index, input)| {
                input.check_signature(index, &id, self.witnesses(), &mut recovery_cache)
            })?;

        Ok(())
    }

    fn check_without_signatures(
        &self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<(), ValidityError> {
        check_common_part(self, block_height, consensus_params)?;
        self.check_unique_rules(consensus_params)?;

        Ok(())
    }
}

mod field {
    use super::*;
    use crate::field::ChargeableBody;

    impl<Body, MetadataBody> PoliciesField for ChargeableTransaction<Body, MetadataBody>
    where
        Body: BodyConstraints,
        Self: ChargeableBody<Body>,
    {
        #[inline(always)]
        fn policies(&self) -> &Policies {
            &self.policies
        }

        #[inline(always)]
        fn policies_mut(&mut self) -> &mut Policies {
            &mut self.policies
        }

        #[inline(always)]
        fn policies_offset(&self) -> usize {
            self.body_offset_end()
        }
    }

    impl<Body, MetadataBody> Inputs for ChargeableTransaction<Body, MetadataBody>
    where
        Body: BodyConstraints,
        Self: ChargeableBody<Body>,
    {
        #[inline(always)]
        fn inputs(&self) -> &Vec<Input> {
            &self.inputs
        }

        #[inline(always)]
        fn inputs_mut(&mut self) -> &mut Vec<Input> {
            &mut self.inputs
        }

        #[inline(always)]
        fn inputs_offset(&self) -> usize {
            if let Some(ChargeableMetadata {
                common: CommonMetadata { inputs_offset, .. },
                ..
            }) = &self.metadata
            {
                return *inputs_offset;
            }

            self.policies_offset()
                .saturating_add(self.policies.size_dynamic())
        }

        #[inline(always)]
        fn inputs_offset_at(&self, idx: usize) -> Option<usize> {
            if let Some(ChargeableMetadata {
                common:
                    CommonMetadata {
                        inputs_offset_at, ..
                    },
                ..
            }) = &self.metadata
            {
                return inputs_offset_at.get(idx).cloned();
            }

            if idx < self.inputs.len() {
                Some(
                    self.inputs_offset().saturating_add(
                        self.inputs()
                            .iter()
                            .take(idx)
                            .map(|i| i.size())
                            .reduce(usize::saturating_add)
                            .unwrap_or_default(),
                    ),
                )
            } else {
                None
            }
        }

        #[inline(always)]
        fn inputs_predicate_offset_at(&self, idx: usize) -> Option<(usize, usize)> {
            if let Some(ChargeableMetadata {
                common:
                    CommonMetadata {
                        inputs_predicate_offset_at,
                        ..
                    },
                ..
            }) = &self.metadata
            {
                return inputs_predicate_offset_at.get(idx).cloned().unwrap_or(None);
            }

            self.inputs().get(idx).and_then(|input| {
                input
                    .predicate_offset()
                    .and_then(|predicate| {
                        self.inputs_offset_at(idx)
                            .map(|inputs| inputs.saturating_add(predicate))
                    })
                    .zip(input.predicate_len().and_then(bytes::padded_len_usize))
            })
        }
    }

    impl<Body, MetadataBody> Outputs for ChargeableTransaction<Body, MetadataBody>
    where
        Body: BodyConstraints,
        Self: ChargeableBody<Body>,
    {
        #[inline(always)]
        fn outputs(&self) -> &Vec<Output> {
            &self.outputs
        }

        #[inline(always)]
        fn outputs_mut(&mut self) -> &mut Vec<Output> {
            &mut self.outputs
        }

        #[inline(always)]
        fn outputs_offset(&self) -> usize {
            if let Some(ChargeableMetadata {
                common: CommonMetadata { outputs_offset, .. },
                ..
            }) = &self.metadata
            {
                return *outputs_offset;
            }

            self.inputs_offset().saturating_add(
                self.inputs()
                    .iter()
                    .map(|i| i.size())
                    .reduce(usize::saturating_add)
                    .unwrap_or_default(),
            )
        }

        #[inline(always)]
        fn outputs_offset_at(&self, idx: usize) -> Option<usize> {
            if let Some(ChargeableMetadata {
                common:
                    CommonMetadata {
                        outputs_offset_at, ..
                    },
                ..
            }) = &self.metadata
            {
                return outputs_offset_at.get(idx).cloned();
            }

            if idx < self.outputs.len() {
                Some(
                    self.outputs_offset().saturating_add(
                        self.outputs()
                            .iter()
                            .take(idx)
                            .map(|i| i.size())
                            .reduce(usize::saturating_add)
                            .unwrap_or_default(),
                    ),
                )
            } else {
                None
            }
        }
    }

    impl<Body, MetadataBody> Witnesses for ChargeableTransaction<Body, MetadataBody>
    where
        Body: BodyConstraints,
        Self: ChargeableBody<Body>,
    {
        #[inline(always)]
        fn witnesses(&self) -> &Vec<Witness> {
            &self.witnesses
        }

        #[inline(always)]
        fn witnesses_mut(&mut self) -> &mut Vec<Witness> {
            &mut self.witnesses
        }

        #[inline(always)]
        fn witnesses_offset(&self) -> usize {
            if let Some(ChargeableMetadata {
                common:
                    CommonMetadata {
                        witnesses_offset, ..
                    },
                ..
            }) = &self.metadata
            {
                return *witnesses_offset;
            }

            self.outputs_offset().saturating_add(
                self.outputs()
                    .iter()
                    .map(|i| i.size())
                    .reduce(usize::saturating_add)
                    .unwrap_or_default(),
            )
        }

        #[inline(always)]
        fn witnesses_offset_at(&self, idx: usize) -> Option<usize> {
            if let Some(ChargeableMetadata {
                common:
                    CommonMetadata {
                        witnesses_offset_at,
                        ..
                    },
                ..
            }) = &self.metadata
            {
                return witnesses_offset_at.get(idx).cloned();
            }

            if idx < self.witnesses.len() {
                Some(
                    self.witnesses_offset().saturating_add(
                        self.witnesses()
                            .iter()
                            .take(idx)
                            .map(|i| i.size())
                            .reduce(usize::saturating_add)
                            .unwrap_or_default(),
                    ),
                )
            } else {
                None
            }
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/types/output.rs

Source
use fuel_crypto::Hasher;
use fuel_types::{
    canonical::{
        self,
        Serialize as _,
    },
    Address,
    AssetId,
    Bytes32,
    ContractId,
    Nonce,
    Word,
};

mod consts;
pub mod contract;
mod repr;

use contract::Contract;
pub use repr::OutputRepr;

#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    Hash,
    strum_macros::EnumCount,
    serde::Serialize,
    serde::Deserialize,
)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(canonical::Deserialize, canonical::Serialize)]
pub enum Output {
    Coin {
        to: Address,
        amount: Word,
        asset_id: AssetId,
    },

    Contract(Contract),

    Change {
        to: Address,
        #[cfg_attr(feature = "da-compression", compress(skip))]
        amount: Word,
        asset_id: AssetId,
    },

    Variable {
        #[cfg_attr(feature = "da-compression", compress(skip))]
        to: Address,
        #[cfg_attr(feature = "da-compression", compress(skip))]
        amount: Word,
        #[cfg_attr(feature = "da-compression", compress(skip))]
        asset_id: AssetId,
    },

    ContractCreated {
        contract_id: ContractId,
        state_root: Bytes32,
    },
}

impl Default for Output {
    fn default() -> Self {
        Self::ContractCreated {
            contract_id: Default::default(),
            state_root: Default::default(),
        }
    }
}

impl Output {
    pub const fn repr(&self) -> OutputRepr {
        OutputRepr::from_output(self)
    }

    pub const fn coin(to: Address, amount: Word, asset_id: AssetId) -> Self {
        Self::Coin {
            to,
            amount,
            asset_id,
        }
    }

    pub const fn contract(
        input_index: u16,
        balance_root: Bytes32,
        state_root: Bytes32,
    ) -> Self {
        Self::Contract(Contract {
            input_index,
            balance_root,
            state_root,
        })
    }

    pub const fn change(to: Address, amount: Word, asset_id: AssetId) -> Self {
        Self::Change {
            to,
            amount,
            asset_id,
        }
    }

    pub const fn variable(to: Address, amount: Word, asset_id: AssetId) -> Self {
        Self::Variable {
            to,
            amount,
            asset_id,
        }
    }

    pub const fn contract_created(contract_id: ContractId, state_root: Bytes32) -> Self {
        Self::ContractCreated {
            contract_id,
            state_root,
        }
    }

    pub const fn asset_id(&self) -> Option<&AssetId> {
        match self {
            Output::Coin { asset_id, .. }
            | Output::Change { asset_id, .. }
            | Output::Variable { asset_id, .. } => Some(asset_id),
            _ => None,
        }
    }

    pub const fn to(&self) -> Option<&Address> {
        match self {
            Output::Coin { to, .. }
            | Output::Change { to, .. }
            | Output::Variable { to, .. } => Some(to),
            _ => None,
        }
    }

    pub const fn amount(&self) -> Option<Word> {
        match self {
            Output::Coin { amount, .. }
            | Output::Change { amount, .. }
            | Output::Variable { amount, .. } => Some(*amount),
            _ => None,
        }
    }

    pub const fn input_index(&self) -> Option<u16> {
        match self {
            Output::Contract(Contract { input_index, .. }) => Some(*input_index),
            _ => None,
        }
    }

    pub const fn balance_root(&self) -> Option<&Bytes32> {
        match self {
            Output::Contract(Contract { balance_root, .. }) => Some(balance_root),
            _ => None,
        }
    }

    pub const fn state_root(&self) -> Option<&Bytes32> {
        match self {
            Output::Contract(Contract { state_root, .. })
            | Output::ContractCreated { state_root, .. } => Some(state_root),
            _ => None,
        }
    }

    pub const fn contract_id(&self) -> Option<&ContractId> {
        match self {
            Output::ContractCreated { contract_id, .. } => Some(contract_id),
            _ => None,
        }
    }

    pub const fn is_coin(&self) -> bool {
        matches!(self, Self::Coin { .. })
    }

    pub const fn is_change(&self) -> bool {
        matches!(self, Self::Change { .. })
    }

    pub const fn is_variable(&self) -> bool {
        matches!(self, Self::Variable { .. })
    }

    pub const fn is_contract(&self) -> bool {
        matches!(self, Self::Contract(_))
    }

    pub const fn is_contract_created(&self) -> bool {
        matches!(self, Self::ContractCreated { .. })
    }

    pub fn message_nonce(txid: &Bytes32, idx: Word) -> Nonce {
        (*Hasher::default()
            .chain(txid)
            .chain(idx.to_bytes())
            .finalize())
        .into()
    }

    pub fn message_digest(data: &[u8]) -> Bytes32 {
        Hasher::hash(data)
    }

    /// Empties fields that should be zero during the signing.
    pub fn prepare_sign(&mut self) {
        match self {
            Output::Contract(contract) => contract.prepare_sign(),

            Output::Change { amount, .. } => {
                *amount = 0;
            }

            Output::Variable {
                to,
                amount,
                asset_id,
                ..
            } => {
                *to = Address::default();
                *amount = 0;
                *asset_id = AssetId::default();
            }

            _ => (),
        }
    }

    /// Prepare the output for VM initialization for script execution
    /// or predicate verification
    pub fn prepare_init_execute(&mut self) {
        self.prepare_sign() // Currently does the same thing
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use super::*;

    use fuel_types::{
        Address,
        AssetId,
        Bytes32,
        Word,
    };

    use alloc::{
        boxed::Box,
        format,
        string::String,
        vec::Vec,
    };

    #[derive(Clone, Eq, Hash, PartialEq, serde::Serialize, serde::Deserialize)]
    #[wasm_bindgen]
    pub struct Output(#[wasm_bindgen(skip)] pub Box<crate::Output>);

    #[wasm_bindgen]
    impl Output {
        #[wasm_bindgen(js_name = toJSON)]
        pub fn to_json(&self) -> String {
            serde_json::to_string(&self.0).expect("unable to json format")
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:?}", self.0)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            self.0.to_bytes()
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<Output, js_sys::Error> {
            use fuel_types::canonical::Deserialize;
            crate::Output::from_bytes(value)
                .map(|v| Output(Box::new(v)))
                .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
        }

        #[wasm_bindgen]
        pub fn coin(to: Address, amount: Word, asset_id: AssetId) -> Output {
            Output(Box::new(crate::Output::coin(to, amount, asset_id)))
        }

        #[wasm_bindgen]
        pub fn contract(
            input_index: u16,
            balance_root: Bytes32,
            state_root: Bytes32,
        ) -> Output {
            Output(Box::new(crate::Output::contract(
                input_index,
                balance_root,
                state_root,
            )))
        }

        #[wasm_bindgen]
        pub fn change(to: Address, amount: Word, asset_id: AssetId) -> Output {
            Output(Box::new(crate::Output::change(to, amount, asset_id)))
        }

        #[wasm_bindgen]
        pub fn variable(to: Address, amount: Word, asset_id: AssetId) -> Output {
            Output(Box::new(crate::Output::variable(to, amount, asset_id)))
        }

        #[wasm_bindgen]
        pub fn contract_created(contract_id: ContractId, state_root: Bytes32) -> Output {
            Output(Box::new(crate::Output::contract_created(
                contract_id,
                state_root,
            )))
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/transaction/consensus_parameters.rs

Source
use fuel_types::{
    bytes::WORD_SIZE,
    Address,
    AssetId,
    Bytes32,
    ChainId,
};

pub mod gas;

pub use gas::{
    DependentCost,
    GasCostNotDefined,
    GasCosts,
    GasCostsValues,
};

use crate::consts::BALANCE_ENTRY_SIZE;

#[cfg(feature = "test-helpers")]
const MAX_GAS: u64 = 100_000_000;
#[cfg(feature = "test-helpers")]
const MAX_SIZE: u64 = 110 * 1024;

#[derive(Debug, derive_more::Display)]
#[display(fmt = "setting block transaction size limit is not supported")]
pub struct SettingBlockTransactionSizeLimitNotSupported;
#[cfg(feature = "std")]
impl std::error::Error for SettingBlockTransactionSizeLimitNotSupported {}

/// A versioned set of consensus parameters.
#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub enum ConsensusParameters {
    /// Version 1 of the consensus parameters
    V1(ConsensusParametersV1),
    V2(ConsensusParametersV2),
}

#[cfg(feature = "test-helpers")]
impl Default for ConsensusParameters {
    fn default() -> Self {
        Self::standard()
    }
}

impl ConsensusParameters {
    #[cfg(feature = "test-helpers")]
    /// Constructor for the `ConsensusParameters` with Standard values.
    pub fn standard() -> Self {
        ConsensusParametersV2::standard().into()
    }

    #[cfg(feature = "test-helpers")]
    /// Constructor for the `ConsensusParameters` with Standard values around `ChainId`.
    pub fn standard_with_id(chain_id: ChainId) -> Self {
        ConsensusParametersV2::standard_with_id(chain_id).into()
    }

    /// Constructor for the `ConsensusParameters`
    pub const fn new(
        tx_params: TxParameters,
        predicate_params: PredicateParameters,
        script_params: ScriptParameters,
        contract_params: ContractParameters,
        fee_params: FeeParameters,
        chain_id: ChainId,
        gas_costs: GasCosts,
        base_asset_id: AssetId,
        block_gas_limit: u64,
        block_transaction_size_limit: u64,
        privileged_address: Address,
    ) -> Self {
        Self::V2(ConsensusParametersV2 {
            tx_params,
            predicate_params,
            script_params,
            contract_params,
            fee_params,
            chain_id,
            gas_costs,
            base_asset_id,
            block_gas_limit,
            block_transaction_size_limit,
            privileged_address,
        })
    }

    /// Get the transaction parameters
    pub const fn tx_params(&self) -> &TxParameters {
        match self {
            Self::V1(params) => &params.tx_params,
            Self::V2(params) => &params.tx_params,
        }
    }

    /// Get the predicate parameters
    pub const fn predicate_params(&self) -> &PredicateParameters {
        match self {
            Self::V1(params) => &params.predicate_params,
            Self::V2(params) => &params.predicate_params,
        }
    }

    /// Get the script parameters
    pub const fn script_params(&self) -> &ScriptParameters {
        match self {
            Self::V1(params) => &params.script_params,
            Self::V2(params) => &params.script_params,
        }
    }

    /// Get the contract parameters
    pub const fn contract_params(&self) -> &ContractParameters {
        match self {
            Self::V1(params) => &params.contract_params,
            Self::V2(params) => &params.contract_params,
        }
    }

    /// Get the fee parameters
    pub const fn fee_params(&self) -> &FeeParameters {
        match self {
            Self::V1(params) => &params.fee_params,
            Self::V2(params) => &params.fee_params,
        }
    }

    /// Get the chain ID
    pub const fn chain_id(&self) -> ChainId {
        match self {
            Self::V1(params) => params.chain_id,
            Self::V2(params) => params.chain_id,
        }
    }

    /// Get the gas costs
    pub const fn gas_costs(&self) -> &GasCosts {
        match self {
            Self::V1(params) => &params.gas_costs,
            Self::V2(params) => &params.gas_costs,
        }
    }

    /// Get the base asset ID
    pub const fn base_asset_id(&self) -> &AssetId {
        match self {
            Self::V1(params) => &params.base_asset_id,
            Self::V2(params) => &params.base_asset_id,
        }
    }

    /// Get the block gas limit
    pub const fn block_gas_limit(&self) -> u64 {
        match self {
            Self::V1(params) => params.block_gas_limit,
            Self::V2(params) => params.block_gas_limit,
        }
    }

    /// Get the block transaction size limit
    pub fn block_transaction_size_limit(&self) -> u64 {
        match self {
            Self::V1(_) => {
                // In V1 there was no limit on the transaction size. For the sake of
                // backwards compatibility we allow for a largest limit possible.
                u64::MAX
            }
            Self::V2(params) => params.block_transaction_size_limit,
        }
    }

    /// Get the privileged address
    pub const fn privileged_address(&self) -> &Address {
        match self {
            Self::V1(params) => &params.privileged_address,
            Self::V2(params) => &params.privileged_address,
        }
    }
}

impl ConsensusParameters {
    /// Set the transaction parameters.
    pub fn set_tx_params(&mut self, tx_params: TxParameters) {
        match self {
            Self::V1(params) => params.tx_params = tx_params,
            Self::V2(params) => params.tx_params = tx_params,
        }
    }

    /// Set the predicate parameters.
    pub fn set_predicate_params(&mut self, predicate_params: PredicateParameters) {
        match self {
            Self::V1(params) => params.predicate_params = predicate_params,
            Self::V2(params) => params.predicate_params = predicate_params,
        }
    }

    /// Set the script parameters.
    pub fn set_script_params(&mut self, script_params: ScriptParameters) {
        match self {
            Self::V1(params) => params.script_params = script_params,
            Self::V2(params) => params.script_params = script_params,
        }
    }

    /// Set the contract parameters.
    pub fn set_contract_params(&mut self, contract_params: ContractParameters) {
        match self {
            Self::V1(params) => params.contract_params = contract_params,
            Self::V2(params) => params.contract_params = contract_params,
        }
    }

    /// Set the fee parameters.
    pub fn set_fee_params(&mut self, fee_params: FeeParameters) {
        match self {
            Self::V1(params) => params.fee_params = fee_params,
            Self::V2(params) => params.fee_params = fee_params,
        }
    }

    /// Set the chain ID.
    pub fn set_chain_id(&mut self, chain_id: ChainId) {
        match self {
            Self::V1(params) => params.chain_id = chain_id,
            Self::V2(params) => params.chain_id = chain_id,
        }
    }

    /// Set the gas costs.
    pub fn set_gas_costs(&mut self, gas_costs: GasCosts) {
        match self {
            Self::V1(params) => params.gas_costs = gas_costs,
            Self::V2(params) => params.gas_costs = gas_costs,
        }
    }

    /// Set the base asset ID.
    pub fn set_base_asset_id(&mut self, base_asset_id: AssetId) {
        match self {
            Self::V1(params) => params.base_asset_id = base_asset_id,
            Self::V2(params) => params.base_asset_id = base_asset_id,
        }
    }

    /// Set the block gas limit.
    pub fn set_block_gas_limit(&mut self, block_gas_limit: u64) {
        match self {
            Self::V1(params) => params.block_gas_limit = block_gas_limit,
            Self::V2(params) => params.block_gas_limit = block_gas_limit,
        }
    }

    /// Set the block transaction size limit.
    pub fn set_block_transaction_size_limit(
        &mut self,
        block_transaction_size_limit: u64,
    ) -> Result<(), SettingBlockTransactionSizeLimitNotSupported> {
        match self {
            Self::V1(_) => Err(SettingBlockTransactionSizeLimitNotSupported),
            Self::V2(params) => {
                params.block_transaction_size_limit = block_transaction_size_limit;
                Ok(())
            }
        }
    }

    /// Set the privileged address.
    pub fn set_privileged_address(&mut self, privileged_address: Address) {
        match self {
            Self::V1(params) => params.privileged_address = privileged_address,
            Self::V2(params) => params.privileged_address = privileged_address,
        }
    }
}

/// A collection of parameters for convenience
#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct ConsensusParametersV1 {
    pub tx_params: TxParameters,
    pub predicate_params: PredicateParameters,
    pub script_params: ScriptParameters,
    pub contract_params: ContractParameters,
    pub fee_params: FeeParameters,
    pub chain_id: ChainId,
    pub gas_costs: GasCosts,
    pub base_asset_id: AssetId,
    pub block_gas_limit: u64,
    /// The privileged address(user or predicate) that can perform permissioned
    /// operations(like upgrading the network).
    pub privileged_address: Address,
}

#[cfg(feature = "test-helpers")]
impl ConsensusParametersV1 {
    /// Constructor for the `ConsensusParameters` with Standard values.
    pub fn standard() -> Self {
        Self::standard_with_id(ChainId::default())
    }

    /// Constructor for the `ConsensusParameters` with Standard values around `ChainId`.
    pub fn standard_with_id(chain_id: ChainId) -> Self {
        Self {
            tx_params: TxParameters::DEFAULT,
            predicate_params: PredicateParameters::DEFAULT,
            script_params: ScriptParameters::DEFAULT,
            contract_params: ContractParameters::DEFAULT,
            fee_params: FeeParameters::DEFAULT,
            chain_id,
            gas_costs: GasCosts::default(),
            base_asset_id: Default::default(),
            block_gas_limit: TxParameters::DEFAULT.max_gas_per_tx(),
            privileged_address: Default::default(),
        }
    }
}

#[cfg(feature = "test-helpers")]
impl Default for ConsensusParametersV1 {
    fn default() -> Self {
        Self::standard()
    }
}

impl From<ConsensusParametersV1> for ConsensusParameters {
    fn from(params: ConsensusParametersV1) -> Self {
        Self::V1(params)
    }
}

/// A collection of parameters for convenience
/// The difference with [`ConsensusParametersV1`]:
/// - `block_transaction_size_limit` has been added.
#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
pub struct ConsensusParametersV2 {
    pub tx_params: TxParameters,
    pub predicate_params: PredicateParameters,
    pub script_params: ScriptParameters,
    pub contract_params: ContractParameters,
    pub fee_params: FeeParameters,
    pub chain_id: ChainId,
    pub gas_costs: GasCosts,
    pub base_asset_id: AssetId,
    pub block_gas_limit: u64,
    pub block_transaction_size_limit: u64,
    /// The privileged address(user or predicate) that can perform permissioned
    /// operations(like upgrading the network).
    pub privileged_address: Address,
}

#[cfg(feature = "test-helpers")]
impl ConsensusParametersV2 {
    const DEFAULT_BLOCK_TRANSACTION_SIZE_LIMIT: u64 = 126 * 1024;

    /// Constructor for the `ConsensusParameters` with Standard values.
    pub fn standard() -> Self {
        Self::standard_with_id(ChainId::default())
    }

    /// Constructor for the `ConsensusParameters` with Standard values around `ChainId`.
    pub fn standard_with_id(chain_id: ChainId) -> Self {
        Self {
            tx_params: TxParameters::DEFAULT,
            predicate_params: PredicateParameters::DEFAULT,
            script_params: ScriptParameters::DEFAULT,
            contract_params: ContractParameters::DEFAULT,
            fee_params: FeeParameters::DEFAULT,
            chain_id,
            gas_costs: GasCosts::default(),
            base_asset_id: Default::default(),
            block_gas_limit: TxParameters::DEFAULT.max_gas_per_tx(),
            block_transaction_size_limit: Self::DEFAULT_BLOCK_TRANSACTION_SIZE_LIMIT,
            privileged_address: Default::default(),
        }
    }
}

#[cfg(feature = "test-helpers")]
impl Default for ConsensusParametersV2 {
    fn default() -> Self {
        Self::standard()
    }
}

impl From<ConsensusParametersV2> for ConsensusParameters {
    fn from(params: ConsensusParametersV2) -> Self {
        Self::V2(params)
    }
}

/// The versioned fee parameters.
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum FeeParameters {
    V1(FeeParametersV1),
}

impl FeeParameters {
    #[cfg(feature = "test-helpers")]
    /// Default fee parameters just for testing.
    pub const DEFAULT: Self = Self::V1(FeeParametersV1::DEFAULT);

    /// Replace the gas price factor with the given argument
    pub const fn with_gas_price_factor(self, gas_price_factor: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.gas_price_factor = gas_price_factor;
                Self::V1(params)
            }
        }
    }

    pub const fn with_gas_per_byte(self, gas_per_byte: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.gas_per_byte = gas_per_byte;
                Self::V1(params)
            }
        }
    }
}

impl FeeParameters {
    /// Get the gas price factor
    pub const fn gas_price_factor(&self) -> u64 {
        match self {
            Self::V1(params) => params.gas_price_factor,
        }
    }

    /// Get the gas per byte
    pub const fn gas_per_byte(&self) -> u64 {
        match self {
            Self::V1(params) => params.gas_per_byte,
        }
    }
}

#[cfg(feature = "test-helpers")]
impl Default for FeeParameters {
    fn default() -> Self {
        Self::DEFAULT
    }
}

impl From<FeeParametersV1> for FeeParameters {
    fn from(params: FeeParametersV1) -> Self {
        Self::V1(params)
    }
}

/// Consensus configurable parameters used for verifying transactions
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct FeeParametersV1 {
    /// Factor to convert between gas and transaction assets value.
    pub gas_price_factor: u64,
    /// A fixed ratio linking metered bytes to gas price
    pub gas_per_byte: u64,
}

#[cfg(feature = "test-helpers")]
impl FeeParametersV1 {
    /// Default fee parameters just for tests.
    pub const DEFAULT: Self = FeeParametersV1 {
        gas_price_factor: 1_000_000_000,
        gas_per_byte: 4,
    };
}

#[cfg(feature = "test-helpers")]
impl Default for FeeParametersV1 {
    fn default() -> Self {
        Self::DEFAULT
    }
}

/// Versioned predicate parameters.
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum PredicateParameters {
    V1(PredicateParametersV1),
}

impl PredicateParameters {
    #[cfg(feature = "test-helpers")]
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self::V1(PredicateParametersV1::DEFAULT);

    /// Replace the max predicate length with the given argument
    pub const fn with_max_predicate_length(self, max_predicate_length: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_predicate_length = max_predicate_length;
                Self::V1(params)
            }
        }
    }

    /// Replace the max predicate data length with the given argument
    pub const fn with_max_predicate_data_length(
        self,
        max_predicate_data_length: u64,
    ) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_predicate_data_length = max_predicate_data_length;
                Self::V1(params)
            }
        }
    }

    /// Replace the max message data length with the given argument
    pub const fn with_max_message_data_length(
        self,
        max_message_data_length: u64,
    ) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_message_data_length = max_message_data_length;
                Self::V1(params)
            }
        }
    }

    /// Replace the max gas per predicate.
    pub const fn with_max_gas_per_predicate(self, max_gas_per_predicate: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_gas_per_predicate = max_gas_per_predicate;
                Self::V1(params)
            }
        }
    }
}

impl PredicateParameters {
    /// Get the maximum predicate length
    pub const fn max_predicate_length(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_predicate_length,
        }
    }

    /// Get the maximum predicate data length
    pub const fn max_predicate_data_length(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_predicate_data_length,
        }
    }

    /// Get the maximum message data length
    pub const fn max_message_data_length(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_message_data_length,
        }
    }

    /// Get the maximum gas per predicate
    pub const fn max_gas_per_predicate(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_gas_per_predicate,
        }
    }
}

impl From<PredicateParametersV1> for PredicateParameters {
    fn from(params: PredicateParametersV1) -> Self {
        Self::V1(params)
    }
}

#[cfg(feature = "test-helpers")]
impl Default for PredicateParameters {
    fn default() -> Self {
        Self::DEFAULT
    }
}

/// Consensus configurable parameters used for verifying transactions
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct PredicateParametersV1 {
    /// Maximum length of predicate, in instructions.
    pub max_predicate_length: u64,
    /// Maximum length of predicate data, in bytes.
    pub max_predicate_data_length: u64,
    /// Maximum length of message data, in bytes.
    pub max_message_data_length: u64,
    /// Maximum gas spent per predicate
    pub max_gas_per_predicate: u64,
}

#[cfg(feature = "test-helpers")]
impl PredicateParametersV1 {
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self {
        max_predicate_length: 1024 * 1024,
        max_predicate_data_length: 1024 * 1024,
        max_message_data_length: 1024 * 1024,
        max_gas_per_predicate: MAX_GAS,
    };
}

#[cfg(feature = "test-helpers")]
impl Default for PredicateParametersV1 {
    fn default() -> Self {
        Self::DEFAULT
    }
}

/// Versioned transaction parameters.
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum TxParameters {
    /// Version 1 of the transaction parameters.
    V1(TxParametersV1),
}

impl TxParameters {
    #[cfg(feature = "test-helpers")]
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self::V1(TxParametersV1::DEFAULT);

    /// Transaction memory offset in VM runtime
    pub const fn tx_offset(&self) -> usize {
        let Some(balances_size) =
            (self.max_inputs() as usize).checked_mul(BALANCE_ENTRY_SIZE)
        else {
            panic!(
                "Consensus parameters shouldn't allow max_inputs to cause overflow here"
            );
        };

        balances_size.saturating_add(
            Bytes32::LEN // Tx ID
            + WORD_SIZE // Tx size
            + AssetId::LEN, // Base asset ID
        )
    }

    /// Replace the max inputs with the given argument
    pub const fn with_max_inputs(self, max_inputs: u16) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_inputs = max_inputs;
                Self::V1(params)
            }
        }
    }

    /// Replace the max outputs with the given argument
    pub const fn with_max_outputs(self, max_outputs: u16) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_outputs = max_outputs;
                Self::V1(params)
            }
        }
    }

    /// Replace the max witnesses with the given argument
    pub const fn with_max_witnesses(self, max_witnesses: u32) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_witnesses = max_witnesses;
                Self::V1(params)
            }
        }
    }

    /// Replace the max gas per transaction with the given argument
    pub const fn with_max_gas_per_tx(self, max_gas_per_tx: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_gas_per_tx = max_gas_per_tx;
                Self::V1(params)
            }
        }
    }

    /// Replace the max size of the transaction with the given argument
    pub const fn with_max_size(self, max_size: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_size = max_size;
                Self::V1(params)
            }
        }
    }

    /// Replace the max bytecode subsections with the given argument
    pub const fn with_max_bytecode_subsections(
        self,
        max_bytecode_subsections: u16,
    ) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_bytecode_subsections = max_bytecode_subsections;
                Self::V1(params)
            }
        }
    }
}

impl TxParameters {
    /// Get the maximum number of inputs
    pub const fn max_inputs(&self) -> u16 {
        match self {
            Self::V1(params) => params.max_inputs,
        }
    }

    /// Get the maximum number of outputs
    pub const fn max_outputs(&self) -> u16 {
        match self {
            Self::V1(params) => params.max_outputs,
        }
    }

    /// Get the maximum number of witnesses
    pub const fn max_witnesses(&self) -> u32 {
        match self {
            Self::V1(params) => params.max_witnesses,
        }
    }

    /// Get the maximum gas per transaction
    pub const fn max_gas_per_tx(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_gas_per_tx,
        }
    }

    /// Get the maximum size in bytes
    pub const fn max_size(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_size,
        }
    }

    /// Get the maximum number of bytecode subsections.
    pub const fn max_bytecode_subsections(&self) -> u16 {
        match self {
            Self::V1(params) => params.max_bytecode_subsections,
        }
    }
}

#[cfg(feature = "test-helpers")]
impl Default for TxParameters {
    fn default() -> Self {
        Self::DEFAULT
    }
}

#[cfg(feature = "test-helpers")]
impl TxParameters {
    pub fn set_max_size(&mut self, max_size: u64) {
        match self {
            Self::V1(params) => params.max_size = max_size,
        }
    }
}

impl From<TxParametersV1> for TxParameters {
    fn from(params: TxParametersV1) -> Self {
        Self::V1(params)
    }
}

#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct TxParametersV1 {
    /// Maximum number of inputs.
    pub max_inputs: u16,
    /// Maximum number of outputs.
    pub max_outputs: u16,
    /// Maximum number of witnesses.
    pub max_witnesses: u32,
    /// Maximum gas per transaction.
    pub max_gas_per_tx: u64,
    /// Maximum size in bytes
    pub max_size: u64,
    /// Maximum number of bytecode subsections.
    pub max_bytecode_subsections: u16,
}

#[cfg(feature = "test-helpers")]
impl TxParametersV1 {
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self {
        max_inputs: 255,
        max_outputs: 255,
        max_witnesses: 255,
        max_gas_per_tx: MAX_GAS,
        max_size: MAX_SIZE,
        max_bytecode_subsections: 255,
    };
}

#[cfg(feature = "test-helpers")]
impl Default for TxParametersV1 {
    fn default() -> Self {
        Self::DEFAULT
    }
}

/// Versioned script parameters.
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum ScriptParameters {
    V1(ScriptParametersV1),
}

impl ScriptParameters {
    #[cfg(feature = "test-helpers")]
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self::V1(ScriptParametersV1::DEFAULT);

    /// Replace the max script length with the given argument
    pub const fn with_max_script_length(self, max_script_length: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_script_length = max_script_length;
                Self::V1(params)
            }
        }
    }

    /// Replace the max script data length with the given argument
    pub const fn with_max_script_data_length(self, max_script_data_length: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_script_data_length = max_script_data_length;
                Self::V1(params)
            }
        }
    }
}

impl ScriptParameters {
    /// Get the maximum script length
    pub const fn max_script_length(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_script_length,
        }
    }

    /// Get the maximum script data length
    pub const fn max_script_data_length(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_script_data_length,
        }
    }
}

impl From<ScriptParametersV1> for ScriptParameters {
    fn from(params: ScriptParametersV1) -> Self {
        Self::V1(params)
    }
}

#[cfg(feature = "test-helpers")]
impl Default for ScriptParameters {
    fn default() -> Self {
        Self::DEFAULT
    }
}

#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct ScriptParametersV1 {
    /// Maximum length of script, in instructions.
    pub max_script_length: u64,
    /// Maximum length of script data, in bytes.
    pub max_script_data_length: u64,
}

#[cfg(feature = "test-helpers")]
impl ScriptParametersV1 {
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self {
        max_script_length: 1024 * 1024,
        max_script_data_length: 1024 * 1024,
    };
}

#[cfg(feature = "test-helpers")]
impl Default for ScriptParametersV1 {
    fn default() -> Self {
        Self::DEFAULT
    }
}

/// Versioned contract parameters.
#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub enum ContractParameters {
    V1(ContractParametersV1),
}

impl ContractParameters {
    #[cfg(feature = "test-helpers")]
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self::V1(ContractParametersV1::DEFAULT);

    /// Replace the max contract size with the given argument
    pub const fn with_contract_max_size(self, contract_max_size: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.contract_max_size = contract_max_size;
                Self::V1(params)
            }
        }
    }

    /// Replace the max storage slots with the given argument
    pub const fn with_max_storage_slots(self, max_storage_slots: u64) -> Self {
        match self {
            Self::V1(mut params) => {
                params.max_storage_slots = max_storage_slots;
                Self::V1(params)
            }
        }
    }
}

impl ContractParameters {
    /// Get the maximum contract size
    pub const fn contract_max_size(&self) -> u64 {
        match self {
            Self::V1(params) => params.contract_max_size,
        }
    }

    /// Get the maximum storage slots
    pub const fn max_storage_slots(&self) -> u64 {
        match self {
            Self::V1(params) => params.max_storage_slots,
        }
    }
}

impl From<ContractParametersV1> for ContractParameters {
    fn from(params: ContractParametersV1) -> Self {
        Self::V1(params)
    }
}

#[cfg(feature = "test-helpers")]
impl Default for ContractParameters {
    fn default() -> Self {
        Self::DEFAULT
    }
}

#[derive(
    Copy, Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize,
)]
pub struct ContractParametersV1 {
    /// Maximum contract size, in bytes.
    pub contract_max_size: u64,

    /// Maximum number of initial storage slots.
    pub max_storage_slots: u64,
}

#[cfg(feature = "test-helpers")]
impl ContractParametersV1 {
    /// Default parameters just for testing.
    pub const DEFAULT: Self = Self {
        contract_max_size: 100 * 1024,
        max_storage_slots: 255,
    };
}

#[cfg(feature = "test-helpers")]
impl Default for ContractParametersV1 {
    fn default() -> Self {
        Self::DEFAULT
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use wasm_bindgen::prelude::*;

    use super::{
        PredicateParameters as PredicateParametersRust,
        PredicateParametersV1,
    };

    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
    #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
    pub struct PredicateParameters(alloc::boxed::Box<PredicateParametersRust>);

    impl AsRef<PredicateParametersRust> for PredicateParameters {
        fn as_ref(&self) -> &PredicateParametersRust {
            &self.0
        }
    }

    #[wasm_bindgen]
    impl PredicateParameters {
        #[wasm_bindgen(constructor)]
        pub fn typescript_new(
            max_predicate_length: u64,
            max_predicate_data_length: u64,
            max_message_data_length: u64,
            max_gas_per_predicate: u64,
        ) -> Self {
            let params: PredicateParametersRust = PredicateParametersV1 {
                max_predicate_length,
                max_predicate_data_length,
                max_message_data_length,
                max_gas_per_predicate,
            }
            .into();

            PredicateParameters(params.into())
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::consensus_parameters::{
        ConsensusParametersV2,
        SettingBlockTransactionSizeLimitNotSupported,
    };

    use super::{
        ConsensusParameters,
        ConsensusParametersV1,
    };

    #[test]
    fn error_when_setting_block_size_limit_in_consensus_parameters_v1() {
        let mut consensus_params: ConsensusParameters =
            ConsensusParametersV1::default().into();

        let result = consensus_params.set_block_transaction_size_limit(0);

        assert!(matches!(
            result,
            Err(SettingBlockTransactionSizeLimitNotSupported)
        ))
    }

    #[test]
    fn ok_when_setting_block_size_limit_in_consensus_parameters_v2() {
        let mut consensus_params: ConsensusParameters =
            ConsensusParametersV2::default().into();

        let result = consensus_params.set_block_transaction_size_limit(0);

        assert!(matches!(result, Ok(())))
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/lib.rs

Source
#![cfg_attr(not(feature = "std"), no_std)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::try_err)]
// Wrong clippy convention; check
// https://rust-lang.github.io/api-guidelines/naming.html
#![allow(clippy::wrong_self_convention)]
#![deny(
    clippy::arithmetic_side_effects,
    clippy::cast_sign_loss,
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
    clippy::string_slice
)]
#![deny(unused_crate_dependencies)]
#![deny(unsafe_code)]

// TODO: Add docs

#[cfg(feature = "alloc")]
extern crate alloc;
extern crate core;

pub mod consts;
mod tx_pointer;

pub use fuel_asm::{
    PanicInstruction,
    PanicReason,
};
pub use fuel_types::{
    Address,
    AssetId,
    BlobId,
    Bytes32,
    Bytes4,
    Bytes64,
    Bytes8,
    ContractId,
    MessageId,
    Salt,
    Word,
};
pub use tx_pointer::TxPointer;

#[cfg(feature = "test-helpers")]
mod builder;

#[cfg(feature = "alloc")]
mod contract;

#[cfg(feature = "alloc")]
mod receipt;

#[cfg(feature = "alloc")]
mod transaction;

#[cfg(test)]
mod tests;

#[cfg(feature = "test-helpers")]
pub mod test_helper;

#[cfg(feature = "test-helpers")]
pub use builder::{
    Buildable,
    Finalizable,
    TransactionBuilder,
};

#[cfg(feature = "alloc")]
pub use receipt::{
    Receipt,
    ScriptExecutionResult,
};

#[cfg(feature = "alloc")]
pub use transaction::{
    consensus_parameters,
    field,
    input,
    input::Input,
    input::InputRepr,
    output,
    output::Output,
    output::OutputRepr,
    policies,
    Blob,
    BlobBody,
    BlobIdExt,
    BlobMetadata,
    Cacheable,
    Chargeable,
    ChargeableMetadata,
    ChargeableTransaction,
    ConsensusParameters,
    ContractParameters,
    Create,
    CreateMetadata,
    DependentCost,
    Executable,
    FeeParameters,
    FormatValidityChecks,
    GasCosts,
    GasCostsValues,
    Mint,
    PredicateParameters,
    Script,
    ScriptCode,
    ScriptParameters,
    StorageSlot,
    Transaction,
    TransactionFee,
    TransactionRepr,
    TxId,
    TxParameters,
    Upgrade,
    UpgradeBody,
    UpgradeMetadata,
    UpgradePurpose,
    Upload,
    UploadBody,
    UploadMetadata,
    UploadSubsection,
    UtxoId,
    ValidityError,
    Witness,
};

#[cfg(feature = "da-compression")]
pub use transaction::{
    CompressedMint,
    CompressedTransaction,
    CompressedUtxoId,
};

pub use transaction::{
    PrepareSign,
    Signable,
    UniqueIdentifier,
};

#[cfg(feature = "alloc")]
pub use contract::Contract;

/// Trait extends the functionality of the `ContractId` type.
pub trait ContractIdExt {
    /// Creates an `AssetId` from the `ContractId` and `sub_id`.
    fn asset_id(&self, sub_id: &Bytes32) -> AssetId;

    /// Creates an `AssetId` from the `ContractId` and the default 0x00..000 `sub_id`.
    fn default_asset(&self) -> AssetId;
}

impl ContractIdExt for ContractId {
    fn asset_id(&self, sub_id: &Bytes32) -> AssetId {
        let hasher = fuel_crypto::Hasher::default();
        AssetId::new(
            *hasher
                .chain(self.as_slice())
                .chain(sub_id.as_slice())
                .finalize(),
        )
    }

    fn default_asset(&self) -> AssetId {
        self.asset_id(&Bytes32::zeroed())
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/receipt/receipt_repr.rs

Source
use crate::receipt::Receipt;

macro_rules! enum_from {
    (
        $(#[$meta:meta])* $vis:vis enum $name:ident {
            $($(#[$vmeta:meta])* $vname:ident $(= $val:expr)?,)*
        }
    ) => {
        $(#[$meta])*
        $vis enum $name {
            $($(#[$vmeta])* $vname $(= $val)?,)*
        }

        impl From<&Receipt> for $name {
            fn from(receipt: &Receipt) -> Self {
                match receipt {
                    $(Receipt::$vname { .. } => Self::$vname,)*
                }
            }
        }

        #[cfg(feature = "std")]
        impl TryFrom<fuel_types::Word> for $name {
            type Error = std::io::Error;

            fn try_from(x: fuel_types::Word) -> Result<Self, Self::Error> {
                match x {
                    $(x if x == $name::$vname as fuel_types::Word => Ok($name::$vname),)*
                    _ => Err(std::io::Error::new(
                        std::io::ErrorKind::InvalidData,
                        "The provided identifier is invalid!",
                    )),
                }
            }
        }
    }
}

enum_from! {
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
    pub enum ReceiptRepr {
        Call = 0x00,
        Return = 0x01,
        ReturnData = 0x02,
        Panic = 0x03,
        Revert = 0x04,
        Log = 0x05,
        LogData = 0x06,
        Transfer = 0x07,
        TransferOut = 0x08,
        ScriptResult = 0x09,
        MessageOut = 0x0A,
        Mint = 0x0B,
        Burn = 0x0C,
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/receipt/script_result.rs

Source
use fuel_types::Word;

#[derive(
    Debug,
    Copy,
    Clone,
    PartialEq,
    Eq,
    Hash,
    serde::Serialize,
    serde::Deserialize,
    fuel_types::canonical::Deserialize,
    fuel_types::canonical::Serialize,
)]
#[repr(u64)]
pub enum ScriptExecutionResult {
    Success,
    Revert,
    Panic,
    // Generic failure case since any u64 is valid here
    GenericFailure(u64),
}

impl From<ScriptExecutionResult> for Word {
    fn from(result: ScriptExecutionResult) -> Self {
        match result {
            ScriptExecutionResult::Success => 0x00,
            ScriptExecutionResult::Revert => 0x01,
            ScriptExecutionResult::Panic => 0x02,
            ScriptExecutionResult::GenericFailure(value) => value,
        }
    }
}

impl From<Word> for ScriptExecutionResult {
    fn from(value: u64) -> Self {
        match value {
            0x00 => Self::Success,
            0x01 => Self::Revert,
            0x02 => Self::Panic,
            value => Self::GenericFailure(value),
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/receipt.rs

Source
use crate::Output;
use alloc::vec::Vec;
use derivative::Derivative;
use fuel_asm::PanicInstruction;
use fuel_crypto::Hasher;
use fuel_types::{
    canonical::{
        Deserialize,
        Serialize,
    },
    fmt_option_truncated_hex,
    Address,
    AssetId,
    Bytes32,
    ContractId,
    MessageId,
    Nonce,
    Word,
};

mod receipt_repr;
mod script_result;

use crate::input::message::compute_message_id;
pub use script_result::ScriptExecutionResult;

#[derive(
    Clone, Derivative, serde::Serialize, serde::Deserialize, Deserialize, Serialize,
)]
#[derivative(Eq, PartialEq, Hash, Debug)]
pub enum Receipt {
    Call {
        id: ContractId,
        to: ContractId,
        amount: Word,
        asset_id: AssetId,
        gas: Word,
        param1: Word,
        param2: Word,
        pc: Word,
        is: Word,
    },

    Return {
        id: ContractId,
        val: Word,
        pc: Word,
        is: Word,
    },

    ReturnData {
        id: ContractId,
        ptr: Word,
        len: Word,
        digest: Bytes32,
        pc: Word,
        is: Word,
        #[derivative(Debug(format_with = "fmt_option_truncated_hex::<16>"))]
        #[derivative(PartialEq = "ignore", Hash = "ignore")]
        #[canonical(skip)]
        data: Option<Vec<u8>>,
    },

    Panic {
        id: ContractId,
        reason: PanicInstruction,
        pc: Word,
        is: Word,
        #[derivative(PartialEq = "ignore", Hash = "ignore")]
        #[canonical(skip)]
        contract_id: Option<ContractId>,
    },

    Revert {
        id: ContractId,
        ra: Word,
        pc: Word,
        is: Word,
    },

    Log {
        id: ContractId,
        ra: Word,
        rb: Word,
        rc: Word,
        rd: Word,
        pc: Word,
        is: Word,
    },

    LogData {
        id: ContractId,
        ra: Word,
        rb: Word,
        ptr: Word,
        len: Word,
        digest: Bytes32,
        pc: Word,
        is: Word,
        #[derivative(Debug(format_with = "fmt_option_truncated_hex::<16>"))]
        #[derivative(PartialEq = "ignore", Hash = "ignore")]
        #[canonical(skip)]
        data: Option<Vec<u8>>,
    },

    Transfer {
        id: ContractId,
        to: ContractId,
        amount: Word,
        asset_id: AssetId,
        pc: Word,
        is: Word,
    },

    TransferOut {
        id: ContractId,
        to: Address,
        amount: Word,
        asset_id: AssetId,
        pc: Word,
        is: Word,
    },

    ScriptResult {
        result: ScriptExecutionResult,
        gas_used: Word,
    },

    MessageOut {
        sender: Address,
        recipient: Address,
        amount: Word,
        nonce: Nonce,
        len: Word,
        digest: Bytes32,
        #[derivative(Debug(format_with = "fmt_option_truncated_hex::<16>"))]
        #[derivative(PartialEq = "ignore", Hash = "ignore")]
        #[canonical(skip)]
        data: Option<Vec<u8>>,
    },
    Mint {
        sub_id: Bytes32,
        contract_id: ContractId,
        val: Word,
        pc: Word,
        is: Word,
    },
    Burn {
        sub_id: Bytes32,
        contract_id: ContractId,
        val: Word,
        pc: Word,
        is: Word,
    },
}

impl Receipt {
    pub const fn call(
        id: ContractId,
        to: ContractId,
        amount: Word,
        asset_id: AssetId,
        gas: Word,
        param1: Word,
        param2: Word,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::Call {
            id,
            to,
            amount,
            asset_id,
            gas,
            param1,
            param2,
            pc,
            is,
        }
    }

    // return keyword is reserved
    pub const fn ret(id: ContractId, val: Word, pc: Word, is: Word) -> Self {
        Self::Return { id, val, pc, is }
    }

    pub fn return_data(
        id: ContractId,
        ptr: Word,
        pc: Word,
        is: Word,
        data: Vec<u8>,
    ) -> Self {
        let digest = Hasher::hash(&data);
        Self::return_data_with_len(
            id,
            ptr,
            data.len() as Word,
            digest,
            pc,
            is,
            Some(data),
        )
    }

    pub const fn return_data_with_len(
        id: ContractId,
        ptr: Word,
        len: Word,
        digest: Bytes32,
        pc: Word,
        is: Word,
        data: Option<Vec<u8>>,
    ) -> Self {
        Self::ReturnData {
            id,
            ptr,
            len,
            digest,
            pc,
            is,
            data,
        }
    }

    pub const fn panic(
        id: ContractId,
        reason: PanicInstruction,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::Panic {
            id,
            reason,
            pc,
            is,
            contract_id: None,
        }
    }

    pub fn with_panic_contract_id(mut self, _contract_id: Option<ContractId>) -> Self {
        if let Receipt::Panic {
            ref mut contract_id,
            ..
        } = self
        {
            *contract_id = _contract_id;
        }
        self
    }

    pub const fn revert(id: ContractId, ra: Word, pc: Word, is: Word) -> Self {
        Self::Revert { id, ra, pc, is }
    }

    pub const fn log(
        id: ContractId,
        ra: Word,
        rb: Word,
        rc: Word,
        rd: Word,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::Log {
            id,
            ra,
            rb,
            rc,
            rd,
            pc,
            is,
        }
    }

    pub fn log_data(
        id: ContractId,
        ra: Word,
        rb: Word,
        ptr: Word,
        pc: Word,
        is: Word,
        data: Vec<u8>,
    ) -> Self {
        let digest = Hasher::hash(&data);
        Self::log_data_with_len(
            id,
            ra,
            rb,
            ptr,
            data.len() as Word,
            digest,
            pc,
            is,
            Some(data),
        )
    }

    pub const fn log_data_with_len(
        id: ContractId,
        ra: Word,
        rb: Word,
        ptr: Word,
        len: Word,
        digest: Bytes32,
        pc: Word,
        is: Word,
        data: Option<Vec<u8>>,
    ) -> Self {
        Self::LogData {
            id,
            ra,
            rb,
            ptr,
            len,
            digest,
            pc,
            is,
            data,
        }
    }

    pub const fn transfer(
        id: ContractId,
        to: ContractId,
        amount: Word,
        asset_id: AssetId,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::Transfer {
            id,
            to,
            amount,
            asset_id,
            pc,
            is,
        }
    }

    pub const fn transfer_out(
        id: ContractId,
        to: Address,
        amount: Word,
        asset_id: AssetId,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::TransferOut {
            id,
            to,
            amount,
            asset_id,
            pc,
            is,
        }
    }

    pub const fn script_result(result: ScriptExecutionResult, gas_used: Word) -> Self {
        Self::ScriptResult { result, gas_used }
    }

    pub fn message_out(
        txid: &Bytes32,
        idx: Word,
        sender: Address,
        recipient: Address,
        amount: Word,
        data: Vec<u8>,
    ) -> Self {
        let nonce = Output::message_nonce(txid, idx);
        let digest = Output::message_digest(&data);

        Self::message_out_with_len(
            sender,
            recipient,
            amount,
            nonce,
            data.len() as Word,
            digest,
            Some(data),
        )
    }

    pub const fn message_out_with_len(
        sender: Address,
        recipient: Address,
        amount: Word,
        nonce: Nonce,
        len: Word,
        digest: Bytes32,
        data: Option<Vec<u8>>,
    ) -> Self {
        Self::MessageOut {
            sender,
            recipient,
            amount,
            nonce,
            len,
            digest,
            data,
        }
    }

    pub fn mint(
        sub_id: Bytes32,
        contract_id: ContractId,
        val: Word,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::Mint {
            sub_id,
            contract_id,
            val,
            pc,
            is,
        }
    }

    pub fn burn(
        sub_id: Bytes32,
        contract_id: ContractId,
        val: Word,
        pc: Word,
        is: Word,
    ) -> Self {
        Self::Burn {
            sub_id,
            contract_id,
            val,
            pc,
            is,
        }
    }

    #[inline(always)]
    pub fn id(&self) -> Option<&ContractId> {
        trim_contract_id(match self {
            Self::Call { id, .. } => Some(id),
            Self::Return { id, .. } => Some(id),
            Self::ReturnData { id, .. } => Some(id),
            Self::Panic { id, .. } => Some(id),
            Self::Revert { id, .. } => Some(id),
            Self::Log { id, .. } => Some(id),
            Self::LogData { id, .. } => Some(id),
            Self::Transfer { id, .. } => Some(id),
            Self::TransferOut { id, .. } => Some(id),
            Self::ScriptResult { .. } => None,
            Self::MessageOut { .. } => None,
            Self::Mint { contract_id, .. } => Some(contract_id),
            Self::Burn { contract_id, .. } => Some(contract_id),
        })
    }

    pub const fn sub_id(&self) -> Option<&Bytes32> {
        match self {
            Self::Mint { sub_id, .. } => Some(sub_id),
            Self::Burn { sub_id, .. } => Some(sub_id),
            _ => None,
        }
    }

    pub const fn pc(&self) -> Option<Word> {
        match self {
            Self::Call { pc, .. } => Some(*pc),
            Self::Return { pc, .. } => Some(*pc),
            Self::ReturnData { pc, .. } => Some(*pc),
            Self::Panic { pc, .. } => Some(*pc),
            Self::Revert { pc, .. } => Some(*pc),
            Self::Log { pc, .. } => Some(*pc),
            Self::LogData { pc, .. } => Some(*pc),
            Self::Transfer { pc, .. } => Some(*pc),
            Self::TransferOut { pc, .. } => Some(*pc),
            Self::ScriptResult { .. } => None,
            Self::MessageOut { .. } => None,
            Self::Mint { pc, .. } => Some(*pc),
            Self::Burn { pc, .. } => Some(*pc),
        }
    }

    pub const fn is(&self) -> Option<Word> {
        match self {
            Self::Call { is, .. } => Some(*is),
            Self::Return { is, .. } => Some(*is),
            Self::ReturnData { is, .. } => Some(*is),
            Self::Panic { is, .. } => Some(*is),
            Self::Revert { is, .. } => Some(*is),
            Self::Log { is, .. } => Some(*is),
            Self::LogData { is, .. } => Some(*is),
            Self::Transfer { is, .. } => Some(*is),
            Self::TransferOut { is, .. } => Some(*is),
            Self::ScriptResult { .. } => None,
            Self::MessageOut { .. } => None,
            Self::Mint { is, .. } => Some(*is),
            Self::Burn { is, .. } => Some(*is),
        }
    }

    #[inline(always)]
    pub fn to(&self) -> Option<&ContractId> {
        trim_contract_id(match self {
            Self::Call { to, .. } => Some(to),
            Self::Transfer { to, .. } => Some(to),
            _ => None,
        })
    }

    pub const fn to_address(&self) -> Option<&Address> {
        match self {
            Self::TransferOut { to, .. } => Some(to),
            _ => None,
        }
    }

    pub const fn amount(&self) -> Option<Word> {
        match self {
            Self::Call { amount, .. } => Some(*amount),
            Self::Transfer { amount, .. } => Some(*amount),
            Self::TransferOut { amount, .. } => Some(*amount),
            Self::MessageOut { amount, .. } => Some(*amount),
            _ => None,
        }
    }

    pub const fn asset_id(&self) -> Option<&AssetId> {
        match self {
            Self::Call { asset_id, .. } => Some(asset_id),
            Self::Transfer { asset_id, .. } => Some(asset_id),
            Self::TransferOut { asset_id, .. } => Some(asset_id),
            _ => None,
        }
    }

    pub const fn gas(&self) -> Option<Word> {
        match self {
            Self::Call { gas, .. } => Some(*gas),
            _ => None,
        }
    }

    pub const fn param1(&self) -> Option<Word> {
        match self {
            Self::Call { param1, .. } => Some(*param1),
            _ => None,
        }
    }

    pub const fn param2(&self) -> Option<Word> {
        match self {
            Self::Call { param2, .. } => Some(*param2),
            _ => None,
        }
    }

    pub const fn val(&self) -> Option<Word> {
        match self {
            Self::Return { val, .. } => Some(*val),
            Self::Mint { val, .. } => Some(*val),
            Self::Burn { val, .. } => Some(*val),
            _ => None,
        }
    }

    pub const fn ptr(&self) -> Option<Word> {
        match self {
            Self::ReturnData { ptr, .. } => Some(*ptr),
            Self::LogData { ptr, .. } => Some(*ptr),
            _ => None,
        }
    }

    pub const fn len(&self) -> Option<Word> {
        match self {
            Self::ReturnData { len, .. } => Some(*len),
            Self::LogData { len, .. } => Some(*len),
            Self::MessageOut { len, .. } => Some(*len),
            _ => None,
        }
    }

    pub const fn is_empty(&self) -> Option<bool> {
        match self.len() {
            Some(0) => Some(true),
            Some(_) => Some(false),
            None => None,
        }
    }

    pub const fn digest(&self) -> Option<&Bytes32> {
        match self {
            Self::ReturnData { digest, .. } => Some(digest),
            Self::LogData { digest, .. } => Some(digest),
            Self::MessageOut { digest, .. } => Some(digest),
            _ => None,
        }
    }

    pub fn data(&self) -> Option<&[u8]> {
        match self {
            Self::ReturnData { data, .. } => data.as_ref().map(|data| data.as_slice()),
            Self::LogData { data, .. } => data.as_ref().map(|data| data.as_slice()),
            Self::MessageOut { data, .. } => data.as_ref().map(|data| data.as_slice()),
            _ => None,
        }
    }

    pub const fn reason(&self) -> Option<PanicInstruction> {
        match self {
            Self::Panic { reason, .. } => Some(*reason),
            _ => None,
        }
    }

    pub const fn ra(&self) -> Option<Word> {
        match self {
            Self::Revert { ra, .. } => Some(*ra),
            Self::Log { ra, .. } => Some(*ra),
            Self::LogData { ra, .. } => Some(*ra),
            _ => None,
        }
    }

    pub const fn rb(&self) -> Option<Word> {
        match self {
            Self::Log { rb, .. } => Some(*rb),
            Self::LogData { rb, .. } => Some(*rb),
            _ => None,
        }
    }

    pub const fn rc(&self) -> Option<Word> {
        match self {
            Self::Log { rc, .. } => Some(*rc),
            _ => None,
        }
    }

    pub const fn rd(&self) -> Option<Word> {
        match self {
            Self::Log { rd, .. } => Some(*rd),
            _ => None,
        }
    }

    pub const fn result(&self) -> Option<&ScriptExecutionResult> {
        match self {
            Self::ScriptResult { result, .. } => Some(result),
            _ => None,
        }
    }

    pub const fn gas_used(&self) -> Option<Word> {
        match self {
            Self::ScriptResult { gas_used, .. } => Some(*gas_used),
            _ => None,
        }
    }

    pub fn message_id(&self) -> Option<MessageId> {
        match self {
            Self::MessageOut {
                sender,
                recipient,
                amount,
                nonce,
                data,
                ..
            } => data.as_ref().map(|data| {
                compute_message_id(sender, recipient, nonce, *amount, data.as_slice())
            }),
            _ => None,
        }
    }

    pub const fn sender(&self) -> Option<&Address> {
        match self {
            Self::MessageOut { sender, .. } => Some(sender),
            _ => None,
        }
    }

    pub const fn recipient(&self) -> Option<&Address> {
        match self {
            Self::MessageOut { recipient, .. } => Some(recipient),
            _ => None,
        }
    }

    pub const fn nonce(&self) -> Option<&Nonce> {
        match self {
            Self::MessageOut { nonce, .. } => Some(nonce),
            _ => None,
        }
    }

    pub const fn contract_id(&self) -> Option<&ContractId> {
        match self {
            Self::Panic { contract_id, .. } => contract_id.as_ref(),
            _ => None,
        }
    }
}

fn trim_contract_id(id: Option<&ContractId>) -> Option<&ContractId> {
    id.and_then(|id| {
        if id != &ContractId::zeroed() {
            Some(id)
        } else {
            None
        }
    })
}

#[cfg(test)]
mod tests {
    use crate::Receipt;
    use fuel_types::ContractId;

    // TODO: Rewrite the test cases when `Receipt` will have its struct for
    //  each variant. It will allow to use `Default` trait.
    #[rstest::rstest]
    #[case(
        Receipt::Call {
            id: ContractId::from([1; 32]),
            to: Default::default(),
            amount: 0,
            asset_id: Default::default(),
            gas: 0,
            param1: 0,
            param2: 0,
            pc: 0,
            is: 0,
        },
        Some(ContractId::from([1; 32]))
    )]
    #[case(
        Receipt::Call {
            id: ContractId::from([0; 32]),
            to: Default::default(),
            amount: 0,
            asset_id: Default::default(),
            gas: 0,
            param1: 0,
            param2: 0,
            pc: 0,
            is: 0,
        },
        None
    )]
    #[case(
        Receipt::Return {
            id: ContractId::from([2; 32]),
            val: 0,
            pc: 0,
            is: 0,
        },
        Some(ContractId::from([2; 32]))
    )]
    #[case(
        Receipt::Return {
            id: ContractId::from([0; 32]),
            val: 0,
            pc: 0,
            is: 0,
        },
        None
    )]
    fn receipt_id(#[case] receipt: Receipt, #[case] expected_id: Option<ContractId>) {
        assert_eq!(receipt.id(), expected_id.as_ref());
    }

    // TODO: Rewrite the test cases when `Receipt` will have its struct for
    //  each variant. It will allow to use `Default` trait.
    #[rstest::rstest]
    #[case(
        Receipt::Call {
            id: Default::default(),
            to: ContractId::from([1; 32]),
            amount: 0,
            asset_id: Default::default(),
            gas: 0,
            param1: 0,
            param2: 0,
            pc: 0,
            is: 0,
        },
        Some(ContractId::from([1; 32]))
    )]
    #[case(
        Receipt::Call {
            id: Default::default(),
            to: ContractId::from([0; 32]),
            amount: 0,
            asset_id: Default::default(),
            gas: 0,
            param1: 0,
            param2: 0,
            pc: 0,
            is: 0,
        },
        None
    )]
    #[case(
        Receipt::Return {
            id: Default::default(),
            val: 0,
            pc: 0,
            is: 0,
        },
        None
    )]
    fn receipt_to(#[case] receipt: Receipt, #[case] expected_to: Option<ContractId>) {
        assert_eq!(receipt.to(), expected_to.as_ref());
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/test_helper.rs

Source
#![cfg_attr(not(feature = "std"), no_std)]

extern crate alloc;

use fuel_types::bytes;
use rand::{
    CryptoRng,
    Rng,
};

#[cfg(feature = "std")]
pub use use_std::*;

use alloc::vec::Vec;

pub fn generate_nonempty_padded_bytes<R>(rng: &mut R) -> Vec<u8>
where
    R: Rng + CryptoRng,
{
    let len = rng.gen_range(1..512);
    let len = bytes::padded_len_usize(len).unwrap();

    let mut data = alloc::vec![0u8; len];
    rng.fill_bytes(data.as_mut_slice());

    data
}

pub fn generate_bytes<R>(rng: &mut R) -> Vec<u8>
where
    R: Rng + CryptoRng,
{
    let len = rng.gen_range(1..512);

    let mut data = alloc::vec![0u8; len];
    rng.fill_bytes(data.as_mut_slice());

    data
}

#[cfg(feature = "std")]
mod use_std {
    use super::{
        generate_bytes,
        generate_nonempty_padded_bytes,
    };
    use crate::{
        field,
        Blob,
        BlobBody,
        BlobIdExt,
        Buildable,
        ConsensusParameters,
        Contract,
        Create,
        Finalizable,
        Input,
        Mint,
        Output,
        Script,
        Transaction,
        TransactionBuilder,
        Upgrade,
        UpgradePurpose,
        Upload,
        UploadBody,
        UploadSubsection,
    };
    use core::marker::PhantomData;
    use fuel_crypto::{
        Hasher,
        SecretKey,
    };
    use fuel_types::{
        canonical::Deserialize,
        BlobId,
    };
    use rand::{
        distributions::{
            Distribution,
            Uniform,
        },
        rngs::StdRng,
        CryptoRng,
        Rng,
        SeedableRng,
    };
    use strum::EnumCount;

    pub struct TransactionFactory<R, Tx>
    where
        R: Rng + CryptoRng,
    {
        rng: R,
        input_sampler: Uniform<usize>,
        output_sampler: Uniform<usize>,
        marker: PhantomData<Tx>,
    }

    impl<R, Tx> From<R> for TransactionFactory<R, Tx>
    where
        R: Rng + CryptoRng,
    {
        fn from(rng: R) -> Self {
            let input_sampler = Uniform::from(0..Input::COUNT);
            let output_sampler = Uniform::from(0..Output::COUNT);

            // Trick to enforce coverage of all variants in compile-time
            //
            // When and if a new variant is added, this implementation enforces it will be
            // listed here.
            let empty: [u8; 0] = [];
            debug_assert!({
                Input::decode(&mut &empty[..])
                    .map(|i| match i {
                        Input::CoinSigned(_) => (),
                        Input::CoinPredicate(_) => (),
                        Input::Contract(_) => (),
                        Input::MessageCoinSigned(_) => (),
                        Input::MessageCoinPredicate(_) => (),
                        Input::MessageDataSigned(_) => (),
                        Input::MessageDataPredicate(_) => (),
                    })
                    .unwrap_or(());

                Output::decode(&mut &empty[..])
                    .map(|o| match o {
                        Output::Coin { .. } => (),
                        Output::Contract(_) => (),
                        Output::Change { .. } => (),
                        Output::Variable { .. } => (),
                        Output::ContractCreated { .. } => (),
                    })
                    .unwrap_or(());

                Transaction::decode(&mut &empty[..])
                    .map(|t| match t {
                        Transaction::Script(_) => (),
                        Transaction::Create(_) => (),
                        Transaction::Mint(_) => (),
                        Transaction::Upgrade(_) => (),
                        Transaction::Upload(_) => (),
                        Transaction::Blob(_) => (),
                    })
                    .unwrap_or(());

                true
            });

            Self {
                rng,
                input_sampler,
                output_sampler,
                marker: Default::default(),
            }
        }
    }

    impl<Tx> TransactionFactory<StdRng, Tx> {
        pub fn from_seed(seed: u64) -> Self {
            StdRng::seed_from_u64(seed).into()
        }
    }

    impl<R, Tx> TransactionFactory<R, Tx>
    where
        R: Rng + CryptoRng,
        Tx: field::Outputs,
    {
        fn fill_outputs(&mut self, builder: &mut TransactionBuilder<Tx>) {
            let outputs = self.rng.gen_range(0..10);
            for _ in 0..outputs {
                let variant = self.output_sampler.sample(&mut self.rng);

                let output = match variant {
                    0 => Output::coin(self.rng.gen(), self.rng.gen(), self.rng.gen()),
                    1 => Output::contract(self.rng.gen(), self.rng.gen(), self.rng.gen()),
                    2 => Output::change(self.rng.gen(), self.rng.gen(), self.rng.gen()),
                    3 => Output::variable(self.rng.gen(), self.rng.gen(), self.rng.gen()),
                    4 => Output::contract_created(self.rng.gen(), self.rng.gen()),

                    _ => unreachable!(),
                };

                builder.add_output(output);
            }
        }
    }

    impl<R, Tx> TransactionFactory<R, Tx>
    where
        R: Rng + CryptoRng,
        Tx: Buildable,
    {
        fn fill_transaction(
            &mut self,
            builder: &mut TransactionBuilder<Tx>,
        ) -> Vec<SecretKey> {
            let inputs = self.rng.gen_range(0..10);
            let mut input_coin_keys = Vec::with_capacity(10);
            let mut input_message_keys = Vec::with_capacity(10);

            enum MessageType {
                MessageCoin,
                MessageData,
            }

            for _ in 0..inputs {
                let variant = self.input_sampler.sample(&mut self.rng);

                match variant {
                    0 => {
                        let secret = SecretKey::random(&mut self.rng);

                        input_coin_keys.push(secret);
                    }

                    1 => {
                        let predicate = generate_nonempty_padded_bytes(&mut self.rng);
                        let owner = (*Contract::root_from_code(&predicate)).into();

                        let input = Input::coin_predicate(
                            self.rng.gen(),
                            owner,
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                            predicate,
                            generate_bytes(&mut self.rng),
                        );

                        builder.add_input(input);
                    }

                    2 => {
                        let input = Input::contract(
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                        );

                        builder.add_input(input);
                    }

                    3 => {
                        let secret = SecretKey::random(&mut self.rng);

                        input_message_keys.push((MessageType::MessageCoin, secret));
                    }

                    4 => {
                        let predicate = generate_nonempty_padded_bytes(&mut self.rng);
                        let recipient = (*Contract::root_from_code(&predicate)).into();

                        let input = Input::message_coin_predicate(
                            self.rng.gen(),
                            recipient,
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                            predicate,
                            generate_bytes(&mut self.rng),
                        );

                        builder.add_input(input);
                    }

                    5 => {
                        let secret = SecretKey::random(&mut self.rng);

                        input_message_keys.push((MessageType::MessageData, secret));
                    }

                    6 => {
                        let predicate = generate_nonempty_padded_bytes(&mut self.rng);
                        let recipient = (*Contract::root_from_code(&predicate)).into();

                        let input = Input::message_data_predicate(
                            self.rng.gen(),
                            recipient,
                            self.rng.gen(),
                            self.rng.gen(),
                            self.rng.gen(),
                            generate_bytes(&mut self.rng),
                            predicate,
                            generate_bytes(&mut self.rng),
                        );

                        builder.add_input(input);
                    }

                    _ => unreachable!(),
                }
            }

            input_coin_keys.iter().for_each(|k| {
                builder.add_unsigned_coin_input(
                    *k,
                    self.rng.gen(),
                    self.rng.gen(),
                    self.rng.gen(),
                    self.rng.gen(),
                );
            });

            input_message_keys.iter().for_each(|(t, k)| match t {
                MessageType::MessageCoin => {
                    builder.add_unsigned_message_input(
                        *k,
                        self.rng.gen(),
                        self.rng.gen(),
                        self.rng.gen(),
                        vec![],
                    );
                }
                MessageType::MessageData => {
                    builder.add_unsigned_message_input(
                        *k,
                        self.rng.gen(),
                        self.rng.gen(),
                        self.rng.gen(),
                        generate_bytes(&mut self.rng),
                    );
                }
            });

            self.fill_outputs(builder);

            let witnesses = self.rng.gen_range(0..10);
            for _ in 0..witnesses {
                let witness = generate_bytes(&mut self.rng).into();

                builder.add_witness(witness);
            }

            let mut input_keys = input_coin_keys;
            input_keys.extend(input_message_keys.into_iter().map(|(_, k)| k));
            input_keys
        }
    }

    impl<R> TransactionFactory<R, Create>
    where
        R: Rng + CryptoRng,
    {
        pub fn transaction(&mut self) -> Create {
            self.transaction_with_keys().0
        }

        pub fn transaction_with_keys(&mut self) -> (Create, Vec<SecretKey>) {
            let slots = self.rng.gen_range(0..10);
            let mut builder = TransactionBuilder::<Create>::create(
                self.rng.gen(),
                self.rng.gen(),
                (0..slots).map(|_| self.rng.gen()).collect(),
            );

            let keys = self.fill_transaction(&mut builder);
            (builder.finalize(), keys)
        }
    }

    impl<R> TransactionFactory<R, Script>
    where
        R: Rng + CryptoRng,
    {
        pub fn transaction(&mut self) -> Script {
            self.transaction_with_keys().0
        }

        pub fn transaction_with_keys(&mut self) -> (Script, Vec<SecretKey>) {
            let mut builder = TransactionBuilder::<Script>::script(
                generate_bytes(&mut self.rng),
                generate_bytes(&mut self.rng),
            );

            let keys = self.fill_transaction(&mut builder);
            (builder.finalize(), keys)
        }
    }

    impl<R> TransactionFactory<R, Upgrade>
    where
        R: Rng + CryptoRng,
    {
        pub fn transaction(&mut self) -> Upgrade {
            self.transaction_with_keys().0
        }

        pub fn transaction_with_keys(&mut self) -> (Upgrade, Vec<SecretKey>) {
            let variant = self.rng.gen_range(0..UpgradePurpose::COUNT);
            let consensus_params =
                postcard::to_allocvec(&ConsensusParameters::default()).unwrap();
            let checksum = Hasher::hash(consensus_params.as_slice());

            let purpose = match variant {
                0 => UpgradePurpose::StateTransition {
                    root: self.rng.gen(),
                },
                1 => UpgradePurpose::ConsensusParameters {
                    witness_index: 0,
                    checksum,
                },
                _ => {
                    panic!("Not supported")
                }
            };

            let mut builder = TransactionBuilder::<Upgrade>::upgrade(purpose);
            builder.add_witness(consensus_params.into());

            let keys = self.fill_transaction(&mut builder);
            (builder.finalize(), keys)
        }
    }

    impl<R> TransactionFactory<R, Upload>
    where
        R: Rng + CryptoRng,
    {
        pub fn transaction(&mut self) -> Upload {
            self.transaction_with_keys().0
        }

        pub fn transaction_with_keys(&mut self) -> (Upload, Vec<SecretKey>) {
            let len = self.rng.gen_range(1..1024 * 1024);

            let mut bytecode = alloc::vec![0u8; len];
            self.rng.fill_bytes(bytecode.as_mut_slice());

            let subsection = UploadSubsection::split_bytecode(&bytecode, len / 10)
                .expect("Should split the bytecode")[0]
                .clone();

            let mut builder = TransactionBuilder::<Upload>::upload(UploadBody {
                root: subsection.root,
                witness_index: 0,
                subsection_index: subsection.subsection_index,
                subsections_number: subsection.subsections_number,
                proof_set: subsection.proof_set,
            });
            debug_assert_eq!(builder.witnesses().len(), 0);
            builder.add_witness(subsection.subsection.into());

            let keys = self.fill_transaction(&mut builder);
            (builder.finalize(), keys)
        }
    }

    impl<R> TransactionFactory<R, Blob>
    where
        R: Rng + CryptoRng,
    {
        pub fn transaction(&mut self) -> Blob {
            self.transaction_with_keys().0
        }

        pub fn transaction_with_keys(&mut self) -> (Blob, Vec<SecretKey>) {
            let len = self.rng.gen_range(1..1024 * 1024);

            let mut bytecode = alloc::vec![0u8; len];
            self.rng.fill_bytes(bytecode.as_mut_slice());

            let mut builder = TransactionBuilder::<Blob>::blob(BlobBody {
                id: BlobId::compute(&bytecode),
                witness_index: 0,
            });
            debug_assert_eq!(builder.witnesses().len(), 0);
            builder.add_witness(bytecode.into());

            let keys = self.fill_transaction(&mut builder);
            (builder.finalize(), keys)
        }
    }

    impl<R> TransactionFactory<R, Mint>
    where
        R: Rng + CryptoRng,
    {
        pub fn transaction(&mut self) -> Mint {
            let builder = TransactionBuilder::<Mint>::mint(
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
            );

            builder.finalize()
        }
    }

    impl<R> Iterator for TransactionFactory<R, Create>
    where
        R: Rng + CryptoRng,
    {
        type Item = (Create, Vec<SecretKey>);

        fn next(&mut self) -> Option<(Create, Vec<SecretKey>)> {
            Some(self.transaction_with_keys())
        }
    }

    impl<R> Iterator for TransactionFactory<R, Script>
    where
        R: Rng + CryptoRng,
    {
        type Item = (Script, Vec<SecretKey>);

        fn next(&mut self) -> Option<(Script, Vec<SecretKey>)> {
            Some(self.transaction_with_keys())
        }
    }

    impl<R> Iterator for TransactionFactory<R, Upgrade>
    where
        R: Rng + CryptoRng,
    {
        type Item = (Upgrade, Vec<SecretKey>);

        fn next(&mut self) -> Option<(Upgrade, Vec<SecretKey>)> {
            Some(self.transaction_with_keys())
        }
    }

    impl<R> Iterator for TransactionFactory<R, Upload>
    where
        R: Rng + CryptoRng,
    {
        type Item = (Upload, Vec<SecretKey>);

        fn next(&mut self) -> Option<(Upload, Vec<SecretKey>)> {
            Some(self.transaction_with_keys())
        }
    }

    impl<R> Iterator for TransactionFactory<R, Blob>
    where
        R: Rng + CryptoRng,
    {
        type Item = (Blob, Vec<SecretKey>);

        fn next(&mut self) -> Option<(Blob, Vec<SecretKey>)> {
            Some(self.transaction_with_keys())
        }
    }

    impl<R> Iterator for TransactionFactory<R, Mint>
    where
        R: Rng + CryptoRng,
    {
        type Item = Mint;

        fn next(&mut self) -> Option<Mint> {
            Some(self.transaction())
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/contract.rs

Source
use crate::{
    StorageSlot,
    Transaction,
    ValidityError,
};

use derivative::Derivative;
use fuel_crypto::Hasher;
use fuel_merkle::{
    binary::root_calculator::MerkleRootCalculator as BinaryMerkleTree,
    sparse::{
        in_memory::MerkleTree as SparseMerkleTree,
        MerkleTreeKey,
    },
};
use fuel_types::{
    fmt_truncated_hex,
    Bytes32,
    ContractId,
    Salt,
};

use alloc::vec::Vec;
use core::iter;

/// The target size of Merkle tree leaves in bytes. Contract code will will be divided
/// into chunks of this size and pushed to the Merkle tree.
///
/// See https://github.com/FuelLabs/fuel-specs/blob/master/src/identifiers/contract-id.md
const LEAF_SIZE: usize = 16 * 1024;
/// In the event that contract code cannot be divided evenly by the `LEAF_SIZE`, the
/// remainder must be padded to the nearest multiple of 8 bytes. Padding is achieved by
/// repeating the `PADDING_BYTE`.
const PADDING_BYTE: u8 = 0u8;
const MULTIPLE: usize = 8;

#[derive(Default, Derivative, Clone, PartialEq, Eq, Hash)]
#[derivative(Debug)]
#[derive(
    serde::Serialize,
    serde::Deserialize,
    fuel_types::canonical::Deserialize,
    fuel_types::canonical::Serialize,
)]
/// Deployable representation of a contract code.
pub struct Contract(
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))] Vec<u8>,
);

impl Contract {
    /// The `ContractId` of the contract with empty bytecode, zero salt, and empty state
    /// root.
    pub const EMPTY_CONTRACT_ID: ContractId = ContractId::new([
        55, 187, 13, 108, 165, 51, 58, 230, 74, 109, 215, 229, 33, 69, 82, 120, 81, 4,
        85, 54, 172, 30, 84, 115, 226, 164, 0, 99, 103, 189, 154, 243,
    ]);

    /// Number of bytes in the contract's bytecode
    pub fn len(&self) -> usize {
        self.0.len()
    }

    /// Check if the contract's bytecode is empty
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Calculate the code root of the contract, using [`Self::root_from_code`].
    pub fn root(&self) -> Bytes32 {
        Self::root_from_code(self)
    }

    /// Calculate the code root from a contract.
    ///
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/identifiers/contract-id.md>
    pub fn root_from_code<B>(bytes: B) -> Bytes32
    where
        B: AsRef<[u8]>,
    {
        let mut tree = BinaryMerkleTree::new();
        bytes.as_ref().chunks(LEAF_SIZE).for_each(|leaf| {
            // If the bytecode is not a multiple of LEAF_SIZE, the final leaf
            // should be zero-padded rounding up to the nearest multiple of 8
            // bytes.
            let len = leaf.len();
            if len == LEAF_SIZE || len % MULTIPLE == 0 {
                tree.push(leaf);
            } else {
                let padding_size = len.next_multiple_of(MULTIPLE);
                let mut padded_leaf = [PADDING_BYTE; LEAF_SIZE];
                padded_leaf[0..len].clone_from_slice(leaf);
                tree.push(padded_leaf[..padding_size].as_ref());
            }
        });

        tree.root().into()
    }

    /// Calculate the root of the initial storage slots for this contract
    pub fn initial_state_root<'a, I>(storage_slots: I) -> Bytes32
    where
        I: Iterator<Item = &'a StorageSlot>,
    {
        let storage_slots = storage_slots
            .map(|slot| (*slot.key(), slot.value()))
            .map(|(key, data)| (MerkleTreeKey::new(key), data));
        let root = SparseMerkleTree::root_from_set(storage_slots);
        root.into()
    }

    /// The default state root value without any entries
    pub fn default_state_root() -> Bytes32 {
        Self::initial_state_root(iter::empty())
    }

    /// Calculate and return the contract id, provided a salt, code root and state root.
    ///
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/identifiers/contract-id.md>
    pub fn id(&self, salt: &Salt, root: &Bytes32, state_root: &Bytes32) -> ContractId {
        let mut hasher = Hasher::default();

        hasher.input(ContractId::SEED);
        hasher.input(salt);
        hasher.input(root);
        hasher.input(state_root);

        ContractId::from(*hasher.digest())
    }
}

impl From<Vec<u8>> for Contract {
    fn from(c: Vec<u8>) -> Self {
        Self(c)
    }
}

impl From<&[u8]> for Contract {
    fn from(c: &[u8]) -> Self {
        Self(c.into())
    }
}

impl From<&mut [u8]> for Contract {
    fn from(c: &mut [u8]) -> Self {
        Self(c.into())
    }
}

impl From<Contract> for Vec<u8> {
    fn from(c: Contract) -> Vec<u8> {
        c.0
    }
}

impl AsRef<[u8]> for Contract {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl AsMut<[u8]> for Contract {
    fn as_mut(&mut self) -> &mut [u8] {
        self.0.as_mut()
    }
}

impl TryFrom<&Transaction> for Contract {
    type Error = ValidityError;

    fn try_from(tx: &Transaction) -> Result<Self, Self::Error> {
        match tx {
            Transaction::Create(create) => TryFrom::try_from(create),
            _ => {
                Err(ValidityError::TransactionOutputContainsContractCreated { index: 0 })
            }
        }
    }
}

#[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)]
#[cfg(test)]
mod tests {
    use super::*;
    use fuel_types::{
        bytes::WORD_SIZE,
        Bytes64,
    };
    use itertools::Itertools;
    use quickcheck_macros::quickcheck;
    use rand::{
        rngs::StdRng,
        RngCore,
        SeedableRng,
    };
    use rstest::rstest;

    // safe-guard against breaking changes to the code root calculation for valid
    // sizes of bytecode (multiples of instruction size in bytes (half-word))
    #[rstest]
    fn code_root_snapshot(
        #[values(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100)] instructions: usize,
    ) {
        let mut rng = StdRng::seed_from_u64(100);
        let code_len = instructions * WORD_SIZE / 2;
        let mut code = alloc::vec![0u8; code_len];
        rng.fill_bytes(code.as_mut_slice());

        // compute root
        let root = Contract::root_from_code(code);

        // take root snapshot
        insta::with_settings!(
            {snapshot_suffix => format!("instructions-{instructions}")},
            {
                insta::assert_debug_snapshot!(root);
            }
        );
    }

    // validate code_root is always equivalent to contract.root
    #[quickcheck]
    fn contract_root_matches_code_root(instructions: u8) -> bool {
        let mut rng = StdRng::seed_from_u64(100);
        let code_len = instructions as usize * WORD_SIZE / 2;
        let mut code = alloc::vec![0u8; code_len];
        rng.fill_bytes(code.as_mut_slice());
        let contract = Contract::from(code.clone());
        // compute root
        let code_root = Contract::root_from_code(code);
        let contract_root = contract.root();
        code_root == contract_root
    }

    #[rstest]
    fn state_root_snapshot(
        #[values(Vec::new(), vec![Bytes64::new([1u8; 64])])] state_slot_bytes: Vec<
            Bytes64,
        >,
    ) {
        let slots: Vec<StorageSlot> =
            state_slot_bytes.iter().map(Into::into).collect_vec();
        let state_root = Contract::initial_state_root(&mut slots.iter());
        // take root snapshot
        insta::with_settings!(
            {snapshot_suffix => format!("state-root-{}", slots.len())},
            {
                insta::assert_debug_snapshot!(state_root);
            }
        );
    }

    #[test]
    fn default_state_root_snapshot() {
        let default_root = Contract::default_state_root();
        insta::assert_debug_snapshot!(default_root);
    }

    #[test]
    fn multi_leaf_state_root_snapshot() {
        let mut rng = StdRng::seed_from_u64(0xF00D);
        // 5 full leaves and a partial 6th leaf with 4 bytes of data
        let partial_leaf_size = 4;
        let code_len = 5 * LEAF_SIZE + partial_leaf_size;
        let mut code = alloc::vec![0u8; code_len];
        rng.fill_bytes(code.as_mut_slice());

        // compute root
        let root = Contract::root_from_code(code);

        // take root snapshot
        insta::with_settings!(
            {snapshot_suffix => "multi-leaf-state-root"},
            {
                insta::assert_debug_snapshot!(root);
            }
        );
    }

    #[rstest]
    #[case(0)]
    #[case(1)]
    #[case(8)]
    #[case(500)]
    #[case(1000)]
    #[case(1024)]
    #[case(1025)]
    fn partial_leaf_state_root(#[case] partial_leaf_size: usize) {
        let mut rng = StdRng::seed_from_u64(0xF00D);
        let code_len = partial_leaf_size;
        let mut code = alloc::vec![0u8; code_len];
        rng.fill_bytes(code.as_mut_slice());

        // Compute root
        let root = Contract::root_from_code(code.clone());

        // Compute expected root
        let expected_root = {
            let mut tree = BinaryMerkleTree::new();

            // Push partial leaf with manual padding.
            // We start by generating an n-byte array, where n is the code
            // length rounded to the nearest multiple of 8, and each byte is the
            // PADDING_BYTE by default. The leaf is generated by copying the
            // remaining data bytes into the start of this array.
            let sz = partial_leaf_size.next_multiple_of(8);
            if sz > 0 {
                let mut padded_leaf = vec![PADDING_BYTE; sz];
                padded_leaf[0..code_len].clone_from_slice(&code);
                tree.push(&padded_leaf);
            }
            tree.root().into()
        };

        assert_eq!(root, expected_root);
    }

    #[rstest]
    #[case(0)]
    #[case(1)]
    #[case(8)]
    #[case(500)]
    #[case(1000)]
    #[case(1024)]
    #[case(1025)]
    fn multi_leaf_state_root(#[case] partial_leaf_size: usize) {
        let mut rng = StdRng::seed_from_u64(0xF00D);
        // 3 full leaves and a partial 4th leaf
        let code_len = 3 * LEAF_SIZE + partial_leaf_size;
        let mut code = alloc::vec![0u8; code_len];
        rng.fill_bytes(code.as_mut_slice());

        // Compute root
        let root = Contract::root_from_code(code.clone());

        // Compute expected root
        let expected_root = {
            let mut tree = BinaryMerkleTree::new();

            let leaves = code.chunks(LEAF_SIZE).collect::<Vec<_>>();
            tree.push(leaves[0]);
            tree.push(leaves[1]);
            tree.push(leaves[2]);

            // Push partial leaf with manual padding.
            // We start by generating an n-byte array, where n is the code
            // length rounded to the nearest multiple of 8, and each byte is the
            // PADDING_BYTE by default. The leaf is generated by copying the
            // remaining data bytes into the start of this array.
            let sz = partial_leaf_size.next_multiple_of(8);
            if sz > 0 {
                let mut padded_leaf = vec![PADDING_BYTE; sz];
                padded_leaf[0..partial_leaf_size].clone_from_slice(leaves[3]);
                tree.push(&padded_leaf);
            }
            tree.root().into()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn empty_contract_id() {
        let contract = Contract::from(vec![]);
        let salt = Salt::zeroed();
        let root = contract.root();
        let state_root = Contract::default_state_root();

        let calculated_id = contract.id(&salt, &root, &state_root);
        assert_eq!(calculated_id, Contract::EMPTY_CONTRACT_ID)
    }
}

/home/marten/fuel/fuel-vm/fuel-tx/src/tx_pointer.rs

Source
use fuel_types::{
    bytes::WORD_SIZE,
    BlockHeight,
};

use fuel_types::canonical::{
    Deserialize,
    Serialize,
};

use core::{
    fmt,
    str,
};

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

/// Identification of unspend transaction output.
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
#[derive(serde::Serialize, serde::Deserialize)]
#[cfg_attr(
    feature = "da-compression",
    derive(fuel_compression::Compress, fuel_compression::Decompress)
)]
#[derive(Deserialize, Serialize)]
pub struct TxPointer {
    /// Block height
    block_height: BlockHeight,
    /// Transaction index
    tx_index: u16,
}

impl TxPointer {
    pub const LEN: usize = 2 * WORD_SIZE;

    pub const fn new(block_height: BlockHeight, tx_index: u16) -> Self {
        Self {
            block_height,
            tx_index,
        }
    }

    pub const fn block_height(&self) -> BlockHeight {
        self.block_height
    }

    pub const fn tx_index(&self) -> u16 {
        self.tx_index
    }
}

#[cfg(feature = "random")]
impl Distribution<TxPointer> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> TxPointer {
        TxPointer::new(rng.gen(), rng.gen())
    }
}

impl fmt::Display for TxPointer {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::LowerHex::fmt(self, f)
    }
}

impl fmt::LowerHex for TxPointer {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{:08x}{:04x}", self.block_height, self.tx_index)
    }
}

impl fmt::UpperHex for TxPointer {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{:08X}{:04X}", self.block_height, self.tx_index)
    }
}

impl str::FromStr for TxPointer {
    type Err = &'static str;

    /// TxPointer is encoded as 12 hex characters:
    /// - 8 characters for block height
    /// - 4 characters for tx index
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        const ERR: &str = "Invalid encoded byte in TxPointer";

        if s.len() != 12 || !s.is_char_boundary(8) {
            return Err(ERR)
        }

        let (block_height, tx_index) = s.split_at(8);

        let block_height = u32::from_str_radix(block_height, 16).map_err(|_| ERR)?;
        let tx_index = u16::from_str_radix(tx_index, 16).map_err(|_| ERR)?;

        Ok(Self::new(block_height.into(), tx_index))
    }
}

#[cfg(feature = "typescript")]
pub mod typescript {
    use super::*;

    use wasm_bindgen::prelude::*;

    use alloc::{
        format,
        string::String,
        vec::Vec,
    };

    #[wasm_bindgen]
    impl TxPointer {
        #[wasm_bindgen(constructor)]
        pub fn typescript_new(value: &str) -> Result<TxPointer, js_sys::Error> {
            use core::str::FromStr;
            TxPointer::from_str(value).map_err(js_sys::Error::new)
        }

        #[wasm_bindgen(js_name = toString)]
        pub fn typescript_to_string(&self) -> String {
            format!("{:#x}", self)
        }

        #[wasm_bindgen(js_name = to_bytes)]
        pub fn typescript_to_bytes(&self) -> Vec<u8> {
            use fuel_types::canonical::Serialize;
            <Self as Serialize>::to_bytes(self)
        }

        #[wasm_bindgen(js_name = from_bytes)]
        pub fn typescript_from_bytes(value: &[u8]) -> Result<TxPointer, js_sys::Error> {
            use fuel_types::canonical::Deserialize;
            <Self as Deserialize>::from_bytes(value)
                .map_err(|e| js_sys::Error::new(&format!("{:?}", e)))
        }
    }
}

#[test]
fn fmt_encode_decode() {
    use core::str::FromStr;

    let cases = vec![(83473, 3829)];

    for (block_height, tx_index) in cases {
        let tx_pointer = TxPointer::new(block_height.into(), tx_index);

        let lower = format!("{tx_pointer:x}");
        let upper = format!("{tx_pointer:X}");

        assert_eq!(lower, format!("{block_height:08x}{tx_index:04x}"));
        assert_eq!(upper, format!("{block_height:08X}{tx_index:04X}"));

        let x = TxPointer::from_str(&lower).expect("failed to decode from str");
        assert_eq!(tx_pointer, x);

        let x = TxPointer::from_str(&upper).expect("failed to decode from str");
        assert_eq!(tx_pointer, x);

        let bytes = tx_pointer.clone().to_bytes();
        let tx_pointer_p = TxPointer::from_bytes(&bytes).expect("failed to deserialize");

        assert_eq!(tx_pointer, tx_pointer_p);
    }
}

/// See https://github.com/FuelLabs/fuel-vm/issues/521
#[test]
fn decode_bug() {
    use core::str::FromStr;
    TxPointer::from_str("00000😎000").expect_err("Should fail on incorrect input");
}

/home/marten/fuel/fuel-vm/fuel-storage/src/lib.rs

Source
#![no_std]
#![deny(
    clippy::arithmetic_side_effects,
    clippy::cast_sign_loss,
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
    clippy::string_slice
)]
#![deny(unsafe_code)]
#![deny(unused_crate_dependencies)]

mod impls;

extern crate alloc;

use alloc::{
    borrow::{
        Cow,
        ToOwned,
    },
    vec::Vec,
};

/// Merkle root alias type
pub type MerkleRoot = [u8; 32];

/// Mappable type with `Key` and `Value`.
///
/// # Example
///
/// ```rust
/// use fuel_storage::Mappable;
/// pub struct Contract;
///
/// impl Mappable for Contract {
///     /// The `[u8; 32]` is a primitive type, so we can't optimize it more.
///     type Key = Self::OwnedKey;
///     type OwnedKey = [u8; 32];
///     /// It is optimized to use slice instead of vector.
///     type Value = [u8];
///     type OwnedValue = Vec<u8>;
/// }
/// ```
pub trait Mappable {
    /// The key type is used during interaction with the storage. In most cases, it is the
    /// same as `Self::OwnedKey`.
    type Key: ?Sized + ToOwned;
    /// The owned type of the `Key` retrieving from the storage.
    type OwnedKey: From<<Self::Key as ToOwned>::Owned> + Clone;
    /// The value type is used while setting the value to the storage. In most cases, it
    /// is the same as `Self::OwnedValue`, but it is without restriction and can be
    /// used for performance optimizations.
    type Value: ?Sized + ToOwned;
    /// The owned type of the `Value` retrieving from the storage.
    type OwnedValue: From<<Self::Value as ToOwned>::Owned> + Clone;
}

/// Base read storage trait for Fuel infrastructure.
///
/// Generic should implement [`Mappable`] trait with all storage type information.
pub trait StorageInspect<Type: Mappable> {
    type Error;

    /// Retrieve `Cow<Value>` such as `Key->Value`.
    fn get(&self, key: &Type::Key) -> Result<Option<Cow<Type::OwnedValue>>, Self::Error>;

    /// Return `true` if there is a `Key` mapping to a value in the storage.
    fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error>;
}

/// Base storage trait for Fuel infrastructure.
///
/// Generic should implement [`Mappable`] trait with all storage type information.
pub trait StorageMutate<Type: Mappable>: StorageInspect<Type> {
    /// Append `Key->Value` mapping to the storage.
    fn insert(
        &mut self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<(), Self::Error> {
        self.replace(key, value).map(|_| ())
    }

    /// Append `Key->Value` mapping to the storage.
    ///
    /// If `Key` was already mappped to a value, return the replaced value as
    /// `Ok(Some(Value))`. Return `Ok(None)` otherwise.
    fn replace(
        &mut self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<Option<Type::OwnedValue>, Self::Error>;

    /// Remove `Key->Value` mapping from the storage.
    fn remove(&mut self, key: &Type::Key) -> Result<(), Self::Error> {
        self.take(key).map(|_| ())
    }

    /// Remove `Key->Value` mapping from the storage.
    ///
    /// Return `Ok(Some(Value))` if the value was present. If the key wasn't found, return
    /// `Ok(None)`.
    fn take(&mut self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, Self::Error>;
}

/// Base storage trait for Fuel infrastructure.
///
/// Allows checking the size of the value stored at a given key.
/// Checking the size of a value is a cheap operation and should not require
/// copying the value into a buffer.
pub trait StorageSize<Type: Mappable>: StorageInspect<Type> {
    /// Return the number of bytes stored at this key.
    fn size_of_value(&self, key: &Type::Key) -> Result<Option<usize>, Self::Error>;
}

/// Base storage trait for Fuel infrastructure.
///
/// Allows reading the raw bytes of the value stored at a given key
/// into a provided buffer.
///
/// This trait should skip any deserialization and simply copy the raw bytes.
pub trait StorageRead<Type: Mappable>: StorageInspect<Type> + StorageSize<Type> {
    /// Read the value stored at the given key into the provided buffer if the value
    /// exists.
    ///
    /// Does not perform any deserialization.
    ///
    /// Returns None if the value does not exist.
    /// Otherwise, returns the number of bytes read.
    fn read(&self, key: &Type::Key, buf: &mut [u8])
        -> Result<Option<usize>, Self::Error>;

    /// Same as `read` but allocates a new buffer and returns it.
    ///
    /// Checks the size of the value and allocates a buffer of that size.
    fn read_alloc(&self, key: &Type::Key) -> Result<Option<Vec<u8>>, Self::Error>;
}

/// Base storage trait for Fuel infrastructure.
///
/// Allows writing the raw bytes of the value stored to a given key
/// from a provided buffer.
///
/// This trait should skip any serialization and simply copy the raw bytes
/// to the storage.
pub trait StorageWrite<Type: Mappable>: StorageMutate<Type> {
    /// Write the bytes to the given key from the provided buffer.
    ///
    /// Does not perform any serialization.
    ///
    /// Returns the number of bytes written.
    fn write_bytes(&mut self, key: &Type::Key, buf: &[u8]) -> Result<usize, Self::Error>;

    /// Write the bytes to the given key from the provided buffer and
    /// return the previous bytes if it existed.
    ///
    /// Does not perform any serialization.
    ///
    /// Returns the number of bytes written and the previous value if it existed.
    fn replace_bytes(
        &mut self,
        key: &Type::Key,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error>;

    /// Removes a bytes from the storage and returning it without deserializing it.
    fn take_bytes(&mut self, key: &Type::Key) -> Result<Option<Vec<u8>>, Self::Error>;
}

/// Returns the merkle root for the `StorageType` per merkle `Key`. Per one storage, it is
/// possible to have several merkle trees under different `Key`.
pub trait MerkleRootStorage<Key, StorageType>: StorageInspect<StorageType>
where
    StorageType: Mappable,
{
    /// Return the merkle root of the stored `Type` in the storage.
    ///
    /// The cryptographic primitive is an arbitrary choice of the implementor and this
    /// trait won't impose any restrictions to that.
    fn root(&self, key: &Key) -> Result<MerkleRoot, Self::Error>;
}

/// The wrapper around the storage that supports only methods from `StorageInspect`.
pub struct StorageRef<'a, T: 'a + ?Sized, Type: Mappable>(
    &'a T,
    core::marker::PhantomData<Type>,
);

/// Helper trait for `StorageInspect` to provide user-friendly API to retrieve storage as
/// reference.
///
/// # Example
///
/// ```rust
/// use fuel_storage::{Mappable, StorageInspect, StorageAsRef};
///
/// pub struct Contracts;
///
/// impl Mappable for Contracts {
///     type Key = Self::OwnedKey;
///     type OwnedKey = [u8; 32];
///     type Value = [u8];
///     type OwnedValue = Vec<u8>;
/// }
///
/// pub struct Balances;
///
/// impl Mappable for Balances {
///     type Key = Self::OwnedKey;
///     type OwnedKey = u128;
///     type Value = Self::OwnedValue;
///     type OwnedValue = u64;
/// }
///
/// pub trait Logic: StorageInspect<Contracts> + StorageInspect<Balances> {
///     fn run(&self) {
///         // You can specify which storage do you want to call with `storage::<Type>()`
///         let _ = self.storage::<Contracts>().get(&[0; 32]);
///         let _ = self.storage::<Balances>().get(&123);
///     }
/// }
/// ```
pub trait StorageAsRef {
    #[inline(always)]
    fn storage<Type>(&self) -> StorageRef<Self, Type>
    where
        Type: Mappable,
    {
        self.storage_as_ref()
    }

    #[inline(always)]
    fn storage_as_ref<Type>(&self) -> StorageRef<Self, Type>
    where
        Type: Mappable,
    {
        StorageRef(self, Default::default())
    }
}

impl<T> StorageAsRef for T {}

/// The wrapper around the storage that supports methods from `StorageInspect` and
/// `StorageMutate`.
pub struct StorageMut<'a, T: 'a + ?Sized, Type: Mappable>(
    &'a mut T,
    core::marker::PhantomData<Type>,
);

/// Helper trait for `StorageMutate` to provide user-friendly API to retrieve storage as
/// mutable reference.
///
/// # Example
///
/// ```rust
/// use fuel_storage::{Mappable, StorageMutate, StorageInspect, StorageAsMut};
///
/// pub struct Contracts;
///
/// impl Mappable for Contracts {
///     type Key = Self::OwnedKey;
///     type OwnedKey = [u8; 32];
///     type Value = [u8];
///     type OwnedValue = Vec<u8>;
/// }
///
/// pub struct Balances;
///
/// impl Mappable for Balances {
///     type Key = Self::OwnedKey;
///     type OwnedKey = u128;
///     type Value = Self::OwnedValue;
///     type OwnedValue = u64;
/// }
///
/// pub trait Logic: StorageInspect<Contracts> + StorageMutate<Balances> {
///     fn run(&mut self) {
///         let mut self_ = self;
///         // You can specify which storage do you want to call with `storage::<Type>()`
///         let _ = self_.storage::<Balances>().insert(&123, &321);
///         let _ = self_.storage::<Contracts>().get(&[0; 32]);
///     }
/// }
/// ```
pub trait StorageAsMut {
    #[inline(always)]
    fn storage<Type>(&mut self) -> StorageMut<Self, Type>
    where
        Type: Mappable,
    {
        self.storage_as_mut()
    }

    #[inline(always)]
    fn storage_as_mut<Type>(&mut self) -> StorageMut<Self, Type>
    where
        Type: Mappable,
    {
        StorageMut(self, Default::default())
    }
}

impl<T> StorageAsMut for T {}

/home/marten/fuel/fuel-vm/fuel-storage/src/impls.rs

Source
use crate::{
    Mappable,
    MerkleRoot,
    MerkleRootStorage,
    StorageInspect,
    StorageMut,
    StorageMutate,
    StorageRead,
    StorageRef,
    StorageSize,
    StorageWrite,
};
use alloc::{
    borrow::Cow,
    vec::Vec,
};

impl<'a, T: StorageInspect<Type> + ?Sized, Type: Mappable> StorageInspect<Type>
    for &'a T
{
    type Error = T::Error;

    fn get(
        &self,
        key: &Type::Key,
    ) -> Result<Option<Cow<'_, Type::OwnedValue>>, Self::Error> {
        <T as StorageInspect<Type>>::get(self, key)
    }

    fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error> {
        <T as StorageInspect<Type>>::contains_key(self, key)
    }
}

impl<'a, T: StorageInspect<Type> + ?Sized, Type: Mappable> StorageInspect<Type>
    for &'a mut T
{
    type Error = T::Error;

    fn get(
        &self,
        key: &Type::Key,
    ) -> Result<Option<Cow<'_, Type::OwnedValue>>, Self::Error> {
        <T as StorageInspect<Type>>::get(self, key)
    }

    fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error> {
        <T as StorageInspect<Type>>::contains_key(self, key)
    }
}

impl<'a, T: StorageMutate<Type> + ?Sized, Type: Mappable> StorageMutate<Type>
    for &'a mut T
{
    fn insert(
        &mut self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<(), Self::Error> {
        <T as StorageMutate<Type>>::insert(self, key, value)
    }

    fn replace(
        &mut self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
        <T as StorageMutate<Type>>::replace(self, key, value)
    }

    fn remove(&mut self, key: &Type::Key) -> Result<(), Self::Error> {
        <T as StorageMutate<Type>>::remove(self, key)
    }

    fn take(&mut self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, Self::Error> {
        <T as StorageMutate<Type>>::take(self, key)
    }
}

impl<'a, T: StorageSize<Type> + ?Sized, Type: Mappable> StorageSize<Type> for &'a T {
    fn size_of_value(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<usize>, Self::Error> {
        <T as StorageSize<Type>>::size_of_value(self, key)
    }
}

impl<'a, T: StorageSize<Type> + ?Sized, Type: Mappable> StorageSize<Type> for &'a mut T {
    fn size_of_value(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<usize>, Self::Error> {
        <T as StorageSize<Type>>::size_of_value(self, key)
    }
}

impl<'a, T: StorageRead<Type> + StorageSize<Type> + ?Sized, Type: Mappable>
    StorageRead<Type> for &'a T
{
    fn read(
        &self,
        key: &<Type as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        <T as StorageRead<Type>>::read(self, key, buf)
    }

    fn read_alloc(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<alloc::vec::Vec<u8>>, Self::Error> {
        <T as StorageRead<Type>>::read_alloc(self, key)
    }
}

impl<'a, T: StorageRead<Type> + StorageSize<Type> + ?Sized, Type: Mappable>
    StorageRead<Type> for &'a mut T
{
    fn read(
        &self,
        key: &<Type as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        <T as StorageRead<Type>>::read(self, key, buf)
    }

    fn read_alloc(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<alloc::vec::Vec<u8>>, Self::Error> {
        <T as StorageRead<Type>>::read_alloc(self, key)
    }
}

impl<'a, T: StorageWrite<Type> + ?Sized, Type: Mappable> StorageWrite<Type>
    for &'a mut T
{
    fn write_bytes(&mut self, key: &Type::Key, buf: &[u8]) -> Result<usize, Self::Error> {
        <T as StorageWrite<Type>>::write_bytes(self, key, buf)
    }

    fn replace_bytes(
        &mut self,
        key: &Type::Key,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error> {
        <T as StorageWrite<Type>>::replace_bytes(self, key, buf)
    }

    fn take_bytes(&mut self, key: &Type::Key) -> Result<Option<Vec<u8>>, Self::Error> {
        <T as StorageWrite<Type>>::take_bytes(self, key)
    }
}

impl<'a, T: MerkleRootStorage<Key, Type> + ?Sized, Key, Type: Mappable>
    MerkleRootStorage<Key, Type> for &'a T
{
    fn root(&self, key: &Key) -> Result<MerkleRoot, Self::Error> {
        <T as MerkleRootStorage<Key, Type>>::root(self, key)
    }
}

impl<'a, T: MerkleRootStorage<Key, Type> + ?Sized, Key, Type: Mappable>
    MerkleRootStorage<Key, Type> for &'a mut T
{
    fn root(&self, key: &Key) -> Result<MerkleRoot, Self::Error> {
        <T as MerkleRootStorage<Key, Type>>::root(self, key)
    }
}

impl<'a, T: StorageInspect<Type>, Type: Mappable> StorageRef<'a, T, Type> {
    #[inline(always)]
    pub fn get(
        self,
        key: &Type::Key,
    ) -> Result<Option<Cow<'a, Type::OwnedValue>>, T::Error> {
        self.0.get(key)
    }

    #[inline(always)]
    pub fn contains_key(self, key: &Type::Key) -> Result<bool, T::Error> {
        self.0.contains_key(key)
    }
}

impl<'a, T, Type: Mappable> StorageRef<'a, T, Type> {
    #[inline(always)]
    pub fn root<Key>(self, key: &Key) -> Result<MerkleRoot, T::Error>
    where
        T: MerkleRootStorage<Key, Type>,
    {
        self.0.root(key)
    }
}

impl<'a, T: StorageRead<Type>, Type: Mappable> StorageRef<'a, T, Type> {
    #[inline(always)]
    pub fn read(
        &self,
        key: &<Type as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, T::Error> {
        self.0.read(key, buf)
    }

    #[inline(always)]
    pub fn read_alloc(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<alloc::vec::Vec<u8>>, T::Error> {
        self.0.read_alloc(key)
    }
}

impl<'a, T: StorageInspect<Type>, Type: Mappable> StorageMut<'a, T, Type> {
    #[inline(always)]
    pub fn get(
        self,
        key: &Type::Key,
    ) -> Result<Option<Cow<'a, Type::OwnedValue>>, T::Error> {
        // Workaround, because compiler doesn't convert the lifetime to `'a` by default.
        let self_: &'a T = self.0;
        self_.get(key)
    }

    #[inline(always)]
    pub fn contains_key(self, key: &Type::Key) -> Result<bool, T::Error> {
        self.0.contains_key(key)
    }
}

impl<'a, T, Type> StorageMut<'a, T, Type>
where
    T: StorageMutate<Type>,
    Type: Mappable,
{
    #[inline(always)]
    pub fn insert(self, key: &Type::Key, value: &Type::Value) -> Result<(), T::Error> {
        StorageMutate::insert(self.0, key, value)
    }

    #[inline(always)]
    pub fn replace(
        self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<Option<Type::OwnedValue>, T::Error> {
        StorageMutate::replace(self.0, key, value)
    }

    #[inline(always)]
    pub fn remove(self, key: &Type::Key) -> Result<(), T::Error> {
        StorageMutate::remove(self.0, key)
    }

    #[inline(always)]
    pub fn take(self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, T::Error> {
        StorageMutate::take(self.0, key)
    }
}

impl<'a, T, Type: Mappable> StorageMut<'a, T, Type> {
    #[inline(always)]
    pub fn root<Key>(self, key: &Key) -> Result<MerkleRoot, T::Error>
    where
        T: MerkleRootStorage<Key, Type>,
    {
        self.0.root(key)
    }
}

impl<'a, T, Type> StorageMut<'a, T, Type>
where
    Type: Mappable,
    T: StorageWrite<Type>,
{
    #[inline(always)]
    pub fn write_bytes(
        &mut self,
        key: &Type::Key,
        buf: &[u8],
    ) -> Result<usize, T::Error> {
        StorageWrite::write_bytes(self.0, key, buf)
    }

    #[inline(always)]
    pub fn replace_bytes(
        &mut self,
        key: &Type::Key,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), T::Error>
    where
        T: StorageSize<Type>,
    {
        StorageWrite::replace_bytes(self.0, key, buf)
    }

    #[inline(always)]
    pub fn take_bytes(&mut self, key: &Type::Key) -> Result<Option<Vec<u8>>, T::Error> {
        StorageWrite::take_bytes(self.0, key)
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/ed25519.rs

Source
//! ED25519 signature verification

use ed25519_dalek::Signature;
use fuel_types::{
    Bytes32,
    Bytes64,
};

use crate::Error;

/// Verify a signature against a message digest and a public key.
pub fn verify(
    pub_key: &Bytes32,
    signature: &Bytes64,
    message: &[u8],
) -> Result<(), Error> {
    let signature = Signature::from_bytes(signature);

    let pub_key = ed25519_dalek::VerifyingKey::from_bytes(pub_key)
        .map_err(|_| Error::InvalidPublicKey)?;

    if pub_key.verify_strict(message, &signature).is_ok() {
        Ok(())
    } else {
        Err(Error::InvalidSignature)
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/mnemonic.rs

Source
#![cfg(all(feature = "std", feature = "random"))]

use crate::Error;
use coins_bip39::{
    English,
    Mnemonic,
};
use rand::Rng;

/// Generates a random mnemonic phrase given a random number generator and
/// the number of words to generate, `count`.
pub fn generate_mnemonic_phrase<R: Rng>(
    rng: &mut R,
    count: usize,
) -> Result<String, Error> {
    Ok(Mnemonic::<English>::new_with_count(rng, count)?.to_phrase())
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/message.rs

Source
use crate::Hasher;
use core::{
    fmt,
    ops::Deref,
};
pub use fuel_types::Bytes32;

/// Normalized (hashed) message authenticated by a signature
#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(transparent)]
pub struct Message(Bytes32);

impl Message {
    /// Memory length of the type in bytes.
    pub const LEN: usize = Bytes32::LEN;

    /// Normalize the given message by cryptographically hashing its content in
    /// preparation for signing.
    pub fn new<M>(message: M) -> Self
    where
        M: AsRef<[u8]>,
    {
        Self(Hasher::hash(message))
    }

    /// Construct a `Message` directly from its bytes.
    ///
    /// This constructor expects the given bytes to be a valid,
    /// cryptographically hashed message. No hashing is performed.
    pub fn from_bytes(bytes: [u8; Self::LEN]) -> Self {
        Self(bytes.into())
    }

    /// Construct a `Message` reference directly from a reference to its bytes.
    ///
    /// This constructor expects the given bytes to be a valid,
    /// cryptographically hashed message. No hashing is performed.
    pub fn from_bytes_ref(bytes: &[u8; Self::LEN]) -> &Self {
        // TODO: Wrap this unsafe conversion safely in `fuel_types::Bytes32`.
        #[allow(unsafe_code)]
        unsafe {
            &*(bytes.as_ptr() as *const Self)
        }
    }

    /// Kept temporarily for backwards compatibility.
    #[deprecated = "Use `Message::from_bytes` instead"]
    pub fn from_bytes_unchecked(bytes: [u8; Self::LEN]) -> Self {
        Self::from_bytes(bytes)
    }
}

impl Deref for Message {
    type Target = [u8; Message::LEN];

    fn deref(&self) -> &[u8; Message::LEN] {
        self.0.deref()
    }
}

impl AsRef<[u8]> for Message {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl From<Message> for [u8; Message::LEN] {
    fn from(message: Message) -> [u8; Message::LEN] {
        message.0.into()
    }
}

impl From<Message> for Bytes32 {
    fn from(s: Message) -> Self {
        s.0
    }
}

impl From<&Hasher> for Message {
    fn from(hasher: &Hasher) -> Self {
        // Safety: `Hasher` is a cryptographic hash
        Self::from_bytes(*hasher.digest())
    }
}

impl From<Hasher> for Message {
    fn from(hasher: Hasher) -> Self {
        // Safety: `Hasher` is a cryptographic hash
        Self::from_bytes(*hasher.finalize())
    }
}

impl fmt::LowerHex for Message {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::UpperHex for Message {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Debug for Message {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Display for Message {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

#[cfg(feature = "std")]
impl From<&Message> for secp256k1::Message {
    fn from(message: &Message) -> Self {
        secp256k1::Message::from_digest_slice(&*message.0).expect("length always matches")
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/hasher.rs

Source
use fuel_types::Bytes32;
use sha2::{
    digest::Update,
    Digest,
    Sha256,
};

use core::iter;

/// Standard hasher
#[derive(Debug, Default, Clone)]
pub struct Hasher(Sha256);

impl Hasher {
    /// Length of the output
    pub const OUTPUT_LEN: usize = Bytes32::LEN;

    /// Append data to the hasher
    pub fn input<B>(&mut self, data: B)
    where
        B: AsRef<[u8]>,
    {
        sha2::Digest::update(&mut self.0, data)
    }

    /// Consume, append data and return the hasher
    pub fn chain<B>(self, data: B) -> Self
    where
        B: AsRef<[u8]>,
    {
        Self(self.0.chain(data))
    }

    /// Consume, append the items of the iterator and return the hasher
    pub fn extend_chain<B, I>(mut self, iter: I) -> Self
    where
        B: AsRef<[u8]>,
        I: IntoIterator<Item = B>,
    {
        self.extend(iter);

        self
    }

    /// Reset the hasher to the default state
    pub fn reset(&mut self) {
        self.0.reset();
    }

    /// Hash the provided data, returning its digest
    pub fn hash<B>(data: B) -> Bytes32
    where
        B: AsRef<[u8]>,
    {
        let mut hasher = Sha256::new();

        sha2::Digest::update(&mut hasher, data);

        <[u8; Bytes32::LEN]>::from(hasher.finalize()).into()
    }

    /// Consume the hasher, returning the digest
    pub fn finalize(self) -> Bytes32 {
        <[u8; Bytes32::LEN]>::from(self.0.finalize()).into()
    }

    /// Return the digest without consuming the hasher
    pub fn digest(&self) -> Bytes32 {
        <[u8; Bytes32::LEN]>::from(self.0.clone().finalize()).into()
    }
}

impl<B> iter::FromIterator<B> for Hasher
where
    B: AsRef<[u8]>,
{
    fn from_iter<T>(iter: T) -> Self
    where
        T: IntoIterator<Item = B>,
    {
        iter.into_iter().fold(Hasher::default(), Hasher::chain)
    }
}

impl<B> Extend<B> for Hasher
where
    B: AsRef<[u8]>,
{
    fn extend<T: IntoIterator<Item = B>>(&mut self, iter: T) {
        iter.into_iter().for_each(|b| self.input(b))
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/error.rs

Source
use core::convert::Infallible;

/// Crypto error variants
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Error {
    /// Invalid secp256k1 secret key
    InvalidSecretKey,

    /// Invalid secp256k1 public key
    InvalidPublicKey,

    /// Invalid secp256k1 signature message
    InvalidMessage,

    /// Invalid secp256k1 signature
    InvalidSignature,

    /// Coudln't sign the message
    FailedToSign,

    /// The provided key wasn't found
    KeyNotFound,

    /// The keystore isn't available or is corrupted
    KeystoreNotAvailable,

    /// Out of preallocated memory
    NotEnoughMemory,

    /// Invalid mnemonic phrase
    InvalidMnemonic,

    /// Bip32-related error
    Bip32Error,
}

impl From<Error> for Infallible {
    fn from(_: Error) -> Infallible {
        unreachable!()
    }
}

impl From<Infallible> for Error {
    fn from(_: Infallible) -> Error {
        unreachable!()
    }
}

#[cfg(feature = "std")]
mod use_std {
    use super::*;
    use coins_bip39::MnemonicError;
    use std::{
        error,
        fmt,
        io,
    };

    impl From<MnemonicError> for Error {
        fn from(_: MnemonicError) -> Self {
            Self::InvalidMnemonic
        }
    }

    impl From<coins_bip32::Bip32Error> for Error {
        fn from(_: coins_bip32::Bip32Error) -> Self {
            Self::Bip32Error
        }
    }

    impl fmt::Display for Error {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "{self:?}")
        }
    }

    impl error::Error for Error {
        fn source(&self) -> Option<&(dyn error::Error + 'static)> {
            None
        }
    }

    impl From<Error> for io::Error {
        fn from(e: Error) -> io::Error {
            io::Error::new(io::ErrorKind::Other, e)
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/signature.rs

Source
use super::backend::k1;
use crate::{
    Error,
    Message,
    PublicKey,
    SecretKey,
};

use fuel_types::Bytes64;

use core::{
    fmt,
    ops::Deref,
    str,
};

/// Compressed-form Secp256k1 signature.
#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(transparent)]
pub struct Signature(Bytes64);

impl Signature {
    /// Memory length of the type in bytes.
    pub const LEN: usize = Bytes64::LEN;

    /// Construct a `Signature` directly from its bytes.
    ///
    /// This constructor expects the given bytes to be a valid signature. No signing is
    /// performed.
    pub fn from_bytes(bytes: [u8; Self::LEN]) -> Self {
        Self(bytes.into())
    }

    /// Construct a `Signature` reference directly from a reference to its bytes.
    ///
    /// This constructor expects the given bytes to be a valid signature. No signing is
    /// performed.
    pub fn from_bytes_ref(bytes: &[u8; Self::LEN]) -> &Self {
        // TODO: Wrap this unsafe conversion safely in `fuel_types::Bytes64`.
        #[allow(unsafe_code)]
        unsafe {
            &*(bytes.as_ptr() as *const Self)
        }
    }

    /// Kept temporarily for backwards compatibility.
    #[deprecated = "Use `Signature::from_bytes` instead"]
    pub fn from_bytes_unchecked(bytes: [u8; Self::LEN]) -> Self {
        Self::from_bytes(bytes)
    }
}

impl Deref for Signature {
    type Target = [u8; Signature::LEN];

    fn deref(&self) -> &[u8; Signature::LEN] {
        self.0.deref()
    }
}

impl AsRef<[u8]> for Signature {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl AsMut<[u8]> for Signature {
    fn as_mut(&mut self) -> &mut [u8] {
        self.0.as_mut()
    }
}

impl fmt::LowerHex for Signature {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::UpperHex for Signature {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Debug for Signature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Display for Signature {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl From<Signature> for [u8; Signature::LEN] {
    fn from(salt: Signature) -> [u8; Signature::LEN] {
        salt.0.into()
    }
}

impl From<Signature> for Bytes64 {
    fn from(s: Signature) -> Self {
        s.0
    }
}

impl str::FromStr for Signature {
    type Err = Error;

    /// Parse a `Signature` directly from its bytes encoded as hex in a string.
    ///
    /// This constructor does not perform any signing.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Bytes64::from_str(s)
            .map_err(|_| Error::InvalidSignature)
            .map(|s| Self::from_bytes(s.into()))
    }
}

/// Secp256k1 methods
impl Signature {
    /// Produce secp256k1 signature
    pub fn sign(secret: &SecretKey, message: &Message) -> Self {
        Self(Bytes64::from(k1::sign(secret, message)))
    }

    /// Recover secp256k1 public key from a signature performed with
    pub fn recover(&self, message: &Message) -> Result<PublicKey, Error> {
        k1::recover(*self.0, message)
    }

    /// Verify that a signature matches given public key
    pub fn verify(&self, public_key: &PublicKey, message: &Message) -> Result<(), Error> {
        k1::verify(*self.0, **public_key, message)
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/backend/r1/p256.rs

Source
//! secp256r1 (P-256) functions

#[cfg(feature = "test-helpers")]
use crate::secp256::signature_format::encode_signature;
use crate::{
    message::Message,
    secp256::signature_format::decode_signature,
    Error,
};
#[cfg(feature = "test-helpers")]
use ecdsa::RecoveryId;
use fuel_types::Bytes64;
use p256::ecdsa::VerifyingKey;

/// Sign a prehashed message. With the given key.
#[cfg(feature = "test-helpers")]
pub fn sign_prehashed(
    signing_key: &p256::ecdsa::SigningKey,
    message: &Message,
) -> Result<Bytes64, Error> {
    let (signature, _) = signing_key
        .sign_prehash_recoverable(&**message)
        .map_err(|_| Error::FailedToSign)?;

    let signature = signature.normalize_s().unwrap_or(signature);

    // TODO: this is a hack to get the recovery id. The signature should be normalized
    // before computing the recovery id, but p256 library doesn't support this, and
    // instead always computes the recovery id from non-normalized signature.
    // So instead the recovery id is determined by checking which variant matches
    // the original public key.

    let recid1 = RecoveryId::new(false, false);
    let recid2 = RecoveryId::new(true, false);

    let rec1 = VerifyingKey::recover_from_prehash(&**message, &signature, recid1);
    let rec2 = VerifyingKey::recover_from_prehash(&**message, &signature, recid2);

    let actual = signing_key.verifying_key();

    let recovery_id = if rec1.map(|r| r == *actual).unwrap_or(false) {
        recid1
    } else if rec2.map(|r| r == *actual).unwrap_or(false) {
        recid2
    } else {
        unreachable!("Invalid signature generated");
    };

    let recovery_id = recovery_id
        .try_into()
        .expect("reduced-x recovery ids are never generated");
    Ok(Bytes64::from(encode_signature(
        signature.to_bytes().into(),
        recovery_id,
    )))
}

/// Convert the public key point to its uncompressed non-prefixed representation,
/// i.e. 32 bytes of x coordinate and 32 bytes of y coordinate.
#[cfg(feature = "test-helpers")]
pub fn encode_pubkey(key: VerifyingKey) -> [u8; 64] {
    let point = key.to_encoded_point(false);
    let mut result = [0u8; 64];
    result[..32].copy_from_slice(point.x().unwrap());
    result[32..].copy_from_slice(point.y().unwrap());
    result
}

/// Recover a public key from a signature and a message digest. It assumes
/// a compacted signature
pub fn recover(signature: &Bytes64, message: &Message) -> Result<Bytes64, Error> {
    let (sig, recid) = decode_signature(**signature);
    let sig =
        p256::ecdsa::Signature::from_slice(&sig).map_err(|_| Error::InvalidSignature)?;
    let vk = VerifyingKey::recover_from_prehash(&**message, &sig, recid.into())
        .map_err(|_| Error::InvalidSignature)?;
    let point = vk.to_encoded_point(false);
    let mut raw = Bytes64::zeroed();
    raw[..32].copy_from_slice(point.x().unwrap());
    raw[32..].copy_from_slice(point.y().unwrap());
    Ok(raw)
}

#[cfg(test)]
mod tests {
    use super::*;

    use p256::ecdsa::SigningKey;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    #[test]
    fn test_raw_recover() {
        let mut rng = &mut StdRng::seed_from_u64(1234);

        let signing_key = SigningKey::random(&mut rng);
        let verifying_key = signing_key.verifying_key();

        let message = Message::new([rng.gen(); 100]);

        let (signature, recovery_id) =
            signing_key.sign_prehash_recoverable(&*message).unwrap();

        let recovered =
            VerifyingKey::recover_from_prehash(&*message, &signature, recovery_id)
                .expect("Unable to recover the public key");

        assert_eq!(recovered, *verifying_key);
    }

    #[test]
    fn test_secp256r1_recover_from_msg() {
        let mut rng = &mut StdRng::seed_from_u64(1234);

        for _ in 0..100 {
            let signing_key = SigningKey::random(&mut rng);
            let verifying_key = signing_key.verifying_key();

            let message = Message::new([rng.gen(); 100]);
            let signature =
                sign_prehashed(&signing_key, &message).expect("Couldn't sign");

            let Ok(recovered) = recover(&signature, &message) else {
                panic!("Failed to recover public key from the message");
            };

            assert_eq!(*recovered, encode_pubkey(*verifying_key));
        }
    }

    #[test]
    fn test_signature_and_recovery_id_encoding_roundtrip() {
        let mut rng = &mut StdRng::seed_from_u64(1234);

        for _ in 0..100 {
            let message = Message::new([rng.gen(); 100]);
            let signing_key = SigningKey::random(&mut rng);
            let (signature, _) = signing_key.sign_prehash_recoverable(&*message).unwrap();
            let signature = signature.normalize_s().unwrap_or(signature);
            let signature: [u8; 64] = signature.to_bytes().into();

            let recovery_id = RecoveryId::from_byte(0).unwrap().try_into().unwrap();
            let encoded = encode_signature(signature, recovery_id);

            let (de_sig, de_recid) = decode_signature(encoded);
            assert_eq!(signature, de_sig);
            assert_eq!(recovery_id, de_recid);

            let recovery_id = RecoveryId::from_byte(1).unwrap().try_into().unwrap();
            let encoded = encode_signature(signature, recovery_id);

            let (de_sig, de_recid) = decode_signature(encoded);
            assert_eq!(signature, de_sig);
            assert_eq!(recovery_id, de_recid);
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/backend/k1/secp256k1.rs

Source
use crate::{
    message::Message,
    secp256::{
        signature_format::{
            decode_signature,
            encode_signature,
            RecoveryId as SecpRecoveryId,
        },
        PublicKey,
    },
    Error,
};

use secp256k1::{
    ecdsa::{
        RecoverableSignature,
        Signature,
    },
    Secp256k1,
};

use crate::SecretKey;

#[cfg(feature = "random")]
use rand::{
    CryptoRng,
    RngCore,
};

lazy_static::lazy_static! {
    static ref CONTEXT: Secp256k1<secp256k1::All> = Secp256k1::new();
}

/// Generates a random secret key
#[cfg(feature = "random")]
pub fn random_secret(rng: &mut (impl CryptoRng + RngCore)) -> SecretKey {
    secp256k1::SecretKey::new(rng).into()
}

/// Derives the public key from a given secret key
pub fn public_key(secret: &SecretKey) -> PublicKey {
    let sk: secp256k1::SecretKey = secret.into();
    let vk = secp256k1::PublicKey::from_secret_key(&CONTEXT, &sk);
    vk.into()
}

/// Sign a given message and compress the `v` to the signature
///
/// The compression scheme is described in
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/cryptographic-primitives.md>
pub fn sign(secret: &SecretKey, message: &Message) -> [u8; 64] {
    let signature = CONTEXT.sign_ecdsa_recoverable(&message.into(), &secret.into());
    let (recovery_id, signature) = signature.serialize_compact();

    // encode_signature cannot panic as we don't generate reduced-x recovery ids.
    let recovery_id = SecpRecoveryId::try_from(recovery_id)
        .expect("reduced-x recovery ids are never generated");
    encode_signature(signature, recovery_id)
}

/// Recover the public key from a signature.
///
/// It takes the signature as owned because this operation is not idempotent. The
/// taken signature will not be recoverable. Signatures are meant to be
/// single use, so this avoids unnecessary copy.
pub fn recover(signature: [u8; 64], message: &Message) -> Result<PublicKey, Error> {
    let (signature, recovery_id) = decode_signature(signature);
    let recoverable = RecoverableSignature::from_compact(&signature, recovery_id.into())
        .map_err(|_| Error::InvalidSignature)?;
    let vk = CONTEXT
        .recover_ecdsa(&message.into(), &recoverable)
        .map_err(|_| Error::InvalidSignature)?;
    Ok(PublicKey::from(vk))
}

/// Verify that a signature matches given public key
pub fn verify(
    signature: [u8; 64],
    public_key: [u8; 64],
    message: &Message,
) -> Result<(), Error> {
    let (signature, _) = decode_signature(signature); // Trunactes recovery id
    let signature =
        Signature::from_compact(&signature).map_err(|_| Error::InvalidSignature)?;

    let mut prefixed_public_key = [0u8; 65];
    prefixed_public_key[0] = 0x04; // Uncompressed
    prefixed_public_key[1..].copy_from_slice(&public_key);
    let vk = secp256k1::PublicKey::from_slice(&prefixed_public_key)
        .map_err(|_| Error::InvalidPublicKey)?;

    CONTEXT
        .verify_ecdsa(&message.into(), &signature, &vk)
        .map_err(|_| Error::InvalidSignature)?;
    Ok(())
}

#[cfg(all(test, feature = "std"))]
mod tests {
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    use super::*;

    #[test]
    fn full() {
        let rng = &mut StdRng::seed_from_u64(1234);

        let secret = random_secret(rng);
        let public = public_key(&secret);

        let message = Message::new(rng.gen::<[u8; 10]>());

        let signature = sign(&secret, &message);
        verify(signature, *public, &message).expect("Verification failed");
        let recovered = recover(signature, &message).expect("Recovery failed");

        assert_eq!(public, recovered);
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/backend/k1/k256.rs

Source
use crate::{
    message::Message,
    secp256::{
        signature_format::{
            decode_signature,
            encode_signature,
            RecoveryId as SecpRecoveryId,
        },
        PublicKey,
    },
    Error,
};

use crate::SecretKey;

use k256::{
    ecdsa::{
        RecoveryId,
        VerifyingKey,
    },
    EncodedPoint,
};

#[cfg(feature = "random")]
use rand::{
    CryptoRng,
    RngCore,
};

/// Generates a random secret key
#[cfg(feature = "random")]
pub fn random_secret(rng: &mut (impl CryptoRng + RngCore)) -> SecretKey {
    k256::SecretKey::random(rng).into()
}

/// Derives the public key from a given secret key
pub fn public_key(secret: &SecretKey) -> PublicKey {
    let sk: k256::SecretKey = secret.into();
    let sk: ecdsa::SigningKey<k256::Secp256k1> = sk.into();
    let vk = sk.verifying_key();
    vk.into()
}

/// Sign a given message and compress the `v` to the signature
///
/// The compression scheme is described in
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/cryptographic-primitives.md>
pub fn sign(secret: &SecretKey, message: &Message) -> [u8; 64] {
    let sk: k256::SecretKey = secret.into();
    let sk: ecdsa::SigningKey<k256::Secp256k1> = sk.into();
    let (signature, _recid) = sk
        .sign_prehash_recoverable(&**message)
        .expect("Infallible signature operation");

    // TODO: this is a hack to get the recovery id. The signature should be normalized
    // before computing the recovery id, but k256 library doesn't support this, and
    // instead always computes the recovery id from non-normalized signature.
    // So instead the recovery id is determined by checking which variant matches
    // the original public key.

    let recid1 = RecoveryId::new(false, false);
    let recid2 = RecoveryId::new(true, false);

    let rec1 = VerifyingKey::recover_from_prehash(&**message, &signature, recid1);
    let rec2 = VerifyingKey::recover_from_prehash(&**message, &signature, recid2);

    let actual = sk.verifying_key();

    let recovery_id = if rec1.map(|r| r == *actual).unwrap_or(false) {
        recid1
    } else if rec2.map(|r| r == *actual).unwrap_or(false) {
        recid2
    } else {
        unreachable!("Invalid signature generated");
    };

    let recovery_id = SecpRecoveryId::try_from(recovery_id)
        .expect("reduced-x recovery ids are never generated");
    encode_signature(signature.to_bytes().into(), recovery_id)
}

/// Recover the public key from a signature.
///
/// It takes the signature as owned because this operation is not idempotent. The
/// taken signature will not be recoverable. Signatures are meant to be
/// single use, so this avoids unnecessary copy.
pub fn recover(signature: [u8; 64], message: &Message) -> Result<PublicKey, Error> {
    let (sig, recid) = decode_signature(signature);
    let sig =
        k256::ecdsa::Signature::from_slice(&sig).map_err(|_| Error::InvalidSignature)?;
    let vk = VerifyingKey::recover_from_prehash(&**message, &sig, recid.into())
        .map_err(|_| Error::InvalidSignature)?;
    Ok(PublicKey::from(&vk))
}

/// Verify that a signature matches given public key
///
/// It takes the signature as owned because this operation is not idempotent. The
/// taken signature will not be recoverable. Signatures are meant to be
/// single use, so this avoids unnecessary copy.
pub fn verify(
    signature: [u8; 64],
    public_key: [u8; 64],
    message: &Message,
) -> Result<(), Error> {
    use ecdsa::signature::hazmat::PrehashVerifier;

    let vk = VerifyingKey::from_encoded_point(&EncodedPoint::from_untagged_bytes(
        &public_key.into(),
    ))
    .map_err(|_| Error::InvalidPublicKey)?;

    let (sig, _) = decode_signature(signature);
    let sig =
        k256::ecdsa::Signature::from_slice(&sig).map_err(|_| Error::InvalidSignature)?;

    vk.verify_prehash(&**message, &sig)
        .map_err(|_| Error::InvalidSignature)?;
    Ok(())
}

#[cfg(test)]
mod tests {
    use fuel_types::Bytes32;
    #[cfg(feature = "std")]
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    use super::*;

    #[cfg(feature = "std")]
    #[test]
    fn full() {
        let rng = &mut StdRng::seed_from_u64(1234);

        let secret = random_secret(rng);
        let public = public_key(&secret);

        let message = Message::new(rng.gen::<[u8; 10]>());

        let signature = sign(&secret, &message);
        verify(signature, *public, &message).expect("Verification failed");
        let recovered = recover(signature, &message).expect("Recovery failed");

        assert_eq!(public, recovered);
    }

    #[test]
    fn no_std() {
        let raw_secret: [u8; 32] = [
            0x99, 0xe8, 0x7b, 0xe, 0x91, 0x58, 0x53, 0x1e, 0xee, 0xb5, 0x3, 0xff, 0x15,
            0x26, 0x6e, 0x2b, 0x23, 0xc2, 0xa2, 0x50, 0x7b, 0x13, 0x8c, 0x9d, 0x1b, 0x1f,
            0x2a, 0xb4, 0x58, 0xdf, 0x2d, 0x6,
        ];
        let secret = SecretKey::try_from(Bytes32::from(raw_secret)).unwrap();
        let public = public_key(&secret);

        let message = Message::new(b"Every secret creates a potential failure point.");

        let signature = sign(&secret, &message);
        verify(signature, *public, &message).expect("Verification failed");
        let recovered = recover(signature, &message).expect("Recovery failed");

        assert_eq!(public, recovered);
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/secret.rs

Source
use fuel_types::Bytes32;

use core::{
    fmt,
    ops::Deref,
    str,
};

use zeroize::Zeroize;

use crate::{
    secp256::PublicKey,
    Error,
};

#[cfg(feature = "std")]
use coins_bip32::path::DerivationPath;

#[cfg(feature = "std")]
use coins_bip39::{
    English,
    Mnemonic,
};

#[cfg(feature = "random")]
use rand::{
    CryptoRng,
    RngCore,
};

/// Asymmetric secret key, guaranteed to be valid by construction
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Zeroize)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(transparent)]
pub struct SecretKey(Bytes32);

impl SecretKey {
    /// Memory length of the type
    pub const LEN: usize = Bytes32::LEN;
}

impl Deref for SecretKey {
    type Target = [u8; SecretKey::LEN];

    fn deref(&self) -> &[u8; SecretKey::LEN] {
        self.0.deref()
    }
}

impl AsRef<[u8]> for SecretKey {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl From<SecretKey> for [u8; SecretKey::LEN] {
    fn from(salt: SecretKey) -> [u8; SecretKey::LEN] {
        salt.0.into()
    }
}

impl fmt::LowerHex for SecretKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::UpperHex for SecretKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Debug for SecretKey {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Display for SecretKey {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl From<::k256::SecretKey> for SecretKey {
    fn from(s: ::k256::SecretKey) -> Self {
        let mut raw_bytes = [0u8; Self::LEN];
        raw_bytes.copy_from_slice(&s.to_bytes());
        Self(Bytes32::from(raw_bytes))
    }
}

#[cfg(feature = "std")]
impl From<::secp256k1::SecretKey> for SecretKey {
    fn from(s: ::secp256k1::SecretKey) -> Self {
        let mut raw_bytes = [0u8; Self::LEN];
        raw_bytes.copy_from_slice(s.as_ref());
        Self(Bytes32::from(raw_bytes))
    }
}

impl From<&SecretKey> for ::k256::SecretKey {
    fn from(sk: &SecretKey) -> Self {
        ::k256::SecretKey::from_bytes(&(*sk.0).into())
            .expect("SecretKey is guaranteed to be valid")
    }
}

#[cfg(feature = "std")]
impl From<&SecretKey> for ::secp256k1::SecretKey {
    fn from(sk: &SecretKey) -> Self {
        ::secp256k1::SecretKey::from_slice(sk.as_ref())
            .expect("SecretKey is guaranteed to be valid")
    }
}

#[cfg(all(feature = "random", feature = "test-helpers"))]
impl Default for SecretKey {
    /// Creates a new random secret using rand::thread_rng()
    fn default() -> Self {
        let mut rng = rand::thread_rng();
        SecretKey::random(&mut rng)
    }
}

#[cfg(feature = "std")]
pub type W = English;

impl SecretKey {
    /// Create a new random secret
    #[cfg(feature = "random")]
    pub fn random(rng: &mut (impl CryptoRng + RngCore)) -> Self {
        super::backend::k1::random_secret(rng)
    }

    /// Generate a new secret key from a mnemonic phrase and its derivation path.
    /// Both are passed as `&str`. If you want to manually create a `DerivationPath`
    /// and `Mnemonic`, use [`SecretKey::new_from_mnemonic`].
    /// The derivation path is a list of integers, each representing a child index.
    #[cfg(feature = "std")]
    pub fn new_from_mnemonic_phrase_with_path(
        phrase: &str,
        path: &str,
    ) -> Result<Self, Error> {
        use core::str::FromStr;

        let mnemonic = Mnemonic::<W>::new_from_phrase(phrase)?;
        let path = DerivationPath::from_str(path)?;
        Self::new_from_mnemonic(path, mnemonic)
    }

    /// Generate a new secret key from a `DerivationPath` and `Mnemonic`.
    /// If you want to pass strings instead, use
    /// [`SecretKey::new_from_mnemonic_phrase_with_path`].
    #[cfg(feature = "std")]
    pub fn new_from_mnemonic(d: DerivationPath, m: Mnemonic<W>) -> Result<Self, Error> {
        let derived_priv_key = m.derive_key(d, None)?;
        let key: &coins_bip32::prelude::SigningKey = derived_priv_key.as_ref();
        let bytes: [u8; Self::LEN] = key.to_bytes().into();
        Ok(SecretKey(Bytes32::from(bytes)))
    }

    /// Return the curve representation of this secret.
    pub fn public_key(&self) -> PublicKey {
        crate::secp256::backend::k1::public_key(self)
    }
}

impl TryFrom<Bytes32> for SecretKey {
    type Error = Error;

    fn try_from(b: Bytes32) -> Result<Self, Self::Error> {
        match k256::SecretKey::from_bytes((&*b).into()) {
            Ok(_) => Ok(Self(b)),
            Err(_) => Err(Error::InvalidSecretKey),
        }
    }
}

impl TryFrom<&[u8]> for SecretKey {
    type Error = Error;

    fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
        Bytes32::try_from(slice)
            .map_err(|_| Error::InvalidSecretKey)
            .and_then(SecretKey::try_from)
    }
}

impl str::FromStr for SecretKey {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Bytes32::from_str(s)
            .map_err(|_| Error::InvalidSecretKey)
            .and_then(SecretKey::try_from)
    }
}

#[cfg(test)]
#[allow(non_snake_case)]
mod tests {
    #[cfg(feature = "random")]
    #[test]
    fn default__yields_valid_secret() {
        use super::SecretKey;
        let _ = SecretKey::default();
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/public.rs

Source
use crate::{
    hasher::Hasher,
    secp256::SecretKey,
    Error,
};
use core::{
    fmt,
    ops::Deref,
};

use k256::ecdsa::VerifyingKey;

use core::str;

use fuel_types::{
    Bytes32,
    Bytes64,
};
use k256::elliptic_curve::sec1::ToEncodedPoint;

/// Asymmetric secp256k1 public key, i.e. verifying key, in uncompressed form.
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/cryptographic-primitives.md#ecdsa-public-key-cryptography>
#[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[repr(transparent)]
pub struct PublicKey(Bytes64);

impl PublicKey {
    /// Memory length of the type in bytes.
    pub const LEN: usize = Bytes64::LEN;

    /// Cryptographic hash of the public key.
    pub fn hash(&self) -> Bytes32 {
        Hasher::hash(self.as_ref())
    }
}

impl Deref for PublicKey {
    type Target = [u8; PublicKey::LEN];

    fn deref(&self) -> &[u8; PublicKey::LEN] {
        self.0.deref()
    }
}

impl AsRef<[u8]> for PublicKey {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl AsMut<[u8]> for PublicKey {
    fn as_mut(&mut self) -> &mut [u8] {
        self.0.as_mut()
    }
}

impl From<PublicKey> for [u8; PublicKey::LEN] {
    fn from(pk: PublicKey) -> [u8; PublicKey::LEN] {
        pk.0.into()
    }
}

impl fmt::LowerHex for PublicKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::UpperHex for PublicKey {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Debug for PublicKey {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl fmt::Display for PublicKey {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.0.fmt(f)
    }
}

impl From<k256::PublicKey> for PublicKey {
    fn from(key: k256::PublicKey) -> Self {
        let point = key.to_encoded_point(false);
        let mut raw = Bytes64::zeroed();
        raw[..32].copy_from_slice(point.x().unwrap());
        raw[32..].copy_from_slice(point.y().unwrap());
        Self(raw)
    }
}

impl From<&ecdsa::VerifyingKey<k256::Secp256k1>> for PublicKey {
    fn from(vk: &ecdsa::VerifyingKey<k256::Secp256k1>) -> Self {
        let vk: k256::PublicKey = vk.into();
        vk.into()
    }
}

#[cfg(feature = "std")]
impl From<secp256k1::PublicKey> for PublicKey {
    fn from(key: secp256k1::PublicKey) -> Self {
        let key_bytes = key.serialize_uncompressed();
        let mut raw = Bytes64::zeroed();
        // Remove leading identifier byte
        raw.copy_from_slice(&key_bytes[1..]);
        Self(raw)
    }
}

impl TryFrom<Bytes64> for PublicKey {
    type Error = Error;

    fn try_from(b: Bytes64) -> Result<Self, Self::Error> {
        match VerifyingKey::from_sec1_bytes(&*b) {
            Ok(_) => Ok(Self(b)),
            Err(_) => Err(Error::InvalidPublicKey),
        }
    }
}

impl TryFrom<&[u8]> for PublicKey {
    type Error = Error;

    fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
        Bytes64::try_from(slice)
            .map_err(|_| Error::InvalidPublicKey)
            .and_then(PublicKey::try_from)
    }
}

impl From<&SecretKey> for PublicKey {
    fn from(s: &SecretKey) -> PublicKey {
        s.public_key()
    }
}

impl str::FromStr for PublicKey {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Bytes64::from_str(s)
            .map_err(|_| Error::InvalidPublicKey)
            .and_then(PublicKey::try_from)
    }
}

/home/marten/fuel/fuel-vm/fuel-crypto/src/secp256/signature_format.rs

Source
//! Utility functions common for secp256k1 and secp256r1

/// Recovery id, used to encode the y parity of the public key
/// in the signature.
///
/// Guaranteed to be valid by construction. Only encodes the y parity,
/// and rejects reduced-x recovery ids.
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct RecoveryId {
    is_y_odd: bool,
}

impl From<RecoveryId> for k256::ecdsa::RecoveryId {
    fn from(recid: RecoveryId) -> Self {
        k256::ecdsa::RecoveryId::new(recid.is_y_odd, false)
    }
}
impl TryFrom<ecdsa::RecoveryId> for RecoveryId {
    type Error = ();

    fn try_from(recid: ecdsa::RecoveryId) -> Result<Self, Self::Error> {
        if recid.is_x_reduced() {
            return Err(())
        }

        Ok(Self {
            is_y_odd: recid.is_y_odd(),
        })
    }
}

#[cfg(feature = "std")]
impl From<RecoveryId> for secp256k1::ecdsa::RecoveryId {
    fn from(recid: RecoveryId) -> Self {
        secp256k1::ecdsa::RecoveryId::from_i32(recid.is_y_odd as i32)
            .expect("0 and 1 are always valid recovery ids")
    }
}

#[cfg(feature = "std")]
impl TryFrom<secp256k1::ecdsa::RecoveryId> for RecoveryId {
    type Error = ();

    fn try_from(recid: secp256k1::ecdsa::RecoveryId) -> Result<Self, Self::Error> {
        match recid.to_i32() {
            0 => Ok(Self { is_y_odd: false }),
            1 => Ok(Self { is_y_odd: true }),
            _ => Err(()),
        }
    }
}

/// Combines recovery id with the signature bytes. See the following link for explanation.
/// https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/cryptographic-primitives.md#ecdsa-public-key-cryptography
/// Panics if the highest bit of byte at index 32 is set, as this indicates non-normalized
/// signature. Panics if the recovery id is in reduced-x form.
pub fn encode_signature(mut signature: [u8; 64], recovery_id: RecoveryId) -> [u8; 64] {
    assert!(signature[32] >> 7 == 0, "Non-normalized signature");
    let v = recovery_id.is_y_odd as u8;

    signature[32] = (v << 7) | (signature[32] & 0x7f);
    signature
}

/// Separates recovery id from the signature bytes. See the following link for
/// explanation. https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/cryptographic-primitives.md#ecdsa-public-key-cryptography
pub fn decode_signature(mut signature: [u8; 64]) -> ([u8; 64], RecoveryId) {
    let is_y_odd = (signature[32] & 0x80) != 0;
    signature[32] &= 0x7f;
    (signature, RecoveryId { is_y_odd })
}

#[cfg(all(test, feature = "std"))]
mod tests {
    use rand::{
        rngs::StdRng,
        SeedableRng,
    };

    use crate::{
        Message,
        SecretKey,
        Signature,
    };

    use super::*;

    #[test]
    fn signature_roundtrip() {
        let rng = &mut StdRng::seed_from_u64(1234);

        let message = Message::new("Hello, world!");
        let secret = SecretKey::random(rng);
        let signature = Signature::sign(&secret, &message);

        let (decoded, recovery_id) = decode_signature(*signature);
        let encoded = encode_signature(decoded, recovery_id);

        assert_eq!(*signature, encoded);
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/fuzz/src/lib.rs

Source
use fuel_vm::fuel_asm::op;
use fuel_vm::fuel_asm::{Instruction, InvalidOpcode};
use fuel_vm::fuel_types::Word;
use fuel_vm::prelude::field::Script;
use fuel_vm::prelude::*;

use fuel_vm::util::test_helpers::TestBuilder;
use fuel_vm::{fuel_asm, script_with_data_offset};
use fuel_vm::fuel_types::canonical::Serialize;
use std::ops::Range;

/// Magic value used as separator between fuzz data components in corpus files.
const MAGIC_VALUE_SEPARATOR: [u8; 8] = [0x00u8, 0xAD, 0xBE, 0xEF, 0x55, 0x66, 0xCE, 0xAA];

#[derive(Debug, Eq, PartialEq)]
pub struct FuzzData {
    pub program: Vec<u8>,
    pub sub_program: Vec<u8>,
    pub script_data: Vec<u8>,
}

pub fn encode(data: &FuzzData) -> Vec<u8> {
    let separator: Vec<u8> = MAGIC_VALUE_SEPARATOR.into();
    data.program.iter()
        .copied()
        .chain(separator.iter().copied())
        .chain(data.script_data.iter().copied())
        .chain(separator.iter().copied())
        .chain(data.sub_program.iter().copied())
        .collect()
}

fn split_by_separator(data: &[u8], separator: &[u8]) -> Vec<Range<usize>> {
    let separator_len = separator.len();

    let mut last: usize = 0;

    let mut result: Vec<_> = data
        .windows(separator_len)
        .enumerate()
        .filter_map(|(i, window)| {
            if window == separator {
                let option = Some(last..i);
                last = i + separator_len;
                return option;
            } else {
                None
            }
        })
        .collect();

    result.push(last..data.len());

    result
}

pub fn decode(data: &[u8]) -> Option<FuzzData> {
    let x = split_by_separator(data, &MAGIC_VALUE_SEPARATOR);
    if x.len() != 3 {
        return None;
    }
    Some(FuzzData {
        program: data[x[0].clone()].to_vec(),
        script_data: data[x[1].clone()].to_vec(),
        sub_program: data[x[2].clone()].to_vec(),
    })
}
pub fn decode_instructions(bytes: &[u8]) -> Option<Vec<Instruction>> {
    let instructions: Vec<_> = fuel_vm::fuel_asm::from_bytes(bytes.iter().cloned())
        .flat_map(|i: Result<Instruction, InvalidOpcode>| i.ok())
        .collect();
    return Some(instructions);
}

pub struct ExecuteResult {
    pub success: bool,
    pub gas_used: u64,
}

pub fn execute(data: FuzzData) -> ExecuteResult {
    let gas_limit = 1_000_000;
    let asset_id: AssetId = AssetId::new([
        0xFA, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1,
    ]);

    let mut test_context = TestBuilder::new(2322u64);
    let subcontract: Vec<_> = [
        // Pass some data to fuzzer
        op::addi(
            0x10,
            fuel_asm::RegId::FP,
            CallFrame::b_offset() as Immediate12,
        ),
        fuel_vm::fuel_asm::op::lw(0x10, 0x10, 0), // load address word
    ]
    .iter()
    .copied()
    .flat_map(Instruction::to_bytes)
    .chain(data.sub_program.iter().copied())
    .collect::<Vec<u8>>();

    let contract_id = test_context
        .setup_contract_bytes(subcontract.clone(), None, None)
        .contract_id;

    let max_program_length = 2usize.pow(18)
        - test_context.get_tx_params().tx_offset()
        - <fuel_vm::prelude::Script as Script>::script_offset_static();

    let actual_program = &data.program[..max_program_length.min(data.program.len())];

    let (script_ops, script_data_offset): (Vec<u8>, Immediate18) = script_with_data_offset!(
        script_data_offset,
        actual_program.to_vec(),
        test_context.get_tx_params().tx_offset()
    );

    let call = Call::new(contract_id, 0, script_data_offset as Word).to_bytes();
    let script_data: [&[u8]; 2] = [asset_id.as_ref(), call.as_slice()];

    // Provide an asset id and the contract_id
    let script_data: Vec<u8> = script_data.iter().copied().flatten().copied().collect();

    let script_data = script_data
        .iter()
        .chain(data.script_data.iter())
        .copied()
        .collect::<Vec<_>>();

    let transfer_tx = test_context
        .start_script_bytes(script_ops.iter().copied().collect(), script_data)
        .script_gas_limit(gas_limit)
        .gas_price(0)
        .coin_input(asset_id, 1000)
        .contract_input(contract_id)
        .contract_output(&contract_id)
        .change_output(asset_id)
        .execute();

    let gas_used: u64 = *transfer_tx
        .receipts()
        .iter()
        .filter_map(|recipt| match recipt {
            Receipt::ScriptResult { gas_used, .. } => Some(gas_used),
            _ => None,
        })
        .next()
        .unwrap();

    ExecuteResult {
        success: !transfer_tx.should_revert(),
        gas_used,
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/backtrace.rs

Source
//! Backtrace implementation to track script errors.
//!
//! As of the moment, doesn't support predicates.

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

use crate::{
    call::CallFrame,
    consts::*,
    interpreter::{
        InitialBalances,
        Interpreter,
    },
};
use derivative::Derivative;

use crate::interpreter::{
    Memory,
    MemoryInstance,
};
use fuel_tx::ScriptExecutionResult;
use fuel_types::{
    ContractId,
    Word,
};

#[derive(Derivative)]
#[derivative(Debug)]
/// Runtime description derived from a VM error.
pub struct Backtrace {
    call_stack: Vec<CallFrame>,
    contract: ContractId,
    registers: [Word; VM_REGISTER_COUNT],
    memory: MemoryInstance,
    result: ScriptExecutionResult,
    initial_balances: InitialBalances,
}

impl Backtrace {
    /// Create a backtrace from a vm instance and instruction result.
    ///
    /// This isn't copy-free and shouldn't be provided by default.
    pub fn from_vm_error<M, S, Tx, Ecal>(
        vm: &Interpreter<M, S, Tx, Ecal>,
        result: ScriptExecutionResult,
    ) -> Self
    where
        M: Memory,
    {
        let call_stack = vm.call_stack().to_owned();
        let contract = vm.internal_contract().unwrap_or_default();
        let memory = vm.memory().clone();
        let initial_balances = vm.initial_balances().clone();
        let mut registers = [0; VM_REGISTER_COUNT];

        registers.copy_from_slice(vm.registers());

        Self {
            call_stack,
            contract,
            registers,
            memory,
            result,
            initial_balances,
        }
    }

    /// Call stack of the VM when the error occurred.
    pub fn call_stack(&self) -> &[CallFrame] {
        self.call_stack.as_slice()
    }

    /// Last contract of the context when the error occurred.
    pub const fn contract(&self) -> &ContractId {
        &self.contract
    }

    /// Register set when the error occurred.
    pub const fn registers(&self) -> &[Word] {
        &self.registers
    }

    /// Memory of the VM when the error occurred.
    pub fn memory(&self) -> &MemoryInstance {
        &self.memory
    }

    /// [`ScriptExecutionResult`] of the error that caused this backtrace.
    pub const fn result(&self) -> &ScriptExecutionResult {
        &self.result
    }

    /// The initial balances.
    pub const fn initial_balances(&self) -> &InitialBalances {
        &self.initial_balances
    }

    /// Expose the internal attributes of the backtrace.
    pub fn into_inner(
        self,
    ) -> (
        Vec<CallFrame>,
        ContractId,
        [Word; VM_REGISTER_COUNT],
        MemoryInstance,
        ScriptExecutionResult,
        InitialBalances,
    ) {
        let Self {
            call_stack,
            contract,
            registers,
            memory,
            result,
            initial_balances,
        } = self;

        (
            call_stack,
            contract,
            registers,
            memory,
            result,
            initial_balances,
        )
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/constraints/reg_key.rs

Source
//! Utilities for accessing register values and proving at compile time that
//! the register index is valid.
//!
//! This module also provides utilities for mutably accessing multiple registers.
use core::ops::{
    Deref,
    DerefMut,
};

use fuel_asm::{
    PanicReason,
    RegId,
    RegisterId,
    Word,
};

use crate::consts::{
    VM_REGISTER_COUNT,
    VM_REGISTER_PROGRAM_COUNT,
    VM_REGISTER_SYSTEM_COUNT,
};

#[cfg(test)]
mod tests;

#[derive(Debug, PartialEq, Eq)]
/// Mutable reference to a register value at a given index.
pub struct RegMut<'r, const INDEX: u8>(&'r mut Word);

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
/// Immutable reference to a register value at a given index.
pub struct Reg<'r, const INDEX: u8>(&'r Word);

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
/// A key to a writable register that is within
/// the bounds of the writable registers.
pub struct WriteRegKey(usize);

impl WriteRegKey {
    /// Create a new writable register key if the index is within the bounds
    /// of the writable registers.
    pub fn new(k: impl Into<usize>) -> Result<Self, PanicReason> {
        let k = k.into();
        is_register_writable(&k)?;
        Ok(Self(k))
    }

    /// Translate this key from an absolute register index
    /// to a program register index.
    ///
    /// This subtracts the number of system registers from the key.
    #[allow(clippy::arithmetic_side_effects)] // Safety: checked in constructor
    fn translate(self) -> usize {
        self.0 - VM_REGISTER_SYSTEM_COUNT
    }
}

/// Check that the register is above the system registers and below the total
/// number of registers.
pub(crate) fn is_register_writable(r: &RegisterId) -> Result<(), PanicReason> {
    const W_USIZE: usize = RegId::WRITABLE.to_u8() as usize;
    const RANGE: core::ops::Range<usize> = W_USIZE..(W_USIZE + VM_REGISTER_PROGRAM_COUNT);
    if RANGE.contains(r) {
        Ok(())
    } else {
        Err(PanicReason::ReservedRegisterNotWritable)
    }
}

impl<'r, const INDEX: u8> RegMut<'r, INDEX> {
    /// Create a new mutable register reference.
    pub fn new(reg: &'r mut Word) -> Self {
        Self(reg)
    }
}

impl<'r, const INDEX: u8> Reg<'r, INDEX> {
    /// Create a new immutable register reference.
    pub fn new(reg: &'r Word) -> Self {
        Self(reg)
    }
}

impl<const INDEX: u8> Deref for Reg<'_, INDEX> {
    type Target = Word;

    fn deref(&self) -> &Self::Target {
        self.0
    }
}

impl<const INDEX: u8> Deref for RegMut<'_, INDEX> {
    type Target = Word;

    fn deref(&self) -> &Self::Target {
        self.0
    }
}

impl<const INDEX: u8> DerefMut for RegMut<'_, INDEX> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.0
    }
}

impl<'a, const INDEX: u8> From<RegMut<'a, INDEX>> for Reg<'a, INDEX> {
    fn from(reg: RegMut<'a, INDEX>) -> Self {
        Self(reg.0)
    }
}

impl<'r, const INDEX: u8> RegMut<'r, INDEX> {
    /// Re-borrow the register as an immutable reference.
    pub fn as_ref(&self) -> Reg<INDEX> {
        Reg(self.0)
    }
}

impl<'r, const INDEX: u8> RegMut<'r, INDEX> {
    /// Re-borrow the register as a mutable reference.
    pub fn as_mut(&mut self) -> RegMut<INDEX> {
        RegMut(self.0)
    }
}

macro_rules! impl_keys {
    ( $($i:ident, $f:ident $(,$f_mut:ident)?)* ) => {
        $(
            #[doc = "Register index key for use with Reg and RegMut."]
            pub const $i: u8 = RegId::$i.to_u8();
        )*
        #[doc = "Get register reference by name."]
        pub trait GetReg {
        $(
            #[doc = "Get register reference for this key."]
            fn $f(&self) -> Reg<'_, $i>;
        )*
        }
        #[doc = "Get register mutable reference by name."]
        pub trait GetRegMut {
        $(
            $(
            #[doc = "Get mutable register reference for this key."]
            fn $f_mut(&mut self) -> RegMut<'_, $i>;
            )?
        )*
        }
        impl GetReg for [Word; VM_REGISTER_COUNT] {
        $(
            fn $f(&self) -> Reg<'_, $i> {
                Reg(&self[$i as usize])
            }
        )*
        }
        impl GetRegMut for [Word; VM_REGISTER_COUNT] {
        $(
            $(
            fn $f_mut(&mut self) -> RegMut<'_, $i> {
                RegMut(&mut self[$i as usize])
            }
            )?
        )*
        }
    };
}

impl_keys! {
    ZERO, zero
    ONE, one
    OF, of, of_mut
    PC, pc, pc_mut
    SSP, ssp, ssp_mut
    SP, sp, sp_mut
    FP, fp, fp_mut
    HP, hp, hp_mut
    ERR, err, err_mut
    GGAS, ggas, ggas_mut
    CGAS, cgas, cgas_mut
    BAL, bal, bal_mut
    IS, is, is_mut
    RET, ret, ret_mut
    RETL, retl, retl_mut
    FLAG, flag, flag_mut
}

/// The set of system registers split into
/// individual mutable references.
pub(crate) struct SystemRegisters<'a> {
    pub(crate) zero: RegMut<'a, ZERO>,
    pub(crate) one: RegMut<'a, ONE>,
    pub(crate) of: RegMut<'a, OF>,
    pub(crate) pc: RegMut<'a, PC>,
    pub(crate) ssp: RegMut<'a, SSP>,
    pub(crate) sp: RegMut<'a, SP>,
    pub(crate) fp: RegMut<'a, FP>,
    pub(crate) hp: RegMut<'a, HP>,
    pub(crate) err: RegMut<'a, ERR>,
    pub(crate) ggas: RegMut<'a, GGAS>,
    pub(crate) cgas: RegMut<'a, CGAS>,
    pub(crate) bal: RegMut<'a, BAL>,
    pub(crate) is: RegMut<'a, IS>,
    pub(crate) ret: RegMut<'a, RET>,
    pub(crate) retl: RegMut<'a, RETL>,
    pub(crate) flag: RegMut<'a, FLAG>,
}

/// Same as `SystemRegisters` but with immutable references.
pub(crate) struct SystemRegistersRef<'a> {
    pub(crate) zero: Reg<'a, ZERO>,
    pub(crate) one: Reg<'a, ONE>,
    pub(crate) of: Reg<'a, OF>,
    pub(crate) pc: Reg<'a, PC>,
    pub(crate) ssp: Reg<'a, SSP>,
    pub(crate) sp: Reg<'a, SP>,
    pub(crate) fp: Reg<'a, FP>,
    pub(crate) hp: Reg<'a, HP>,
    pub(crate) err: Reg<'a, ERR>,
    pub(crate) ggas: Reg<'a, GGAS>,
    pub(crate) cgas: Reg<'a, CGAS>,
    pub(crate) bal: Reg<'a, BAL>,
    pub(crate) is: Reg<'a, IS>,
    pub(crate) ret: Reg<'a, RET>,
    pub(crate) retl: Reg<'a, RETL>,
    pub(crate) flag: Reg<'a, FLAG>,
}

/// The set of program registers split from the system registers.
pub(crate) struct ProgramRegisters<'a>(pub &'a mut [Word; VM_REGISTER_PROGRAM_COUNT]);

/// Same as `ProgramRegisters` but with immutable references.
pub(crate) struct ProgramRegistersRef<'a>(pub &'a [Word; VM_REGISTER_PROGRAM_COUNT]);

/// Split the registers into system and program registers.
///
/// This allows multiple mutable references to registers.
pub(crate) fn split_registers(
    registers: &mut [Word; VM_REGISTER_COUNT],
) -> (SystemRegisters<'_>, ProgramRegisters<'_>) {
    let [zero, one, of, pc, ssp, sp, fp, hp, err, ggas, cgas, bal, is, ret, retl, flag, rest @ ..] =
        registers;
    let r = SystemRegisters {
        zero: RegMut(zero),
        one: RegMut(one),
        of: RegMut(of),
        pc: RegMut(pc),
        ssp: RegMut(ssp),
        sp: RegMut(sp),
        fp: RegMut(fp),
        hp: RegMut(hp),
        err: RegMut(err),
        ggas: RegMut(ggas),
        cgas: RegMut(cgas),
        bal: RegMut(bal),
        is: RegMut(is),
        ret: RegMut(ret),
        retl: RegMut(retl),
        flag: RegMut(flag),
    };
    (r, ProgramRegisters(rest))
}

/// Copy the system and program registers into a single array.
pub(crate) fn copy_registers(
    system_registers: &SystemRegistersRef<'_>,
    program_registers: &ProgramRegistersRef<'_>,
) -> [Word; VM_REGISTER_COUNT] {
    let mut out = [0u64; VM_REGISTER_COUNT];
    out[..VM_REGISTER_SYSTEM_COUNT]
        .copy_from_slice(&<[Word; VM_REGISTER_SYSTEM_COUNT]>::from(system_registers));
    out[VM_REGISTER_SYSTEM_COUNT..].copy_from_slice(program_registers.0);
    out
}

impl<'r> ProgramRegisters<'r> {
    /// Get two mutable references to program registers.
    /// Note they cannot be the same register.
    pub fn get_mut_two(
        &mut self,
        a: WriteRegKey,
        b: WriteRegKey,
    ) -> Option<(&mut Word, &mut Word)> {
        if a == b {
            // Cannot mutably borrow the same register twice.
            return None
        }

        // Order registers
        let swap = a > b;
        let (a, b) = if swap { (b, a) } else { (a, b) };

        // Translate the absolute register indices to a program register indeces.
        let a = a.translate();

        // Subtract a + 1 because because we split the array at `a`.
        let b = b
            .translate()
            .checked_sub(a.saturating_add(1))
            .expect("Cannot underflow as the values are ordered");

        // Split the array at the first register which is a.
        let [i, rest @ ..] = &mut self.0[a..] else {
            return None
        };

        // Translate the higher absolute register index to a program register index.
        // Get the `b` register.
        let j = &mut rest[b];

        Some(if swap { (j, i) } else { (i, j) })
    }
}

impl<'a> From<&'a SystemRegisters<'_>> for SystemRegistersRef<'a> {
    fn from(value: &'a SystemRegisters<'_>) -> Self {
        Self {
            zero: Reg(value.zero.0),
            one: Reg(value.one.0),
            of: Reg(value.of.0),
            pc: Reg(value.pc.0),
            ssp: Reg(value.ssp.0),
            sp: Reg(value.sp.0),
            fp: Reg(value.fp.0),
            hp: Reg(value.hp.0),
            err: Reg(value.err.0),
            ggas: Reg(value.ggas.0),
            cgas: Reg(value.cgas.0),
            bal: Reg(value.bal.0),
            is: Reg(value.is.0),
            ret: Reg(value.ret.0),
            retl: Reg(value.retl.0),
            flag: Reg(value.flag.0),
        }
    }
}

impl<'a> From<SystemRegisters<'a>> for SystemRegistersRef<'a> {
    fn from(value: SystemRegisters<'a>) -> Self {
        Self {
            zero: Reg(value.zero.0),
            one: Reg(value.one.0),
            of: Reg(value.of.0),
            pc: Reg(value.pc.0),
            ssp: Reg(value.ssp.0),
            sp: Reg(value.sp.0),
            fp: Reg(value.fp.0),
            hp: Reg(value.hp.0),
            err: Reg(value.err.0),
            ggas: Reg(value.ggas.0),
            cgas: Reg(value.cgas.0),
            bal: Reg(value.bal.0),
            is: Reg(value.is.0),
            ret: Reg(value.ret.0),
            retl: Reg(value.retl.0),
            flag: Reg(value.flag.0),
        }
    }
}

impl<'a> From<&'a ProgramRegisters<'_>> for ProgramRegistersRef<'a> {
    fn from(value: &'a ProgramRegisters<'_>) -> Self {
        Self(value.0)
    }
}

impl<'a> From<ProgramRegisters<'a>> for ProgramRegistersRef<'a> {
    fn from(value: ProgramRegisters<'a>) -> Self {
        Self(value.0)
    }
}

impl TryFrom<RegisterId> for WriteRegKey {
    type Error = PanicReason;

    fn try_from(r: RegisterId) -> Result<Self, Self::Error> {
        Self::new(r)
    }
}

impl core::ops::Index<WriteRegKey> for ProgramRegisters<'_> {
    type Output = Word;

    fn index(&self, index: WriteRegKey) -> &Self::Output {
        &self.0[index.translate()]
    }
}

impl core::ops::IndexMut<WriteRegKey> for ProgramRegisters<'_> {
    fn index_mut(&mut self, index: WriteRegKey) -> &mut Self::Output {
        &mut self.0[index.translate()]
    }
}

impl<'a> From<&SystemRegistersRef<'a>> for [Word; VM_REGISTER_SYSTEM_COUNT] {
    fn from(value: &SystemRegistersRef<'a>) -> Self {
        let SystemRegistersRef {
            zero,
            one,
            of,
            pc,
            ssp,
            sp,
            fp,
            hp,
            err,
            ggas,
            cgas,
            bal,
            is,
            ret,
            retl,
            flag,
        } = value;
        [
            *zero.0, *one.0, *of.0, *pc.0, *ssp.0, *sp.0, *fp.0, *hp.0, *err.0, *ggas.0,
            *cgas.0, *bal.0, *is.0, *ret.0, *retl.0, *flag.0,
        ]
    }
}

#[derive(Debug, Clone, Copy)]
pub(crate) enum ProgramRegistersSegment {
    /// Registers 16..40
    Low,
    /// Registers 40..64
    High,
}

impl<'r> ProgramRegisters<'r> {
    /// Returns the registers corresponding to the segment, always 24 elements.
    pub(crate) fn segment(&self, segment: ProgramRegistersSegment) -> &[Word] {
        match segment {
            ProgramRegistersSegment::Low => &self.0[..24],
            ProgramRegistersSegment::High => &self.0[24..],
        }
    }

    /// Returns the registers corresponding to the segment, always 24 elements.
    pub(crate) fn segment_mut(
        &mut self,
        segment: ProgramRegistersSegment,
    ) -> &mut [Word] {
        match segment {
            ProgramRegistersSegment::Low => &mut self.0[..24],
            ProgramRegistersSegment::High => &mut self.0[24..],
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/util.rs

Source
//! FuelVM utilities

/// A utility macro for writing scripts with the data offset included. Since the
/// script data offset depends on the length of the script, this macro will
/// evaluate the length and then rewrite the resultant script output with the
/// correct offset (using the offset parameter).
///
/// # Example
///
/// ```
/// use fuel_asm::{op, RegId};
/// use fuel_types::{Immediate18, Word, canonical::Serialize};
/// use fuel_vm::prelude::{Call, TxParameters, ContractId, Opcode};
/// use fuel_vm::script_with_data_offset;
/// use itertools::Itertools;
///
/// // Example of making a contract call script using script_data for the call info and asset id.
/// let contract_id = ContractId::from([0x11; 32]);
/// let call = Call::new(contract_id, 0, 0).to_bytes();
/// let asset_id = [0x00; 32];
/// let transfer_amount: Word = 100;
/// let gas_to_forward = 100_000;
/// let script_data = [call.as_ref(), asset_id.as_ref()]
///     .into_iter()
///     .flatten()
///     .copied()
///     .collect_vec();
///
/// // Use the macro since we don't know the exact offset for script_data.
/// let (script, data_offset) = script_with_data_offset!(
///     data_offset,
///     vec![
///         // use data_offset to reference the location of the call bytes inside script_data
///         op::movi(0x10, data_offset),
///         op::movi(0x11, transfer_amount as Immediate18),
///         // use data_offset again to reference the location of the asset id inside of script data
///         op::movi(0x12, data_offset + call.len() as Immediate18),
///         op::movi(0x13, gas_to_forward as Immediate18),
///         op::call(0x10, 0x11, 0x12, 0x13),
///         op::ret(RegId::ONE),
///     ],
///     TxParameters::DEFAULT.tx_offset()
/// );
/// ```
#[cfg(feature = "alloc")]
#[macro_export]
macro_rules! script_with_data_offset {
    ($offset:ident, $script:expr, $tx_offset:expr) => {{
        let $offset = {
            // first set offset to 0 before evaluating script expression
            let $offset = {
                use $crate::prelude::Immediate18;
                0 as Immediate18
            };
            // evaluate script expression with zeroed data offset to get the script length
            let script_bytes: $crate::alloc::vec::Vec<u8> =
                ::core::iter::IntoIterator::into_iter({ $script }).collect();
            // compute the script data offset within the VM memory given the script length
            {
                use $crate::{
                    fuel_tx::{
                        field::Script as ScriptField,
                        Script,
                    },
                    fuel_types::bytes::padded_len,
                    prelude::Immediate18,
                };
                let value: Immediate18 = $tx_offset
                    .saturating_add(Script::script_offset_static())
                    .saturating_add(
                        padded_len(script_bytes.as_slice()).unwrap_or(usize::MAX),
                    )
                    .try_into()
                    .expect("script data offset is too large");
                value
            }
        };
        // re-evaluate and return the finalized script with the correct data offset length
        // set.
        ($script, $offset)
    }};
}

#[allow(missing_docs)]
#[cfg(feature = "random")]
#[cfg(any(test, feature = "test-helpers"))]
/// Testing utilities
pub mod test_helpers {
    use alloc::{
        vec,
        vec::Vec,
    };

    use crate::{
        checked_transaction::{
            builder::TransactionBuilderExt,
            Checked,
            IntoChecked,
        },
        interpreter::Memory,
        memory_client::MemoryClient,
        state::StateTransition,
        storage::{
            ContractsAssetsStorage,
            MemoryStorage,
        },
        transactor::Transactor,
    };
    use anyhow::anyhow;

    use crate::{
        interpreter::{
            CheckedMetadata,
            ExecutableTransaction,
            InterpreterParams,
            MemoryInstance,
        },
        prelude::{
            Backtrace,
            Call,
        },
    };
    use fuel_asm::{
        op,
        GTFArgs,
        Instruction,
        PanicReason,
        RegId,
    };
    use fuel_tx::{
        field::{
            Outputs,
            ReceiptsRoot,
        },
        BlobBody,
        BlobIdExt,
        ConsensusParameters,
        Contract,
        ContractParameters,
        Create,
        FeeParameters,
        Finalizable,
        GasCosts,
        Input,
        Output,
        PredicateParameters,
        Receipt,
        Script,
        ScriptParameters,
        StorageSlot,
        Transaction,
        TransactionBuilder,
        TxParameters,
        Witness,
    };
    use fuel_types::{
        canonical::{
            Deserialize,
            Serialize,
        },
        Address,
        AssetId,
        BlobId,
        BlockHeight,
        ChainId,
        ContractId,
        Immediate12,
        Salt,
        Word,
    };
    use itertools::Itertools;
    use rand::{
        prelude::StdRng,
        Rng,
        SeedableRng,
    };

    pub struct CreatedContract {
        pub tx: Create,
        pub contract_id: ContractId,
        pub salt: Salt,
    }

    pub struct TestBuilder {
        pub rng: StdRng,
        gas_price: Word,
        max_fee_limit: Word,
        script_gas_limit: Word,
        builder: TransactionBuilder<Script>,
        storage: MemoryStorage,
        block_height: BlockHeight,
        consensus_params: ConsensusParameters,
    }

    impl TestBuilder {
        pub fn new(seed: u64) -> Self {
            let bytecode = core::iter::once(op::ret(RegId::ONE)).collect();
            TestBuilder {
                rng: StdRng::seed_from_u64(seed),
                gas_price: 0,
                max_fee_limit: 0,
                script_gas_limit: 100,
                builder: TransactionBuilder::script(bytecode, vec![]),
                storage: MemoryStorage::default(),
                block_height: Default::default(),
                consensus_params: ConsensusParameters::standard(),
            }
        }

        pub fn get_block_height(&self) -> BlockHeight {
            self.block_height
        }

        pub fn start_script_bytes(
            &mut self,
            script: Vec<u8>,
            script_data: Vec<u8>,
        ) -> &mut Self {
            self.start_script_inner(script, script_data)
        }

        pub fn start_script(
            &mut self,
            script: Vec<Instruction>,
            script_data: Vec<u8>,
        ) -> &mut Self {
            let script = script.into_iter().collect();
            self.start_script_inner(script, script_data)
        }

        fn start_script_inner(
            &mut self,
            script: Vec<u8>,
            script_data: Vec<u8>,
        ) -> &mut Self {
            self.builder = TransactionBuilder::script(script, script_data);
            self.builder.script_gas_limit(self.script_gas_limit);
            self
        }

        pub fn gas_price(&mut self, price: Word) -> &mut TestBuilder {
            self.gas_price = price;
            self
        }

        pub fn max_fee_limit(&mut self, max_fee_limit: Word) -> &mut TestBuilder {
            self.max_fee_limit = max_fee_limit;
            self
        }

        pub fn script_gas_limit(&mut self, limit: Word) -> &mut TestBuilder {
            self.builder.script_gas_limit(limit);
            self.script_gas_limit = limit;
            self
        }

        pub fn change_output(&mut self, asset_id: AssetId) -> &mut TestBuilder {
            self.builder
                .add_output(Output::change(self.rng.gen(), 0, asset_id));
            self
        }

        pub fn coin_output(
            &mut self,
            asset_id: AssetId,
            amount: Word,
        ) -> &mut TestBuilder {
            self.builder
                .add_output(Output::coin(self.rng.gen(), amount, asset_id));
            self
        }

        pub fn variable_output(&mut self, asset_id: AssetId) -> &mut TestBuilder {
            self.builder
                .add_output(Output::variable(Address::zeroed(), 0, asset_id));
            self
        }

        pub fn contract_output(&mut self, id: &ContractId) -> &mut TestBuilder {
            let input_idx = self
                .builder
                .inputs()
                .iter()
                .find_position(|input| matches!(input, Input::Contract(contract) if &contract.contract_id == id))
                .expect("expected contract input with matching contract id");

            self.builder.add_output(Output::contract(
                u16::try_from(input_idx.0).expect("The input index is more than allowed"),
                self.rng.gen(),
                self.rng.gen(),
            ));

            self
        }

        pub fn coin_input(
            &mut self,
            asset_id: AssetId,
            amount: Word,
        ) -> &mut TestBuilder {
            self.builder.add_unsigned_coin_input(
                fuel_crypto::SecretKey::random(&mut self.rng),
                self.rng.gen(),
                amount,
                asset_id,
                Default::default(),
            );
            self
        }

        pub fn fee_input(&mut self) -> &mut TestBuilder {
            self.builder.add_fee_input();
            self
        }

        pub fn contract_input(&mut self, contract_id: ContractId) -> &mut TestBuilder {
            self.builder.add_input(Input::contract(
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
                self.rng.gen(),
                contract_id,
            ));
            self
        }

        pub fn witness(&mut self, witness: Witness) -> &mut TestBuilder {
            self.builder.add_witness(witness);
            self
        }

        pub fn storage(&mut self, storage: MemoryStorage) -> &mut TestBuilder {
            self.storage = storage;
            self
        }

        pub fn block_height(&mut self, block_height: BlockHeight) -> &mut TestBuilder {
            self.block_height = block_height;
            self
        }

        pub fn with_fee_params(&mut self, fee_params: FeeParameters) -> &mut TestBuilder {
            self.consensus_params.set_fee_params(fee_params);
            self
        }

        pub fn with_free_gas_costs(&mut self) -> &mut TestBuilder {
            let gas_costs = GasCosts::free();
            self.consensus_params.set_gas_costs(gas_costs);
            self
        }

        pub fn base_asset_id(&mut self, base_asset_id: AssetId) -> &mut TestBuilder {
            self.consensus_params.set_base_asset_id(base_asset_id);
            self
        }

        pub fn build(&mut self) -> Checked<Script> {
            self.builder.max_fee_limit(self.max_fee_limit);
            self.builder.with_tx_params(*self.get_tx_params());
            self.builder
                .with_contract_params(*self.get_contract_params());
            self.builder
                .with_predicate_params(*self.get_predicate_params());
            self.builder.with_script_params(*self.get_script_params());
            self.builder.with_fee_params(*self.get_fee_params());
            self.builder.with_base_asset_id(*self.get_base_asset_id());
            self.builder
                .finalize_checked_with_storage(self.block_height, &self.storage)
        }

        pub fn get_tx_params(&self) -> &TxParameters {
            self.consensus_params.tx_params()
        }

        pub fn get_predicate_params(&self) -> &PredicateParameters {
            self.consensus_params.predicate_params()
        }

        pub fn get_script_params(&self) -> &ScriptParameters {
            self.consensus_params.script_params()
        }

        pub fn get_contract_params(&self) -> &ContractParameters {
            self.consensus_params.contract_params()
        }

        pub fn get_fee_params(&self) -> &FeeParameters {
            self.consensus_params.fee_params()
        }

        pub fn get_base_asset_id(&self) -> &AssetId {
            self.consensus_params.base_asset_id()
        }

        pub fn get_block_gas_limit(&self) -> u64 {
            self.consensus_params.block_gas_limit()
        }

        pub fn get_block_transaction_size_limit(&self) -> u64 {
            self.consensus_params.block_transaction_size_limit()
        }

        pub fn get_privileged_address(&self) -> &Address {
            self.consensus_params.privileged_address()
        }

        pub fn get_chain_id(&self) -> ChainId {
            self.consensus_params.chain_id()
        }

        pub fn get_gas_costs(&self) -> &GasCosts {
            self.consensus_params.gas_costs()
        }

        pub fn build_get_balance_tx(
            contract_id: &ContractId,
            asset_id: &AssetId,
            tx_offset: usize,
        ) -> Checked<Script> {
            let (script, _) = script_with_data_offset!(
                data_offset,
                vec![
                    op::movi(0x11, data_offset),
                    op::addi(
                        0x12,
                        0x11,
                        Immediate12::try_from(AssetId::LEN)
                            .expect("`AssetId::LEN` is 32 bytes")
                    ),
                    op::bal(0x10, 0x11, 0x12),
                    op::log(0x10, RegId::ZERO, RegId::ZERO, RegId::ZERO),
                    op::ret(RegId::ONE),
                ],
                tx_offset
            );

            let script_data: Vec<u8> = [asset_id.as_ref(), contract_id.as_ref()]
                .into_iter()
                .flatten()
                .copied()
                .collect();

            TestBuilder::new(2322u64)
                .start_script(script, script_data)
                .gas_price(0)
                .script_gas_limit(1_000_000)
                .contract_input(*contract_id)
                .fee_input()
                .contract_output(contract_id)
                .build()
        }

        pub fn setup_contract_bytes(
            &mut self,
            contract: Vec<u8>,
            initial_balance: Option<(AssetId, Word)>,
            initial_state: Option<Vec<StorageSlot>>,
        ) -> CreatedContract {
            self.setup_contract_inner(contract, initial_balance, initial_state)
        }

        pub fn setup_contract(
            &mut self,
            contract: Vec<Instruction>,
            initial_balance: Option<(AssetId, Word)>,
            initial_state: Option<Vec<StorageSlot>>,
        ) -> CreatedContract {
            let contract = contract.into_iter().collect();

            self.setup_contract_inner(contract, initial_balance, initial_state)
        }

        fn setup_contract_inner(
            &mut self,
            contract: Vec<u8>,
            initial_balance: Option<(AssetId, Word)>,
            initial_state: Option<Vec<StorageSlot>>,
        ) -> CreatedContract {
            let storage_slots = initial_state.unwrap_or_default();

            let salt: Salt = self.rng.gen();
            let program: Witness = contract.into();
            let storage_root = Contract::initial_state_root(storage_slots.iter());
            let contract = Contract::from(program.as_ref());
            let contract_root = contract.root();
            let contract_id = contract.id(&salt, &contract_root, &storage_root);

            let tx = TransactionBuilder::create(program, salt, storage_slots)
                .max_fee_limit(self.max_fee_limit)
                .maturity(Default::default())
                .add_fee_input()
                .add_contract_created()
                .finalize()
                .into_checked(self.block_height, &self.consensus_params)
                .expect("failed to check tx");

            // setup a contract in current test state
            let state = self
                .deploy(tx)
                .expect("Expected vm execution to be successful");

            // set initial contract balance
            if let Some((asset_id, amount)) = initial_balance {
                self.storage
                    .contract_asset_id_balance_insert(&contract_id, &asset_id, amount)
                    .unwrap();
            }

            CreatedContract {
                tx: state.tx().clone(),
                contract_id,
                salt,
            }
        }

        pub fn setup_blob(&mut self, data: Vec<u8>) {
            let id = BlobId::compute(data.as_slice());

            let tx = TransactionBuilder::blob(BlobBody {
                id,
                witness_index: 0,
            })
            .add_witness(data.into())
            .max_fee_limit(self.max_fee_limit)
            .maturity(Default::default())
            .add_fee_input()
            .finalize()
            .into_checked(self.block_height, &self.consensus_params)
            .expect("failed to check tx");

            let interpreter_params =
                InterpreterParams::new(self.gas_price, &self.consensus_params);
            let mut transactor = Transactor::<_, _, _>::new(
                MemoryInstance::new(),
                self.storage.clone(),
                interpreter_params,
            );

            self.execute_tx_inner(&mut transactor, tx)
                .expect("Expected vm execution to be successful");
        }

        fn execute_tx_inner<M, Tx, Ecal>(
            &mut self,
            transactor: &mut Transactor<M, MemoryStorage, Tx, Ecal>,
            checked: Checked<Tx>,
        ) -> anyhow::Result<StateTransition<Tx>>
        where
            M: Memory,
            Tx: ExecutableTransaction,
            <Tx as IntoChecked>::Metadata: CheckedMetadata,
            Ecal: crate::interpreter::EcalHandler,
        {
            self.storage.set_block_height(self.block_height);

            transactor.transact(checked);

            let storage = transactor.as_mut().clone();

            if let Some(e) = transactor.error() {
                return Err(anyhow!("{:?}", e));
            }
            let is_reverted = transactor.is_reverted();

            let state = transactor.to_owned_state_transition().unwrap();

            let interpreter = transactor.interpreter();

            // verify serialized tx == referenced tx
            let transaction: Transaction = interpreter.transaction().clone().into();
            let tx_offset = self.get_tx_params().tx_offset();
            let mut tx_mem = interpreter
                .memory()
                .read(tx_offset, transaction.size())
                .unwrap();
            let mut deser_tx = Transaction::decode(&mut tx_mem).unwrap();

            // Patch the tx with correct receipts root
            if let Transaction::Script(ref mut s) = deser_tx {
                *s.receipts_root_mut() = interpreter.compute_receipts_root();
            }

            assert_eq!(deser_tx, transaction);
            if is_reverted {
                return Ok(state);
            }

            // save storage between client instances
            self.storage = storage;

            Ok(state)
        }

        pub fn deploy(
            &mut self,
            checked: Checked<Create>,
        ) -> anyhow::Result<StateTransition<Create>> {
            let interpreter_params =
                InterpreterParams::new(self.gas_price, &self.consensus_params);
            let mut transactor = Transactor::<_, _, _>::new(
                MemoryInstance::new(),
                self.storage.clone(),
                interpreter_params,
            );

            self.execute_tx_inner(&mut transactor, checked)
        }

        pub fn execute_tx(
            &mut self,
            checked: Checked<Script>,
        ) -> anyhow::Result<StateTransition<Script>> {
            let interpreter_params =
                InterpreterParams::new(self.gas_price, &self.consensus_params);
            let mut transactor = Transactor::<_, _, _>::new(
                MemoryInstance::new(),
                self.storage.clone(),
                interpreter_params,
            );

            self.execute_tx_inner(&mut transactor, checked)
        }

        pub fn execute_tx_with_backtrace(
            &mut self,
            checked: Checked<Script>,
            gas_price: u64,
        ) -> anyhow::Result<(StateTransition<Script>, Option<Backtrace>)> {
            let interpreter_params =
                InterpreterParams::new(gas_price, &self.consensus_params);
            let mut transactor = Transactor::<_, _, _>::new(
                MemoryInstance::new(),
                self.storage.clone(),
                interpreter_params,
            );

            let state = self.execute_tx_inner(&mut transactor, checked)?;
            let backtrace = transactor.backtrace();

            Ok((state, backtrace))
        }

        /// Build test tx and execute it
        pub fn execute(&mut self) -> StateTransition<Script> {
            let tx = self.build();

            self.execute_tx(tx)
                .expect("expected successful vm execution")
        }

        pub fn get_storage(&self) -> &MemoryStorage {
            &self.storage
        }

        pub fn execute_get_outputs(&mut self) -> Vec<Output> {
            self.execute().tx().outputs().to_vec()
        }

        pub fn execute_get_change(&mut self, find_asset_id: AssetId) -> Word {
            let outputs = self.execute_get_outputs();
            find_change(outputs, find_asset_id)
        }

        pub fn get_contract_balance(
            &mut self,
            contract_id: &ContractId,
            asset_id: &AssetId,
        ) -> Word {
            let tx = TestBuilder::build_get_balance_tx(
                contract_id,
                asset_id,
                self.consensus_params.tx_params().tx_offset(),
            );
            let state = self
                .execute_tx(tx)
                .expect("expected successful vm execution in this context");
            let receipts = state.receipts();
            receipts[0].ra().expect("Balance expected")
        }
    }

    pub fn check_expected_reason_for_instructions(
        instructions: Vec<Instruction>,
        expected_reason: PanicReason,
    ) {
        let client = MemoryClient::default();

        check_expected_reason_for_instructions_with_client(
            client,
            instructions,
            expected_reason,
        );
    }

    pub fn check_expected_reason_for_instructions_with_client<M>(
        mut client: MemoryClient<M>,
        instructions: Vec<Instruction>,
        expected_reason: PanicReason,
    ) where
        M: Memory,
    {
        let tx_params = TxParameters::default().with_max_gas_per_tx(Word::MAX / 2);
        // The gas should be huge enough to cover the execution but still much less than
        // `MAX_GAS_PER_TX`.
        let gas_limit = tx_params.max_gas_per_tx() / 2;
        let maturity = Default::default();
        let height = Default::default();
        let zero_fee_limit = 0;

        // setup contract with state tests
        let contract: Witness = instructions.into_iter().collect::<Vec<u8>>().into();
        let salt = Default::default();
        let code_root = Contract::root_from_code(contract.as_ref());
        let storage_slots = vec![];
        let state_root = Contract::initial_state_root(storage_slots.iter());
        let contract_id =
            Contract::from(contract.as_ref()).id(&salt, &code_root, &state_root);

        let contract_deployer = TransactionBuilder::create(contract, salt, storage_slots)
            .max_fee_limit(zero_fee_limit)
            .with_tx_params(tx_params)
            .add_fee_input()
            .add_contract_created()
            .finalize_checked(height);

        client
            .deploy(contract_deployer)
            .expect("valid contract deployment");

        // call deployed contract
        let script = [
            // load call data to 0x10
            op::gtf(0x10, 0x0, Immediate12::from(GTFArgs::ScriptData)),
            // call the transfer contract
            op::call(0x10, RegId::ZERO, RegId::ZERO, RegId::CGAS),
            op::ret(RegId::ONE),
        ]
        .into_iter()
        .collect();
        let script_data: Vec<u8> = [Call::new(contract_id, 0, 0).to_bytes().as_slice()]
            .into_iter()
            .flatten()
            .copied()
            .collect();

        let tx_deploy_loader = TransactionBuilder::script(script, script_data)
            .max_fee_limit(zero_fee_limit)
            .script_gas_limit(gas_limit)
            .maturity(maturity)
            .with_tx_params(tx_params)
            .add_input(Input::contract(
                Default::default(),
                Default::default(),
                Default::default(),
                Default::default(),
                contract_id,
            ))
            .add_fee_input()
            .add_output(Output::contract(0, Default::default(), Default::default()))
            .finalize_checked(height);

        check_reason_for_transaction(client, tx_deploy_loader, expected_reason);
    }

    pub fn check_reason_for_transaction<M>(
        mut client: MemoryClient<M>,
        checked_tx: Checked<Script>,
        expected_reason: PanicReason,
    ) where
        M: Memory,
    {
        let receipts = client.transact(checked_tx);

        let panic_found = receipts.iter().any(|receipt| {
            if let Receipt::Panic { id: _, reason, .. } = receipt {
                assert_eq!(
                    &expected_reason,
                    reason.reason(),
                    "Expected {}, found {}",
                    expected_reason,
                    reason.reason()
                );
                true
            } else {
                false
            }
        });

        if !panic_found {
            panic!("Script should have panicked");
        }
    }

    pub fn find_change(outputs: Vec<Output>, find_asset_id: AssetId) -> Word {
        let change = outputs.into_iter().find_map(|output| {
            if let Output::Change {
                amount, asset_id, ..
            } = output
            {
                if asset_id == find_asset_id {
                    Some(amount)
                } else {
                    None
                }
            } else {
                None
            }
        });
        change.unwrap_or_else(|| {
            panic!("no change matching asset ID {:x} was found", &find_asset_id)
        })
    }
}

#[allow(missing_docs)]
#[cfg(all(
    feature = "profile-gas",
    feature = "std",
    any(test, feature = "test-helpers")
))]
/// Gas testing utilities
pub mod gas_profiling {
    use crate::prelude::*;

    use std::sync::{
        Arc,
        Mutex,
    };

    #[derive(Clone)]
    pub struct GasProfiler {
        data: Arc<Mutex<Option<ProfilingData>>>,
    }

    impl Default for GasProfiler {
        fn default() -> Self {
            Self {
                data: Arc::new(Mutex::new(None)),
            }
        }
    }

    impl ProfileReceiver for GasProfiler {
        fn on_transaction(
            &mut self,
            _state: Result<&ProgramState, InterpreterError<String>>,
            data: &ProfilingData,
        ) {
            let mut guard = self.data.lock().unwrap();
            *guard = Some(data.clone());
        }
    }

    impl GasProfiler {
        pub fn data(&self) -> Option<ProfilingData> {
            self.data.lock().ok().and_then(|g| g.as_ref().cloned())
        }

        pub fn total_gas(&self) -> Word {
            self.data()
                .map(|d| {
                    d.gas()
                        .iter()
                        .map(|(_, gas)| gas)
                        .copied()
                        .reduce(Word::saturating_add)
                        .unwrap_or_default()
                })
                .unwrap_or_default()
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/predicate.rs

Source
//! Predicate representations with required data to be executed during VM runtime

use fuel_tx::field;

use crate::interpreter::MemoryRange;

/// Runtime representation of a predicate
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RuntimePredicate {
    range: MemoryRange,
    idx: usize,
}

impl RuntimePredicate {
    /// Empty predicate for testing
    #[cfg(test)]
    pub const fn empty() -> Self {
        Self {
            range: MemoryRange::new(0, 0),
            idx: 0,
        }
    }

    /// Memory slice with the program representation of the predicate
    pub const fn program(&self) -> &MemoryRange {
        &self.range
    }

    /// Index of the transaction input that maps to this predicate
    pub const fn idx(&self) -> usize {
        self.idx
    }

    /// Create a new runtime predicate from a transaction, given the input index
    ///
    /// Return `None` if the tx input doesn't map to an input with a predicate
    pub fn from_tx<T>(tx: &T, tx_offset: usize, idx: usize) -> Option<Self>
    where
        T: field::Inputs,
    {
        let (ofs, len) = tx.inputs_predicate_offset_at(idx)?;
        let addr = ofs.saturating_add(tx_offset);
        Some(Self {
            range: MemoryRange::new(addr, len),
            idx,
        })
    }
}

#[allow(clippy::cast_possible_truncation)]
#[cfg(test)]
mod tests {
    use alloc::{
        vec,
        vec::Vec,
    };
    use core::iter;
    use fuel_asm::op;
    use fuel_tx::{
        field::ScriptGasLimit,
        TransactionBuilder,
    };
    use fuel_types::bytes;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    use crate::{
        checked_transaction::{
            CheckPredicateParams,
            EstimatePredicates,
        },
        constraints::reg_key::{
            HP,
            IS,
            ONE,
            SSP,
            ZERO,
        },
        error::PredicateVerificationFailed,
        interpreter::InterpreterParams,
        prelude::{
            predicates::check_predicates,
            *,
        },
        storage::{
            predicate::empty_predicate_storage,
            BlobData,
        },
    };

    #[test]
    fn from_tx_works() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        let height = 1.into();

        #[rustfmt::skip]
        let predicate: Vec<u8> = vec![
            op::addi(0x10, 0x00, 0x01),
            op::addi(0x10, 0x10, 0x01),
            op::ret(0x01),
        ].into_iter().collect();

        let predicate_data = b"If people do not believe that mathematics is simple, it is only because they do not realize how complicated life is.".to_vec();

        let owner = (*Contract::root_from_code(&predicate)).into();
        let a = Input::coin_predicate(
            rng.gen(),
            owner,
            rng.gen(),
            rng.gen(),
            rng.gen(),
            0,
            predicate.clone(),
            predicate_data.clone(),
        );

        let b = Input::message_coin_predicate(
            rng.gen(),
            rng.gen(),
            rng.gen(),
            rng.gen(),
            0,
            predicate.clone(),
            predicate_data.clone(),
        );

        let c = Input::message_data_predicate(
            rng.gen(),
            rng.gen(),
            rng.gen(),
            rng.gen(),
            0,
            vec![0xff; 10],
            predicate.clone(),
            predicate_data,
        );

        let inputs = vec![a, b, c];

        for i in inputs {
            let tx = TransactionBuilder::script(vec![], vec![])
                .add_input(i)
                .add_fee_input()
                .finalize_checked_basic(height);

            // assert invalid idx wont panic
            let idx = 1;
            let tx_offset = TxParameters::DEFAULT.tx_offset();
            let runtime = RuntimePredicate::from_tx(tx.as_ref(), tx_offset, idx);

            assert!(runtime.is_none());

            // fetch the input predicate
            let idx = 0;
            let runtime = RuntimePredicate::from_tx(tx.as_ref(), tx_offset, idx)
                .expect("failed to generate predicate from valid tx");

            assert_eq!(idx, runtime.idx());

            let mut interpreter = Interpreter::<_, _, _>::with_storage(
                MemoryInstance::new(),
                empty_predicate_storage(),
                InterpreterParams::default(),
            );

            assert!(interpreter
                .init_predicate(
                    Context::PredicateVerification {
                        program: RuntimePredicate::empty(),
                    },
                    tx.transaction().clone(),
                    *tx.transaction().script_gas_limit(),
                )
                .is_ok());

            let pad = bytes::padded_len(&predicate).unwrap() - predicate.len();

            // assert we are testing an edge case
            assert_ne!(0, pad);

            let padded_predicate: Vec<u8> = predicate
                .iter()
                .copied()
                .chain(iter::repeat(0u8).take(pad))
                .collect();

            let program = runtime.program();
            let program = &interpreter.memory()[program.usizes()];

            // assert the program in the vm memory is the same of the input
            assert_eq!(program, &padded_predicate);
        }
    }

    fn assert_inputs_are_validated_for_predicates(
        inputs: Vec<(
            Vec<Instruction>,
            bool,
            Result<(), PredicateVerificationFailed>,
        )>,
        blob: Vec<Instruction>,
    ) {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        let height = 1.into();
        let predicate_data =
            b"If you think it's simple, then you have misunderstood the problem."
                .to_vec();

        let mut storage = MemoryStorage::new(Default::default(), Default::default());

        let blob_id = BlobId::zeroed();
        let blob: Vec<u8> = blob.into_iter().collect();
        storage
            .storage_as_mut::<BlobData>()
            .insert(&blob_id, &blob)
            .unwrap();

        macro_rules! predicate_input {
            ($predicate:expr) => {{
                let predicate: Vec<u8> = $predicate.into_iter().collect();
                let owner = Input::predicate_owner(&predicate);
                [
                    Input::coin_predicate(
                        rng.gen(),
                        owner,
                        rng.gen(),
                        rng.gen(),
                        rng.gen(),
                        0,
                        predicate.clone(),
                        predicate_data.clone(),
                    ),
                    Input::message_coin_predicate(
                        rng.gen(),
                        owner,
                        rng.gen(),
                        rng.gen(),
                        0,
                        predicate.clone(),
                        predicate_data.clone(),
                    ),
                    Input::message_data_predicate(
                        rng.gen(),
                        owner,
                        rng.gen(),
                        rng.gen(),
                        0,
                        vec![rng.gen(); rng.gen_range(1..100)],
                        predicate.clone(),
                        predicate_data.clone(),
                    ),
                ]
            }};
        }

        for (i, (input_predicate, correct_gas, expected)) in
            inputs.into_iter().enumerate()
        {
            let input_group = predicate_input!(input_predicate);
            for mut input in input_group {
                if !correct_gas {
                    input.set_predicate_gas_used(1234);
                }

                let mut script = TransactionBuilder::script(
                    [op::ret(0x01)].into_iter().collect(),
                    vec![],
                )
                .add_input(input)
                .add_fee_input()
                .finalize();

                if correct_gas {
                    script
                        .estimate_predicates(
                            &CheckPredicateParams::default(),
                            MemoryInstance::new(),
                            &storage,
                        )
                        .unwrap();
                }

                let tx = script
                    .into_checked_basic(height, &Default::default())
                    .unwrap();

                let result = check_predicates(
                    &tx,
                    &CheckPredicateParams::default(),
                    MemoryInstance::new(),
                    &storage,
                );

                assert_eq!(result.map(|_| ()), expected, "failed at input {}", i);
            }
        }
    }

    /// Verifies the runtime predicate validation rules outlined in the spec are actually
    /// validated https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/index.md#predicate-verification
    #[test]
    fn inputs_are_validated_for_good_predicate_inputs() {
        const CORRECT_GAS: bool = true;
        let good_blob = vec![op::noop(), op::ret(0x01)];

        let inputs = vec![
            (
                // A valid predicate
                vec![
                    op::addi(0x10, 0x00, 0x01),
                    op::addi(0x10, 0x10, 0x01),
                    op::ret(0x01),
                ],
                CORRECT_GAS,
                Ok(()),
            ),
            (
                // Use `LDC` with mode `1` to load the blob into the predicate.
                vec![
                    // Allocate 32 byte on the heap.
                    op::movi(0x10, 32),
                    op::aloc(0x10),
                    // This will be our zeroed blob id
                    op::move_(0x10, HP),
                    // Store the size of the blob
                    op::bsiz(0x11, 0x10),
                    // Store start of the blob code
                    op::move_(0x12, SSP),
                    // Subtract the start of the code from the end of the code
                    op::sub(0x12, 0x12, IS),
                    // Divide the code by the instruction size to get the number of
                    // instructions
                    op::divi(0x12, 0x12, Instruction::SIZE as u16),
                    // Load the blob by `0x10` ID with the `0x11` size
                    op::ldc(0x10, ZERO, 0x11, 1),
                    // Jump to a new code location
                    op::jmp(0x12),
                ],
                CORRECT_GAS,
                Ok(()),
            ),
            (
                // Use `LDC` with mode `2` to load the part of the predicate from the
                // transaction.
                vec![
                    // Skip the return opcodes. One of two opcodes is a good opcode that
                    // returns `0x1`. This opcode is our source for the `LDC`
                    // opcode. We will copy return good opcode to the end
                    // of the `ssp` via `LDC`. And jump there to
                    // return `true` from the predicate.
                    op::jmpf(ZERO, 2),
                    // Bad return opcode that we want to skip.
                    op::ret(0x0),
                    // Good return opcode that we want to use for the `LDC`.
                    op::ret(0x1),
                    // Take the start of the code and move it for 2 opcodes to get the
                    // desired opcode to copy.
                    op::move_(0x10, IS),
                    // We don't need to copy `jmpf` and bad `ret` opcodes via `LDC`.
                    op::addi(0x10, 0x10, 2 * Instruction::SIZE as u16),
                    // Store end of the code
                    op::move_(0x12, SSP),
                    // Subtract the start of the code from the end of the code
                    op::sub(0x12, 0x12, IS),
                    // Divide the code by the instruction size to get the number of
                    // instructions
                    op::divi(0x12, 0x12, Instruction::SIZE as u16),
                    // We want to load only on good `ret` opcode.
                    op::movi(0x11, Instruction::SIZE as u32),
                    // Load the code from the memory address `0x10` with the `0x11` size
                    op::ldc(0x10, ZERO, 0x11, 2),
                    // Jump to a new code location
                    op::jmp(0x12),
                ],
                CORRECT_GAS,
                Ok(()),
            ),
        ];

        assert_inputs_are_validated_for_predicates(inputs, good_blob)
    }

    #[test]
    fn inputs_are_validated_for_bad_predicate_inputs() {
        const CORRECT_GAS: bool = true;
        const INCORRECT_GAS: bool = false;

        let bad_blob = vec![op::noop(), op::ret(0x00)];

        let inputs = vec![
            (
                // A valid predicate, but gas amount mismatches
                vec![
                    op::addi(0x10, 0x00, 0x01),
                    op::addi(0x10, 0x10, 0x01),
                    op::ret(0x01),
                ],
                INCORRECT_GAS,
                Err(PredicateVerificationFailed::GasMismatch),
            ),
            (
                // Returning an invalid value
                vec![op::ret(0x0)],
                CORRECT_GAS,
                Err(PredicateVerificationFailed::Panic(
                    PanicReason::PredicateReturnedNonOne,
                )),
            ),
            (
                // Using a contract instruction
                vec![op::time(0x20, 0x1), op::ret(0x1)],
                CORRECT_GAS,
                Err(PredicateVerificationFailed::PanicInstruction(
                    PanicInstruction::error(
                        PanicReason::ContractInstructionNotAllowed,
                        op::time(0x20, 0x1).into(),
                    ),
                )),
            ),
            (
                // Using a contract instruction
                vec![op::ldc(ONE, ONE, ONE, 0)],
                CORRECT_GAS,
                Err(PredicateVerificationFailed::PanicInstruction(
                    PanicInstruction::error(
                        PanicReason::ContractInstructionNotAllowed,
                        op::ldc(ONE, ONE, ONE, 0).into(),
                    ),
                )),
            ),
            (
                // Use `LDC` with mode `1` to load the blob into the predicate.
                vec![
                    // Allocate 32 byte on the heap.
                    op::movi(0x10, 32),
                    op::aloc(0x10),
                    // This will be our zeroed blob id
                    op::move_(0x10, HP),
                    // Store the size of the blob
                    op::bsiz(0x11, 0x10),
                    // Store start of the blob code
                    op::move_(0x12, SSP),
                    // Subtract the start of the code from the end of the code
                    op::sub(0x12, 0x12, IS),
                    // Divide the code by the instruction size to get the number of
                    // instructions
                    op::divi(0x12, 0x12, Instruction::SIZE as u16),
                    // Load the blob by `0x10` ID with the `0x11` size
                    op::ldc(0x10, ZERO, 0x11, 1),
                    // Jump to a new code location
                    op::jmp(0x12),
                ],
                CORRECT_GAS,
                Err(PredicateVerificationFailed::Panic(
                    PanicReason::PredicateReturnedNonOne,
                )),
            ),
            (
                // Use `LDC` with mode `2` to load the part of the predicate from the
                // transaction.
                vec![
                    // Skip the return opcodes. One of two opcodes is a bad opcode that
                    // returns `0x0`. This opcode is our source for the `LDC`
                    // opcode. We will copy return bad opcode to the end
                    // of the `ssp` via `LDC`. And jump there to
                    // return `false` from the predicate adn fail.
                    op::jmpf(ZERO, 2),
                    // Good return opcode that we want to skip.
                    op::ret(0x1),
                    // Bad return opcode that we want to use for the `LDC`.
                    op::ret(0x0),
                    // Take the start of the code and move it for 2 opcodes to get the
                    // desired opcode to copy.
                    op::move_(0x10, IS),
                    // We don't need to copy `jmpf` and bad `ret` opcodes via `LDC`.
                    op::addi(0x10, 0x10, 2 * Instruction::SIZE as u16),
                    // Store end of the code
                    op::move_(0x12, SSP),
                    // Subtract the start of the code from the end of the code
                    op::sub(0x12, 0x12, IS),
                    // Divide the code by the instruction size to get the number of
                    // instructions
                    op::divi(0x12, 0x12, Instruction::SIZE as u16),
                    // We want to load only on bad `ret` opcode.
                    op::movi(0x11, Instruction::SIZE as u32),
                    // Load the code from the memory address `0x10` with the `0x11` size
                    op::ldc(0x10, ZERO, 0x11, 2),
                    // Jump to a new code location
                    op::jmp(0x12),
                ],
                CORRECT_GAS,
                Err(PredicateVerificationFailed::Panic(
                    PanicReason::PredicateReturnedNonOne,
                )),
            ),
        ];

        assert_inputs_are_validated_for_predicates(inputs, bad_blob)
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/crypto.rs

Source
//! Crypto implementations for the instructions

use fuel_merkle::binary::root_calculator::MerkleRootCalculator as MerkleTree;
use fuel_types::Bytes32;

/// Calculate a binary merkle root with in-memory storage
pub fn ephemeral_merkle_root<L, I>(leaves: I) -> Bytes32
where
    L: AsRef<[u8]>,
    I: Iterator<Item = L> + ExactSizeIterator,
{
    let mut tree = MerkleTree::new();
    leaves.for_each(|l| tree.push(l.as_ref()));
    tree.root().into()
}

#[test]
#[cfg(feature = "random")]
fn ephemeral_merkle_root_returns_the_expected_root() {
    use fuel_crypto::Hasher;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

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

    use crate::prelude::*;

    let mut rng = StdRng::seed_from_u64(2322u64);

    const LEAF_PREFIX: u8 = 0x00;
    const NODE_PREFIX: u8 = 0x01;

    // Test for 0 leaves
    //
    // Expected root is `h()`
    let empty: Vec<Address> = vec![];

    let root = ephemeral_merkle_root(empty.iter());
    let empty = Hasher::default().digest();

    assert_eq!(empty, root);

    // Test for 5 leaves
    let a: Address = rng.gen();
    let b: Address = rng.gen();
    let c: Address = rng.gen();
    let d: Address = rng.gen();
    let e: Address = rng.gen();

    let initial = [a, b, c, d, e];

    let a = Hasher::default().chain([LEAF_PREFIX]).chain(a).digest();
    let b = Hasher::default().chain([LEAF_PREFIX]).chain(b).digest();
    let c = Hasher::default().chain([LEAF_PREFIX]).chain(c).digest();
    let d = Hasher::default().chain([LEAF_PREFIX]).chain(d).digest();
    let e = Hasher::default().chain([LEAF_PREFIX]).chain(e).digest();

    let a = Hasher::default()
        .chain([NODE_PREFIX])
        .extend_chain([a, b])
        .digest();
    let b = Hasher::default()
        .chain([NODE_PREFIX])
        .extend_chain([c, d])
        .digest();
    let c = e;

    let a = Hasher::default()
        .chain([NODE_PREFIX])
        .extend_chain([a, b])
        .digest();
    let b = c;

    let root = Hasher::default()
        .chain([NODE_PREFIX])
        .extend_chain([a, b])
        .digest();
    let root_p = ephemeral_merkle_root(initial.iter());

    assert_eq!(root, root_p);
}

/home/marten/fuel/fuel-vm/fuel-vm/src/convert.rs

Line	Count	Source
1		/// Converts value to usize is a way that's consistet on 32-bit and 64-bit platforms.
2	10.4M	pub(crate) fn to_usize(value: u64) -> Option<usize> {
3	10.4M	usize::try_from(u32::try_from(value).ok()?).ok()
4	10.4M	}

/home/marten/fuel/fuel-vm/fuel-vm/src/storage.rs

Source
//! Storage backend implementations.

use fuel_storage::Mappable;
use fuel_tx::Contract;
use fuel_types::{
    Bytes32,
    ContractId,
};

mod blob_data;
mod contracts_assets;
mod contracts_state;
mod interpreter;
#[cfg(feature = "test-helpers")]
mod memory;
pub mod predicate;

pub use blob_data::{
    BlobBytes,
    BlobData,
};
pub use contracts_assets::{
    ContractsAssetKey,
    ContractsAssets,
};
pub use contracts_state::{
    ContractsState,
    ContractsStateData,
    ContractsStateKey,
};
pub use interpreter::{
    ContractsAssetsStorage,
    InterpreterStorage,
};
#[cfg(feature = "test-helpers")]
pub use memory::MemoryStorage;

#[cfg(feature = "alloc")]
use alloc::vec::Vec;

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// The uploaded bytecode can be in two states: fully uploaded or partially uploaded.
pub enum UploadedBytecode {
    /// The bytecode is partially uploaded.
    Uncompleted {
        /// The cumulative bytecode of `uploaded_subsections_number` parts.
        bytecode: Vec<u8>,
        /// The number of already included subsections of the bytecode.
        uploaded_subsections_number: u16,
    },
    /// The bytecode is fully uploaded and ready to be used.
    Completed(Vec<u8>),
}

/// The storage table for uploaded bytecode.
pub struct UploadedBytecodes;

impl Mappable for UploadedBytecodes {
    /// The key is a Merkle root of the bytecode.
    type Key = Self::OwnedKey;
    type OwnedKey = Bytes32;
    type OwnedValue = UploadedBytecode;
    type Value = Self::OwnedValue;
}

/// The storage table for contract's raw byte code.
pub struct ContractsRawCode;

impl Mappable for ContractsRawCode {
    type Key = Self::OwnedKey;
    type OwnedKey = ContractId;
    type OwnedValue = Contract;
    type Value = [u8];
}

/// The macro defines a new type of double storage key. It is a merge of the two
/// types into one general type that represents the storage key of some entity.
///
/// Both types are represented by one big array. It is done from the performance
/// perspective to minimize the number of copies. The current code doesn't use
/// consumed values and uses it in most cases as on big key(except tests, which
/// require access to sub-keys). But in the future, we may change the layout of the
/// fields based on the performance measurements/new business logic.
#[macro_export]
macro_rules! double_key {
    (
        $i:ident, $first:ident, $first_getter:ident, $second:ident, $second_getter:ident
    ) => {
        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
        /// The FuelVM storage double key.
        pub struct $i([u8; { $first::LEN + $second::LEN }]);

        impl Default for $i {
            fn default() -> Self {
                Self([0; { Self::second_end() }])
            }
        }

        impl $i {
            /// The length of the underlying array.
            pub const LEN: usize = $first::LEN + $second::LEN;

            /// Create a new instance of the double storage key from references.
            pub fn new(first: &$first, second: &$second) -> Self {
                let mut default = Self::default();
                default.0[0..Self::first_end()].copy_from_slice(first.as_ref());
                default.0[Self::first_end()..Self::second_end()]
                    .copy_from_slice(second.as_ref());
                default
            }

            /// Creates a new instance of double storage key from the array.
            pub fn from_array(array: [u8; { $first::LEN + $second::LEN }]) -> Self {
                Self(array)
            }

            /// Creates a new instance of double storage key from the slice.
            pub fn from_slice(
                slice: &[u8],
            ) -> Result<Self, core::array::TryFromSliceError> {
                Ok(Self(slice.try_into()?))
            }

            /// Returns the reference to the first sub-key.
            pub fn $first_getter(&self) -> &$first {
                $first::from_bytes_ref(
                    (&self.0[0..Self::first_end()])
                        .try_into()
                        .expect("0..first_end() < first_end() + second_end()"),
                )
            }

            /// Returns the reference to the second sub-key.
            pub fn $second_getter(&self) -> &$second {
                $second::from_bytes_ref(
                    (&self.0[Self::first_end()..Self::second_end()])
                        .try_into()
                        .expect("first_end()..second_end() < first_end() + second_end()"),
                )
            }

            const fn first_end() -> usize {
                $first::LEN
            }

            const fn second_end() -> usize {
                $first::LEN + $second::LEN
            }
        }

        impl From<(&$first, &$second)> for $i {
            fn from(pair: (&$first, &$second)) -> Self {
                Self::new(pair.0, pair.1)
            }
        }

        impl AsRef<[u8]> for $i {
            fn as_ref(&self) -> &[u8] {
                self.0.as_ref()
            }
        }

        impl From<$i> for ($first, $second) {
            fn from(key: $i) -> ($first, $second) {
                let first = &key.0[0..$i::first_end()];
                let second = &key.0[$i::first_end()..$i::second_end()];
                let first = first.try_into().unwrap();
                let second = second.try_into().unwrap();
                (first, second)
            }
        }

        impl From<$i> for [u8; { $first::LEN + $second::LEN }] {
            fn from(key: $i) -> [u8; { $first::LEN + $second::LEN }] {
                key.0
            }
        }

        impl TryFrom<&[u8]> for $i {
            type Error = core::array::TryFromSliceError;

            fn try_from(slice: &[u8]) -> Result<Self, Self::Error> {
                $i::from_slice(slice)
            }
        }

        #[cfg(feature = "serde")]
        impl serde::Serialize for $i {
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                use serde_with::SerializeAs;
                serde_with::Bytes::serialize_as(&self.0, serializer)
            }
        }

        #[cfg(feature = "serde")]
        impl<'a> serde::Deserialize<'a> for $i {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'a>,
            {
                use serde_with::DeserializeAs;
                let bytes: [u8; $i::LEN] =
                    serde_with::Bytes::deserialize_as(deserializer)?;
                Ok(Self(bytes))
            }
        }
    };
}

/home/marten/fuel/fuel-vm/fuel-vm/src/transactor.rs

Source
//! State machine of the interpreter.

use crate::{
    backtrace::Backtrace,
    checked_transaction::{
        Checked,
        IntoChecked,
        Ready,
    },
    error::InterpreterError,
    interpreter::{
        CheckedMetadata,
        EcalHandler,
        ExecutableTransaction,
        Interpreter,
        InterpreterParams,
        Memory,
        NotSupportedEcal,
    },
    state::{
        ProgramState,
        StateTransition,
        StateTransitionRef,
    },
    storage::InterpreterStorage,
};
use fuel_tx::{
    Blob,
    Create,
    FeeParameters,
    GasCosts,
    Receipt,
    Script,
    Upgrade,
    Upload,
};

#[cfg(any(test, feature = "test-helpers"))]
use crate::interpreter::MemoryInstance;

#[derive(Debug)]
/// State machine to execute transactions and provide runtime entities on
/// demand.
///
/// Builder pattern for [`Interpreter`]. Follows the recommended `Non-consuming
/// builder`.
///
/// Based on <https://doc.rust-lang.org/1.5.0/style/ownership/builders.html#non-consuming-builders-preferred>
pub struct Transactor<M, S, Tx, Ecal = NotSupportedEcal>
where
    S: InterpreterStorage,
{
    interpreter: Interpreter<M, S, Tx, Ecal>,
    program_state: Option<ProgramState>,
    error: Option<InterpreterError<S::DataError>>,
}

impl<M, S, Tx, Ecal> Transactor<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler + Default,
{
    /// Transactor constructor
    pub fn new(memory: M, storage: S, interpreter_params: InterpreterParams) -> Self {
        Self {
            interpreter: Interpreter::<M, S, Tx, Ecal>::with_storage(
                memory,
                storage,
                interpreter_params,
            ),
            program_state: None,
            error: None,
        }
    }
}
impl<M, S, Tx, Ecal> Transactor<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler,
{
    /// State transition representation after the execution of a transaction.
    ///
    /// Will be `None` if the last transaction resulted in a VM panic, or if no
    /// transaction was executed.
    pub fn state_transition(&self) -> Option<StateTransitionRef<'_, Tx>> {
        self.program_state.map(|state| {
            StateTransitionRef::new(
                state,
                self.interpreter.transaction(),
                self.interpreter.receipts(),
            )
        })
    }

    /// State transition representation after the execution of a transaction.
    ///
    /// Will be `None` if the last transaction resulted in a VM panic, or if no
    /// transaction was executed.
    pub fn to_owned_state_transition(&self) -> Option<StateTransition<Tx>> {
        self.program_state.map(|state| {
            StateTransition::new(
                state,
                self.interpreter.transaction().clone(),
                self.interpreter.receipts().to_vec(),
            )
        })
    }

    /// Interpreter error representation after the execution of a transaction.
    ///
    /// Follows the same criteria as [`Self::state_transition`] to return
    /// `None`.
    ///
    /// Will be `None` if the last transaction resulted successful, or if no
    /// transaction was executed.
    pub const fn error(&self) -> Option<&InterpreterError<S::DataError>> {
        self.error.as_ref()
    }

    /// Returns true if last transaction execution was successful
    pub const fn is_success(&self) -> bool {
        !self.is_reverted()
    }

    /// Returns true if last transaction execution was erroneous
    pub const fn is_reverted(&self) -> bool {
        self.error.is_some()
            || matches!(self.program_state, Some(ProgramState::Revert(_)))
    }

    /// Result representation of the last executed transaction.
    ///
    /// Will return `None` if no transaction was executed.
    pub fn result(
        &self,
    ) -> Result<StateTransitionRef<'_, Tx>, &InterpreterError<S::DataError>> {
        let state = self.state_transition();
        let error = self.error.as_ref();

        match (state, error) {
            (Some(s), None) => Ok(s),
            (None, Some(e)) => Err(e),

            // Cover also inconsistent states such as `(Some, Some)`
            _ => Err(&InterpreterError::NoTransactionInitialized),
        }
    }

    /// Gets the interpreter.
    pub fn interpreter(&self) -> &Interpreter<M, S, Tx, Ecal> {
        &self.interpreter
    }

    /// Gas costs of opcodes
    pub fn gas_costs(&self) -> &GasCosts {
        self.interpreter.gas_costs()
    }

    /// Fee parameters
    pub fn fee_params(&self) -> &FeeParameters {
        self.interpreter.fee_params()
    }

    #[cfg(feature = "test-helpers")]
    /// Sets the gas price of the `Interpreter`
    pub fn set_gas_price(&mut self, gas_price: u64) {
        self.interpreter.set_gas_price(gas_price);
    }

    /// Tx memory offset
    pub fn tx_offset(&self) -> usize {
        self.interpreter.tx_offset()
    }
}

impl<M, S, Ecal> Transactor<M, S, Script, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
{
    /// Receipts after the execution of a transaction.
    ///
    /// Follows the same criteria as [`Self::state_transition`] to return
    /// `None`.
    pub fn receipts(&self) -> Option<&[Receipt]> {
        self.program_state
            .is_some()
            .then(|| self.interpreter.receipts())
    }

    /// Generate a backtrace when at least one receipt of `ScriptResult` was
    /// found.
    pub fn backtrace(&self) -> Option<Backtrace> {
        self.receipts()
            .and_then(|r| r.iter().find_map(Receipt::result))
            .copied()
            .map(|result| Backtrace::from_vm_error(&self.interpreter, result))
    }
}

impl<M, S, Tx, Ecal> Transactor<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    /// Deploys `Create` checked transactions.
    pub fn deploy(
        &mut self,
        checked: Checked<Create>,
    ) -> Result<Create, InterpreterError<S::DataError>> {
        let gas_price = self.interpreter.gas_price();
        let gas_costs = self.interpreter.gas_costs();
        let fee_params = self.interpreter.fee_params();

        let ready = checked
            .into_ready(gas_price, gas_costs, fee_params)
            .map_err(InterpreterError::CheckError)?;

        self.deploy_ready_tx(ready)
    }

    /// Deployt a `Ready` transaction directly instead of letting `Transactor` construct
    pub fn deploy_ready_tx(
        &mut self,
        ready_tx: Ready<Create>,
    ) -> Result<Create, InterpreterError<S::DataError>> {
        self.interpreter.deploy(ready_tx)
    }

    /// Executes `Upgrade` checked transactions.
    pub fn upgrade(
        &mut self,
        checked: Checked<Upgrade>,
    ) -> Result<Upgrade, InterpreterError<S::DataError>> {
        let gas_price = self.interpreter.gas_price();
        let gas_costs = self.interpreter.gas_costs();
        let fee_params = self.interpreter.fee_params();

        let ready = checked
            .into_ready(gas_price, gas_costs, fee_params)
            .map_err(InterpreterError::CheckError)?;

        self.execute_ready_upgrade_tx(ready)
    }

    /// Executes a `Ready` transaction directly instead of letting `Transactor` construct
    pub fn execute_ready_upgrade_tx(
        &mut self,
        ready_tx: Ready<Upgrade>,
    ) -> Result<Upgrade, InterpreterError<S::DataError>> {
        self.interpreter.upgrade(ready_tx)
    }

    /// Executes `Upload` checked transactions.
    pub fn upload(
        &mut self,
        checked: Checked<Upload>,
    ) -> Result<Upload, InterpreterError<S::DataError>> {
        let gas_price = self.interpreter.gas_price();
        let gas_costs = self.interpreter.gas_costs();
        let fee_params = self.interpreter.fee_params();

        let ready = checked
            .into_ready(gas_price, gas_costs, fee_params)
            .map_err(InterpreterError::CheckError)?;

        self.execute_ready_upload_tx(ready)
    }

    /// Executes a `Ready` transaction directly instead of letting `Transactor` construct
    pub fn execute_ready_upload_tx(
        &mut self,
        ready_tx: Ready<Upload>,
    ) -> Result<Upload, InterpreterError<S::DataError>> {
        self.interpreter.upload(ready_tx)
    }

    /// Executes `Blob` checked transactions.
    pub fn blob(
        &mut self,
        checked: Checked<Blob>,
    ) -> Result<Blob, InterpreterError<S::DataError>> {
        let gas_price = self.interpreter.gas_price();
        let gas_costs = self.interpreter.gas_costs();
        let fee_params = self.interpreter.fee_params();

        let ready = checked
            .into_ready(gas_price, gas_costs, fee_params)
            .map_err(InterpreterError::CheckError)?;

        self.execute_ready_blob_tx(ready)
    }

    /// Executes a `Ready` transaction directly instead of letting `Transactor` construct
    pub fn execute_ready_blob_tx(
        &mut self,
        ready_tx: Ready<Blob>,
    ) -> Result<Blob, InterpreterError<S::DataError>> {
        self.interpreter.blob(ready_tx)
    }
}

impl<M, S, Tx, Ecal> Transactor<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,
    Ecal: EcalHandler,
{
    /// Execute a transaction, and return the new state of the transactor
    pub fn transact(&mut self, tx: Checked<Tx>) -> &mut Self {
        let gas_price = self.interpreter.gas_price();
        let gas_costs = self.interpreter.gas_costs();
        let fee_params = self.interpreter.fee_params();

        match tx
            .into_ready(gas_price, gas_costs, fee_params)
            .map_err(InterpreterError::CheckError)
        {
            Ok(ready_tx) => self.transact_ready_tx(ready_tx),
            Err(e) => self.handle_error(e),
        }
    }

    /// Transact a `Ready` transaction directly instead of letting `Transactor` construct
    pub fn transact_ready_tx(&mut self, ready_tx: Ready<Tx>) -> &mut Self {
        match self.interpreter.transact(ready_tx) {
            Ok(s) => {
                self.program_state.replace(s.into());
                self.error.take();
                self
            }

            Err(e) => self.handle_error(e),
        }
    }

    fn handle_error(&mut self, error: InterpreterError<S::DataError>) -> &mut Self {
        self.program_state.take();
        self.error.replace(error);
        self
    }
}

impl<M, S, Tx, Ecal> From<Interpreter<M, S, Tx, Ecal>> for Transactor<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    fn from(interpreter: Interpreter<M, S, Tx, Ecal>) -> Self {
        let program_state = None;
        let error = None;

        Self {
            interpreter,
            program_state,
            error,
        }
    }
}

impl<M, S, Tx, Ecal> From<Transactor<M, S, Tx, Ecal>> for Interpreter<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    fn from(transactor: Transactor<M, S, Tx, Ecal>) -> Self {
        transactor.interpreter
    }
}

impl<M, S, Tx, Ecal> AsRef<Interpreter<M, S, Tx, Ecal>> for Transactor<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
    Ecal: EcalHandler,
{
    fn as_ref(&self) -> &Interpreter<M, S, Tx, Ecal> {
        &self.interpreter
    }
}

impl<M, S, Tx, Ecal> AsRef<S> for Transactor<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    fn as_ref(&self) -> &S {
        self.interpreter.as_ref()
    }
}

impl<M, S, Tx, Ecal> AsMut<S> for Transactor<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    fn as_mut(&mut self) -> &mut S {
        self.interpreter.as_mut()
    }
}

#[cfg(feature = "test-helpers")]
impl<S, Tx, Ecal> Default for Transactor<MemoryInstance, S, Tx, Ecal>
where
    S: InterpreterStorage + Default,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler + Default,
{
    fn default() -> Self {
        Self::new(
            MemoryInstance::new(),
            S::default(),
            InterpreterParams::default(),
        )
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/checked_transaction.rs

Source
//! A checked transaction is type-wrapper for transactions which have been checked.
//! It is impossible to construct a checked transaction without performing necessary
//! checks.
//!
//! This allows the VM to accept transactions with metadata that have been already
//! verified upstream.

#![allow(non_upper_case_globals)]

use fuel_tx::{
    Create,
    Mint,
    Script,
    Transaction,
    ValidityError,
};
use fuel_types::{
    BlockHeight,
    ChainId,
};

use alloc::{
    boxed::Box,
    vec::Vec,
};
use core::{
    borrow::Borrow,
    fmt::Debug,
    future::Future,
};
use fuel_tx::{
    field::MaxFeeLimit,
    ConsensusParameters,
};

mod balances;
#[cfg(feature = "test-helpers")]
pub mod builder;
pub mod types;

pub use types::*;

use crate::{
    error::PredicateVerificationFailed,
    interpreter::{
        Memory,
        MemoryInstance,
    },
    pool::VmMemoryPool,
    prelude::*,
    storage::predicate::{
        EmptyStorage,
        PredicateStorageProvider,
        PredicateStorageRequirements,
    },
};

bitflags::bitflags! {
    /// Possible types of transaction checks.
    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
    pub struct Checks: u32 {
        /// Basic checks defined in the specification for each transaction:
        /// https://github.com/FuelLabs/fuel-specs/blob/master/src/tx-format/transaction.md#transaction
        /// Also ensures that malleable fields are zeroed.
        const Basic         = 0b00000001;
        /// Check that signature in the transactions are valid.
        const Signatures    = 0b00000010;
        /// Check that predicate in the transactions are valid.
        const Predicates    = 0b00000100;
    }
}

impl core::fmt::Display for Checks {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        write!(f, "{:032b}", self.bits())
    }
}

/// The type describes that the inner transaction was already checked.
///
/// All fields are private, and there is no constructor, so it is impossible to create the
/// instance of `Checked` outside the `fuel-tx` crate.
///
/// The inner data is immutable to prevent modification to invalidate the checking.
///
/// If you need to modify an inner state, you need to get inner values
/// (via the `Into<(Tx, Tx ::Metadata)>` trait), modify them and check again.
///
/// # Dev note: Avoid serde serialization of this type.
///
/// Since checked tx would need to be re-validated on deserialization anyways,
/// it's cleaner to redo the tx check.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct Checked<Tx: IntoChecked> {
    transaction: Tx,
    metadata: Tx::Metadata,
    checks_bitmask: Checks,
}

impl<Tx: IntoChecked> Checked<Tx> {
    fn new(transaction: Tx, metadata: Tx::Metadata, checks_bitmask: Checks) -> Self {
        Checked {
            transaction,
            metadata,
            checks_bitmask,
        }
    }

    pub(crate) fn basic(transaction: Tx, metadata: Tx::Metadata) -> Self {
        Checked::new(transaction, metadata, Checks::Basic)
    }

    /// Returns reference on inner transaction.
    pub fn transaction(&self) -> &Tx {
        &self.transaction
    }

    /// Returns the metadata generated during the check for transaction.
    pub fn metadata(&self) -> &Tx::Metadata {
        &self.metadata
    }

    /// Returns the bitmask of all passed checks.
    pub fn checks(&self) -> &Checks {
        &self.checks_bitmask
    }

    /// Performs check of signatures, if not yet done.
    pub fn check_signatures(mut self, chain_id: &ChainId) -> Result<Self, CheckError> {
        if !self.checks_bitmask.contains(Checks::Signatures) {
            self.transaction.check_signatures(chain_id)?;
            self.checks_bitmask.insert(Checks::Signatures);
        }
        Ok(self)
    }
}

/// Transaction that has checks for all dynamic values, e.g. `gas_price`
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct Ready<Tx: IntoChecked> {
    gas_price: Word,
    transaction: Tx,
    metadata: Tx::Metadata,
    checks_bitmask: Checks,
}

impl<Tx: IntoChecked> Ready<Tx> {
    /// Consume and decompose components of the `Immutable` transaction.
    pub fn decompose(self) -> (Word, Checked<Tx>) {
        let Ready {
            gas_price,
            transaction,
            metadata,
            checks_bitmask,
        } = self;
        let checked = Checked::new(transaction, metadata, checks_bitmask);
        (gas_price, checked)
    }

    /// Getter for `gas_price` field
    pub fn gas_price(&self) -> Word {
        self.gas_price
    }
}

#[cfg(feature = "test-helpers")]
impl<Tx: IntoChecked> Checked<Tx> {
    /// Convert `Checked` into `Ready` without performing final checks.
    pub fn test_into_ready(self) -> Ready<Tx> {
        let Checked {
            transaction,
            metadata,
            checks_bitmask,
        } = self;
        Ready {
            gas_price: 0,
            transaction,
            metadata,
            checks_bitmask,
        }
    }
}

impl<Tx: IntoChecked + Chargeable> Checked<Tx> {
    /// Run final checks on `Checked` using dynamic values, e.g. `gas_price`
    pub fn into_ready(
        self,
        gas_price: Word,
        gas_costs: &GasCosts,
        fee_parameters: &FeeParameters,
    ) -> Result<Ready<Tx>, CheckError> {
        let Checked {
            transaction,
            metadata,
            checks_bitmask,
        } = self;
        let fee = TransactionFee::checked_from_tx(
            gas_costs,
            fee_parameters,
            &transaction,
            gas_price,
        )
        .ok_or(CheckError::Validity(ValidityError::BalanceOverflow))?;

        let max_fee_from_policies = transaction.max_fee_limit();
        let max_fee_from_gas_price = fee.max_fee();

        if max_fee_from_gas_price > max_fee_from_policies {
            Err(CheckError::InsufficientMaxFee {
                max_fee_from_policies,
                max_fee_from_gas_price,
            })
        } else {
            Ok(Ready {
                gas_price,
                transaction,
                metadata,
                checks_bitmask,
            })
        }
    }
}

impl<Tx: IntoChecked + UniqueIdentifier> Checked<Tx> {
    /// Returns the transaction ID from the computed metadata
    pub fn id(&self) -> TxId {
        self.transaction
            .cached_id()
            .expect("Transaction metadata should be computed for checked transactions")
    }
}

#[cfg(feature = "test-helpers")]
impl<Tx: IntoChecked + Default> Default for Checked<Tx>
where
    Checked<Tx>: CheckPredicates,
{
    fn default() -> Self {
        Tx::default()
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect("default tx should produce a valid fully checked transaction")
    }
}

impl<Tx: IntoChecked> From<Checked<Tx>> for (Tx, Tx::Metadata) {
    fn from(checked: Checked<Tx>) -> Self {
        let Checked {
            transaction,
            metadata,
            ..
        } = checked;

        (transaction, metadata)
    }
}

impl<Tx: IntoChecked> AsRef<Tx> for Checked<Tx> {
    fn as_ref(&self) -> &Tx {
        &self.transaction
    }
}

#[cfg(feature = "test-helpers")]
impl<Tx: IntoChecked> AsMut<Tx> for Checked<Tx> {
    fn as_mut(&mut self) -> &mut Tx {
        &mut self.transaction
    }
}

impl<Tx: IntoChecked> Borrow<Tx> for Checked<Tx> {
    fn borrow(&self) -> &Tx {
        self.transaction()
    }
}

/// The error can occur when transforming transactions into the `Checked` type.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum CheckError {
    /// The transaction doesn't pass validity rules.
    Validity(ValidityError),
    /// The predicate verification failed.
    PredicateVerificationFailed(PredicateVerificationFailed),
    /// The max fee used during checking was lower than calculated during `Immutable`
    /// conversion
    InsufficientMaxFee {
        /// The max fee from the policies defined by the user.
        max_fee_from_policies: Word,
        /// The max fee calculated from the gas price and gas used by the transaction.
        max_fee_from_gas_price: Word,
    },
}

/// Performs checks for a transaction
pub trait IntoChecked: FormatValidityChecks + Sized {
    /// Metadata produced during the check.
    type Metadata: Sized;

    /// Returns transaction that passed all `Checks`.
    fn into_checked(
        self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<Checked<Self>, CheckError>
    where
        Checked<Self>: CheckPredicates,
    {
        self.into_checked_reusable_memory(
            block_height,
            consensus_params,
            MemoryInstance::new(),
            &EmptyStorage,
        )
    }

    /// Returns transaction that passed all `Checks` accepting reusable memory
    /// to run predicates.
    fn into_checked_reusable_memory(
        self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<Checked<Self>, CheckError>
    where
        Checked<Self>: CheckPredicates,
    {
        let check_predicate_params = consensus_params.into();
        self.into_checked_basic(block_height, consensus_params)?
            .check_signatures(&consensus_params.chain_id())?
            .check_predicates(&check_predicate_params, memory, storage)
    }

    /// Returns transaction that passed only `Checks::Basic`.
    fn into_checked_basic(
        self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<Checked<Self>, CheckError>;
}

/// The parameters needed for checking a predicate
#[derive(Debug, Clone)]
pub struct CheckPredicateParams {
    /// Gas costs for opcodes
    pub gas_costs: GasCosts,
    /// Chain ID
    pub chain_id: ChainId,
    /// Maximum gas per predicate
    pub max_gas_per_predicate: u64,
    /// Maximum gas per transaction
    pub max_gas_per_tx: u64,
    /// Maximum number of inputs
    pub max_inputs: u16,
    /// Maximum size of the contract in bytes
    pub contract_max_size: u64,
    /// Maximum length of the message data
    pub max_message_data_length: u64,
    /// Offset of the transaction data in the memory
    pub tx_offset: usize,
    /// Fee parameters
    pub fee_params: FeeParameters,
    /// Base Asset ID
    pub base_asset_id: AssetId,
}

#[cfg(feature = "test-helpers")]
impl Default for CheckPredicateParams {
    fn default() -> Self {
        CheckPredicateParams::from(&ConsensusParameters::standard())
    }
}

impl From<ConsensusParameters> for CheckPredicateParams {
    fn from(value: ConsensusParameters) -> Self {
        CheckPredicateParams::from(&value)
    }
}

impl From<&ConsensusParameters> for CheckPredicateParams {
    fn from(value: &ConsensusParameters) -> Self {
        CheckPredicateParams {
            gas_costs: value.gas_costs().clone(),
            chain_id: value.chain_id(),
            max_gas_per_predicate: value.predicate_params().max_gas_per_predicate(),
            max_gas_per_tx: value.tx_params().max_gas_per_tx(),
            max_inputs: value.tx_params().max_inputs(),
            contract_max_size: value.contract_params().contract_max_size(),
            max_message_data_length: value.predicate_params().max_message_data_length(),
            tx_offset: value.tx_params().tx_offset(),
            fee_params: *(value.fee_params()),
            base_asset_id: *value.base_asset_id(),
        }
    }
}

/// Provides predicate verification functionality for the transaction.
#[async_trait::async_trait]
pub trait CheckPredicates: Sized {
    /// Performs predicates verification of the transaction.
    fn check_predicates(
        self,
        params: &CheckPredicateParams,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<Self, CheckError>;

    /// Performs predicates verification of the transaction in parallel.
    async fn check_predicates_async<E: ParallelExecutor>(
        self,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<Self, CheckError>;
}

/// Provides predicate estimation functionality for the transaction.
#[async_trait::async_trait]
pub trait EstimatePredicates: Sized {
    /// Estimates predicates of the transaction.
    fn estimate_predicates(
        &mut self,
        params: &CheckPredicateParams,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<(), CheckError>;

    /// Estimates predicates of the transaction in parallel.
    async fn estimate_predicates_async<E: ParallelExecutor>(
        &mut self,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<(), CheckError>;
}

/// Executes CPU-heavy tasks in parallel.
#[async_trait::async_trait]
pub trait ParallelExecutor {
    /// Future created from a CPU-heavy task.
    type Task: Future + Send + 'static;

    /// Creates a Future from a CPU-heavy task.
    fn create_task<F>(func: F) -> Self::Task
    where
        F: FnOnce() -> Result<(Word, usize), PredicateVerificationFailed>
            + Send
            + 'static;

    /// Executes tasks created by `create_task` in parallel.
    async fn execute_tasks(
        futures: Vec<Self::Task>,
    ) -> Vec<Result<(Word, usize), PredicateVerificationFailed>>;
}

#[async_trait::async_trait]
impl<Tx> CheckPredicates for Checked<Tx>
where
    Tx: ExecutableTransaction + Send + Sync + 'static,
    <Tx as IntoChecked>::Metadata: crate::interpreter::CheckedMetadata + Send + Sync,
{
    fn check_predicates(
        mut self,
        params: &CheckPredicateParams,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<Self, CheckError> {
        if !self.checks_bitmask.contains(Checks::Predicates) {
            predicates::check_predicates(&self, params, memory, storage)?;
            self.checks_bitmask.insert(Checks::Predicates);
        }
        Ok(self)
    }

    async fn check_predicates_async<E>(
        mut self,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<Self, CheckError>
    where
        E: ParallelExecutor,
    {
        if !self.checks_bitmask.contains(Checks::Predicates) {
            predicates::check_predicates_async::<Tx, E>(&self, params, pool, storage)
                .await?;

            self.checks_bitmask.insert(Checks::Predicates);

            Ok(self)
        } else {
            Ok(self)
        }
    }
}

#[async_trait::async_trait]
impl<Tx: ExecutableTransaction + Send + Sync + 'static> EstimatePredicates for Tx {
    fn estimate_predicates(
        &mut self,
        params: &CheckPredicateParams,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<(), CheckError> {
        predicates::estimate_predicates(self, params, memory, storage)?;
        Ok(())
    }

    async fn estimate_predicates_async<E>(
        &mut self,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<(), CheckError>
    where
        E: ParallelExecutor,
    {
        predicates::estimate_predicates_async::<Self, E>(self, params, pool, storage)
            .await?;

        Ok(())
    }
}

#[async_trait::async_trait]
impl EstimatePredicates for Transaction {
    fn estimate_predicates(
        &mut self,
        params: &CheckPredicateParams,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<(), CheckError> {
        match self {
            Self::Script(tx) => tx.estimate_predicates(params, memory, storage),
            Self::Create(tx) => tx.estimate_predicates(params, memory, storage),
            Self::Mint(_) => Ok(()),
            Self::Upgrade(tx) => tx.estimate_predicates(params, memory, storage),
            Self::Upload(tx) => tx.estimate_predicates(params, memory, storage),
            Self::Blob(tx) => tx.estimate_predicates(params, memory, storage),
        }
    }

    async fn estimate_predicates_async<E: ParallelExecutor>(
        &mut self,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<(), CheckError> {
        match self {
            Self::Script(tx) => {
                tx.estimate_predicates_async::<E>(params, pool, storage)
                    .await
            }
            Self::Create(tx) => {
                tx.estimate_predicates_async::<E>(params, pool, storage)
                    .await
            }
            Self::Mint(_) => Ok(()),
            Self::Upgrade(tx) => {
                tx.estimate_predicates_async::<E>(params, pool, storage)
                    .await
            }
            Self::Upload(tx) => {
                tx.estimate_predicates_async::<E>(params, pool, storage)
                    .await
            }
            Self::Blob(tx) => {
                tx.estimate_predicates_async::<E>(params, pool, storage)
                    .await
            }
        }
    }
}

#[async_trait::async_trait]
impl CheckPredicates for Checked<Mint> {
    fn check_predicates(
        mut self,
        _params: &CheckPredicateParams,
        _memory: impl Memory,
        _storage: &impl PredicateStorageRequirements,
    ) -> Result<Self, CheckError> {
        self.checks_bitmask.insert(Checks::Predicates);
        Ok(self)
    }

    async fn check_predicates_async<E: ParallelExecutor>(
        mut self,
        _params: &CheckPredicateParams,
        _pool: &impl VmMemoryPool,
        _storage: &impl PredicateStorageProvider,
    ) -> Result<Self, CheckError> {
        self.checks_bitmask.insert(Checks::Predicates);
        Ok(self)
    }
}

#[async_trait::async_trait]
impl CheckPredicates for Checked<Transaction> {
    fn check_predicates(
        self,
        params: &CheckPredicateParams,
        memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<Self, CheckError> {
        let checked_transaction: CheckedTransaction = self.into();
        let checked_transaction: CheckedTransaction = match checked_transaction {
            CheckedTransaction::Script(tx) => {
                CheckPredicates::check_predicates(tx, params, memory, storage)?.into()
            }
            CheckedTransaction::Create(tx) => {
                CheckPredicates::check_predicates(tx, params, memory, storage)?.into()
            }
            CheckedTransaction::Mint(tx) => {
                CheckPredicates::check_predicates(tx, params, memory, storage)?.into()
            }
            CheckedTransaction::Upgrade(tx) => {
                CheckPredicates::check_predicates(tx, params, memory, storage)?.into()
            }
            CheckedTransaction::Upload(tx) => {
                CheckPredicates::check_predicates(tx, params, memory, storage)?.into()
            }
            CheckedTransaction::Blob(tx) => {
                CheckPredicates::check_predicates(tx, params, memory, storage)?.into()
            }
        };
        Ok(checked_transaction.into())
    }

    async fn check_predicates_async<E>(
        mut self,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<Self, CheckError>
    where
        E: ParallelExecutor,
    {
        let checked_transaction: CheckedTransaction = self.into();

        let checked_transaction: CheckedTransaction = match checked_transaction {
            CheckedTransaction::Script(tx) => {
                CheckPredicates::check_predicates_async::<E>(tx, params, pool, storage)
                    .await?
                    .into()
            }
            CheckedTransaction::Create(tx) => {
                CheckPredicates::check_predicates_async::<E>(tx, params, pool, storage)
                    .await?
                    .into()
            }
            CheckedTransaction::Mint(tx) => {
                CheckPredicates::check_predicates_async::<E>(tx, params, pool, storage)
                    .await?
                    .into()
            }
            CheckedTransaction::Upgrade(tx) => {
                CheckPredicates::check_predicates_async::<E>(tx, params, pool, storage)
                    .await?
                    .into()
            }
            CheckedTransaction::Upload(tx) => {
                CheckPredicates::check_predicates_async::<E>(tx, params, pool, storage)
                    .await?
                    .into()
            }
            CheckedTransaction::Blob(tx) => {
                CheckPredicates::check_predicates_async::<E>(tx, params, pool, storage)
                    .await?
                    .into()
            }
        };

        Ok(checked_transaction.into())
    }
}

/// The Enum version of `Checked<Transaction>` allows getting the inner variant without
/// losing "checked" status.
///
/// It is possible to freely convert `Checked<Transaction>` into `CheckedTransaction` and
/// vice verse without the overhead.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
#[allow(missing_docs)]
pub enum CheckedTransaction {
    Script(Checked<Script>),
    Create(Checked<Create>),
    Mint(Checked<Mint>),
    Upgrade(Checked<Upgrade>),
    Upload(Checked<Upload>),
    Blob(Checked<Blob>),
}

impl From<Checked<Transaction>> for CheckedTransaction {
    fn from(checked: Checked<Transaction>) -> Self {
        let Checked {
            transaction,
            metadata,
            checks_bitmask,
        } = checked;

        // # Dev note: Avoid wildcard pattern to be sure that all variants are covered.
        match (transaction, metadata) {
            (Transaction::Script(transaction), CheckedMetadata::Script(metadata)) => {
                Self::Script(Checked::new(transaction, metadata, checks_bitmask))
            }
            (Transaction::Create(transaction), CheckedMetadata::Create(metadata)) => {
                Self::Create(Checked::new(transaction, metadata, checks_bitmask))
            }
            (Transaction::Mint(transaction), CheckedMetadata::Mint(metadata)) => {
                Self::Mint(Checked::new(transaction, metadata, checks_bitmask))
            }
            (Transaction::Upgrade(transaction), CheckedMetadata::Upgrade(metadata)) => {
                Self::Upgrade(Checked::new(transaction, metadata, checks_bitmask))
            }
            (Transaction::Upload(transaction), CheckedMetadata::Upload(metadata)) => {
                Self::Upload(Checked::new(transaction, metadata, checks_bitmask))
            }
            (Transaction::Blob(transaction), CheckedMetadata::Blob(metadata)) => {
                Self::Blob(Checked::new(transaction, metadata, checks_bitmask))
            }
            // The code should produce the `CheckedMetadata` for the corresponding
            // transaction variant. It is done in the implementation of the
            // `IntoChecked` trait for `Transaction`. With the current
            // implementation, the patterns below are unreachable.
            (Transaction::Script(_), _) => unreachable!(),
            (Transaction::Create(_), _) => unreachable!(),
            (Transaction::Mint(_), _) => unreachable!(),
            (Transaction::Upgrade(_), _) => unreachable!(),
            (Transaction::Upload(_), _) => unreachable!(),
            (Transaction::Blob(_), _) => unreachable!(),
        }
    }
}

impl From<Checked<Script>> for CheckedTransaction {
    fn from(checked: Checked<Script>) -> Self {
        Self::Script(checked)
    }
}

impl From<Checked<Create>> for CheckedTransaction {
    fn from(checked: Checked<Create>) -> Self {
        Self::Create(checked)
    }
}

impl From<Checked<Mint>> for CheckedTransaction {
    fn from(checked: Checked<Mint>) -> Self {
        Self::Mint(checked)
    }
}

impl From<Checked<Upgrade>> for CheckedTransaction {
    fn from(checked: Checked<Upgrade>) -> Self {
        Self::Upgrade(checked)
    }
}

impl From<Checked<Upload>> for CheckedTransaction {
    fn from(checked: Checked<Upload>) -> Self {
        Self::Upload(checked)
    }
}

impl From<Checked<Blob>> for CheckedTransaction {
    fn from(checked: Checked<Blob>) -> Self {
        Self::Blob(checked)
    }
}

impl From<CheckedTransaction> for Checked<Transaction> {
    fn from(checked: CheckedTransaction) -> Self {
        match checked {
            CheckedTransaction::Script(Checked {
                transaction,
                metadata,
                checks_bitmask,
            }) => Checked::new(transaction.into(), metadata.into(), checks_bitmask),
            CheckedTransaction::Create(Checked {
                transaction,
                metadata,
                checks_bitmask,
            }) => Checked::new(transaction.into(), metadata.into(), checks_bitmask),
            CheckedTransaction::Mint(Checked {
                transaction,
                metadata,
                checks_bitmask,
            }) => Checked::new(transaction.into(), metadata.into(), checks_bitmask),
            CheckedTransaction::Upgrade(Checked {
                transaction,
                metadata,
                checks_bitmask,
            }) => Checked::new(transaction.into(), metadata.into(), checks_bitmask),
            CheckedTransaction::Upload(Checked {
                transaction,
                metadata,
                checks_bitmask,
            }) => Checked::new(transaction.into(), metadata.into(), checks_bitmask),
            CheckedTransaction::Blob(Checked {
                transaction,
                metadata,
                checks_bitmask,
            }) => Checked::new(transaction.into(), metadata.into(), checks_bitmask),
        }
    }
}

/// The `IntoChecked` metadata for `CheckedTransaction`.
#[derive(Debug, Clone, Eq, PartialEq, Hash)]
#[allow(missing_docs)]
pub enum CheckedMetadata {
    Script(<Script as IntoChecked>::Metadata),
    Create(<Create as IntoChecked>::Metadata),
    Mint(<Mint as IntoChecked>::Metadata),
    Upgrade(<Upgrade as IntoChecked>::Metadata),
    Upload(<Upload as IntoChecked>::Metadata),
    Blob(<Blob as IntoChecked>::Metadata),
}

impl From<<Script as IntoChecked>::Metadata> for CheckedMetadata {
    fn from(metadata: <Script as IntoChecked>::Metadata) -> Self {
        Self::Script(metadata)
    }
}

impl From<<Create as IntoChecked>::Metadata> for CheckedMetadata {
    fn from(metadata: <Create as IntoChecked>::Metadata) -> Self {
        Self::Create(metadata)
    }
}

impl From<<Mint as IntoChecked>::Metadata> for CheckedMetadata {
    fn from(metadata: <Mint as IntoChecked>::Metadata) -> Self {
        Self::Mint(metadata)
    }
}

impl From<<Upgrade as IntoChecked>::Metadata> for CheckedMetadata {
    fn from(metadata: <Upgrade as IntoChecked>::Metadata) -> Self {
        Self::Upgrade(metadata)
    }
}

impl From<<Upload as IntoChecked>::Metadata> for CheckedMetadata {
    fn from(metadata: <Upload as IntoChecked>::Metadata) -> Self {
        Self::Upload(metadata)
    }
}
impl From<<Blob as IntoChecked>::Metadata> for CheckedMetadata {
    fn from(metadata: <Blob as IntoChecked>::Metadata) -> Self {
        Self::Blob(metadata)
    }
}

impl IntoChecked for Transaction {
    type Metadata = CheckedMetadata;

    fn into_checked_basic(
        self,
        block_height: BlockHeight,
        consensus_params: &ConsensusParameters,
    ) -> Result<Checked<Self>, CheckError> {
        match self {
            Self::Script(tx) => {
                let (transaction, metadata) = tx
                    .into_checked_basic(block_height, consensus_params)?
                    .into();
                Ok((transaction.into(), metadata.into()))
            }
            Self::Create(tx) => {
                let (transaction, metadata) = tx
                    .into_checked_basic(block_height, consensus_params)?
                    .into();
                Ok((transaction.into(), metadata.into()))
            }
            Self::Mint(tx) => {
                let (transaction, metadata) = tx
                    .into_checked_basic(block_height, consensus_params)?
                    .into();
                Ok((transaction.into(), metadata.into()))
            }
            Self::Upgrade(tx) => {
                let (transaction, metadata) = tx
                    .into_checked_basic(block_height, consensus_params)?
                    .into();
                Ok((transaction.into(), metadata.into()))
            }
            Self::Upload(tx) => {
                let (transaction, metadata) = tx
                    .into_checked_basic(block_height, consensus_params)?
                    .into();
                Ok((transaction.into(), metadata.into()))
            }
            Self::Blob(tx) => {
                let (transaction, metadata) = tx
                    .into_checked_basic(block_height, consensus_params)?
                    .into();
                Ok((transaction.into(), metadata.into()))
            }
        }
        .map(|(transaction, metadata)| Checked::basic(transaction, metadata))
    }
}

impl From<ValidityError> for CheckError {
    fn from(value: ValidityError) -> Self {
        CheckError::Validity(value)
    }
}

impl From<PredicateVerificationFailed> for CheckError {
    fn from(value: PredicateVerificationFailed) -> Self {
        CheckError::PredicateVerificationFailed(value)
    }
}

#[cfg(feature = "random")]
#[allow(non_snake_case)]
#[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)]
#[cfg(test)]
mod tests {

    use super::*;
    use alloc::vec;
    use fuel_asm::op;
    use fuel_crypto::SecretKey;
    use fuel_tx::{
        field::{
            ScriptGasLimit,
            Tip,
            WitnessLimit,
            Witnesses,
        },
        Script,
        TransactionBuilder,
        ValidityError,
    };
    use fuel_types::canonical::Serialize;
    use quickcheck::TestResult;
    use quickcheck_macros::quickcheck;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    fn params(factor: u64) -> ConsensusParameters {
        ConsensusParameters::new(
            TxParameters::default(),
            PredicateParameters::default(),
            ScriptParameters::default(),
            ContractParameters::default(),
            FeeParameters::default().with_gas_price_factor(factor),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
        )
    }

    #[test]
    fn into_checked__tx_accepts_valid_tx() {
        // simple smoke test that valid txs can be checked
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_limit = 1000;
        let input_amount = 1000;
        let output_amount = 10;
        let max_fee_limit = 500;
        let tx =
            valid_coin_tx(rng, gas_limit, input_amount, output_amount, max_fee_limit);

        let checked = tx
            .clone()
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect("Expected valid transaction");

        // verify transaction getter works
        assert_eq!(checked.transaction(), &tx);
        // verify available balance was decreased by max fee
        assert_eq!(
            checked.metadata().non_retryable_balances[&AssetId::default()],
            input_amount - max_fee_limit - output_amount
        );
    }

    #[test]
    fn into_checked__tx_accepts_valid_signed_message_coin_for_fees() {
        // simple test to ensure a tx that only has a message input can cover fees
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let input_amount = 1000;
        let gas_limit = 1000;
        let zero_fee_limit = 500;
        let tx = signed_message_coin_tx(rng, gas_limit, input_amount, zero_fee_limit);

        let checked = tx
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect("Expected valid transaction");

        // verify available balance was decreased by max fee
        assert_eq!(
            checked.metadata().non_retryable_balances[&AssetId::default()],
            input_amount - checked.transaction.max_fee_limit()
        );
    }

    #[test]
    fn into_checked__tx_excludes_message_output_amount_from_fee() {
        // ensure message outputs aren't deducted from available balance
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let input_amount = 100;
        let gas_limit = 1000;
        let zero_fee_limit = 50;
        let tx = signed_message_coin_tx(rng, gas_limit, input_amount, zero_fee_limit);

        let checked = tx
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect("Expected valid transaction");

        // verify available balance was decreased by max fee
        assert_eq!(
            checked.metadata().non_retryable_balances[&AssetId::default()],
            input_amount - checked.transaction.max_fee_limit()
        );
    }

    #[test]
    fn into_checked__message_data_signed_message_is_not_used_to_cover_fees() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        // given
        let input_amount = 100;

        // when
        let max_fee = input_amount;
        let tx = TransactionBuilder::script(vec![], vec![])
            .max_fee_limit(max_fee)
            // Add message input with enough to cover max fee
            .add_unsigned_message_input(SecretKey::random(rng), rng.gen(), rng.gen(), input_amount, vec![0xff; 10])
            // Add empty base coin
            .add_unsigned_coin_input(SecretKey::random(rng), rng.gen(), 0, AssetId::BASE, rng.gen())
            .finalize();

        let err = tx
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect_err("Expected valid transaction");

        // then
        assert!(matches!(
            err,
            CheckError::Validity(ValidityError::InsufficientFeeAmount {
                expected: _,
                provided: 0
            })
        ));
    }

    #[test]
    fn message_data_predicate_message_is_not_used_to_cover_fees() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_limit = 1000;

        // given
        let input_amount = 100;

        // when
        let max_fee = input_amount;

        let tx = TransactionBuilder::script(vec![], vec![])
            .max_fee_limit(max_fee)
            .script_gas_limit(gas_limit)
            .add_input(Input::message_data_predicate(
                rng.gen(),
                rng.gen(),
                input_amount,
                rng.gen(),
                Default::default(),
                vec![0xff; 10],
                vec![0xaa; 10],
                vec![0xbb; 10],
            ))
            // Add empty base coin
            .add_unsigned_coin_input(SecretKey::random(rng), rng.gen(), 0, AssetId::BASE, rng.gen())
            .finalize();

        let err = tx
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect_err("Expected valid transaction");

        // then
        assert!(matches!(
            err,
            CheckError::Validity(ValidityError::InsufficientFeeAmount {
                expected: _,
                provided: 0
            })
        ));
    }

    // use quickcheck to fuzz any rounding or precision errors in the max fee w/ coin
    // input
    #[quickcheck]
    fn max_fee_coin_input(
        gas_price: u64,
        gas_limit: u64,
        witness_limit: u64,
        input_amount: u64,
        gas_price_factor: u64,
        seed: u64,
    ) -> TestResult {
        // verify max fee a transaction can consume based on gas limit + bytes is correct

        // dont divide by zero
        if gas_price_factor == 0 {
            return TestResult::discard();
        }

        let rng = &mut StdRng::seed_from_u64(seed);
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
        let predicate_gas_used = rng.gen();
        let tx = predicate_tx(
            rng,
            gas_limit,
            witness_limit,
            input_amount,
            predicate_gas_used,
        );

        if let Ok(valid) = is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params) {
            TestResult::from_bool(valid)
        } else {
            TestResult::discard()
        }
    }

    // use quickcheck to fuzz any rounding or precision errors in the min fee w/ coin
    // input
    #[quickcheck]
    fn min_fee_coin_input(
        gas_price: u64,
        gas_limit: u64,
        witness_limit: u64,
        input_amount: u64,
        gas_price_factor: u64,
        seed: u64,
    ) -> TestResult {
        // verify min fee a transaction can consume based on bytes is correct

        // dont divide by zero
        if gas_price_factor == 0 {
            return TestResult::discard();
        }
        let rng = &mut StdRng::seed_from_u64(seed);
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
        let predicate_gas_used = rng.gen();
        let tx = predicate_tx(
            rng,
            gas_limit,
            witness_limit,
            input_amount,
            predicate_gas_used,
        );

        if let Ok(valid) = is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params) {
            TestResult::from_bool(valid)
        } else {
            TestResult::discard()
        }
    }

    // use quickcheck to fuzz any rounding or precision errors in the max fee w/ message
    // input
    #[quickcheck]
    fn max_fee_message_input(
        gas_price: u64,
        gas_limit: u64,
        input_amount: u64,
        gas_price_factor: u64,
        tip: u64,
        seed: u64,
    ) -> TestResult {
        // dont divide by zero
        if gas_price_factor == 0 {
            return TestResult::discard();
        }

        let rng = &mut StdRng::seed_from_u64(seed);
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
        let tx = predicate_message_coin_tx(rng, gas_limit, input_amount, tip);

        if let Ok(valid) = is_valid_max_fee(&tx, gas_price, &gas_costs, &fee_params) {
            TestResult::from_bool(valid)
        } else {
            TestResult::discard()
        }
    }

    // use quickcheck to fuzz any rounding or precision errors in refund calculation
    #[quickcheck]
    fn refund_when_used_gas_is_zero(
        gas_price: u64,
        gas_limit: u64,
        input_amount: u64,
        gas_price_factor: u64,
        seed: u64,
        tip: u64,
    ) -> TestResult {
        // dont divide by zero
        if gas_price_factor == 0 {
            return TestResult::discard();
        }

        let rng = &mut StdRng::seed_from_u64(seed);
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
        let tx = predicate_message_coin_tx(rng, gas_limit, input_amount, tip);

        // Given
        let used_gas = 0;

        // When
        let refund = tx.refund_fee(&gas_costs, &fee_params, used_gas, gas_price);

        let min_fee = tx.min_fee(&gas_costs, &fee_params, gas_price);
        let max_fee = tx.max_fee(&gas_costs, &fee_params, gas_price);

        // Then
        if let Some(refund) = refund {
            TestResult::from_bool(max_fee - min_fee == refund as u128)
        } else {
            TestResult::discard()
        }
    }

    // use quickcheck to fuzz any rounding or precision errors in the min fee w/ message
    // input
    #[quickcheck]
    fn min_fee_message_input(
        gas_limit: u64,
        input_amount: u64,
        gas_price: u64,
        gas_price_factor: u64,
        tip: u64,
        seed: u64,
    ) -> TestResult {
        // verify min fee a transaction can consume based on bytes is correct

        // dont divide by zero
        if gas_price_factor == 0 {
            return TestResult::discard();
        }
        let rng = &mut StdRng::seed_from_u64(seed);
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(gas_price_factor);
        let tx = predicate_message_coin_tx(rng, gas_limit, input_amount, tip);

        if let Ok(valid) = is_valid_min_fee(&tx, &gas_costs, &fee_params, gas_price) {
            TestResult::from_bool(valid)
        } else {
            TestResult::discard()
        }
    }

    #[test]
    fn fee_multiple_signed_inputs() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_price = 100;
        let gas_limit = 1000;
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
        let tx = TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(gas_limit)
            // Set up 3 signed inputs
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .finalize();
        let fee =
            TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx, gas_price)
                .unwrap();

        let min_fee = fee.min_fee();
        let expected_min_fee = (tx.metered_bytes_size() as u64
            * fee_params.gas_per_byte()
            + gas_costs.vm_initialization().resolve(tx.size() as u64)
            + 3 * gas_costs.eck1()
            + gas_costs.s256().resolve(tx.size() as u64))
            * gas_price;
        assert_eq!(min_fee, expected_min_fee);

        let max_fee = fee.max_fee();
        let expected_max_fee = expected_min_fee + gas_limit * gas_price;
        assert_eq!(max_fee, expected_max_fee);
    }

    #[test]
    fn fee_multiple_signed_inputs_single_owner() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_price = 100;
        let gas_limit = 1000;
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
        let secret = SecretKey::random(rng);
        let tx = TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(gas_limit)
            // Set up 3 signed inputs
            .add_unsigned_message_input(
                secret,
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .add_unsigned_message_input(
                secret,
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .add_unsigned_message_input(
                secret,
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .finalize();
        let fee =
            TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx, gas_price)
                .unwrap();

        let min_fee = fee.min_fee();
        // Because all inputs are owned by the same address, the address will only need to
        // be recovered once. Therefore, we charge only once for the address
        // recovery of the signed inputs.
        let expected_min_fee = (tx.metered_bytes_size() as u64
            * fee_params.gas_per_byte()
            + gas_costs.vm_initialization().resolve(tx.size() as u64)
            + gas_costs.eck1()
            + gas_costs.s256().resolve(tx.size() as u64))
            * gas_price;
        assert_eq!(min_fee, expected_min_fee);

        let max_fee = fee.max_fee();
        let expected_max_fee = min_fee + gas_limit * gas_price;
        assert_eq!(max_fee, expected_max_fee);
    }

    fn random_bytes<const N: usize, R: Rng + ?Sized>(rng: &mut R) -> Box<[u8; N]> {
        let mut bytes = Box::new([0u8; N]);
        for chunk in bytes.chunks_mut(32) {
            rng.fill(chunk);
        }
        bytes
    }

    #[test]
    fn min_fee_multiple_predicate_inputs() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_price = 100;
        let gas_limit = 1000;
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
        let predicate_1 = random_bytes::<1024, _>(rng);
        let predicate_2 = random_bytes::<2048, _>(rng);
        let predicate_3 = random_bytes::<4096, _>(rng);
        let tx = TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(gas_limit)
            // Set up 3 predicate inputs
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                50,
                predicate_1.to_vec(),
                vec![],
            ))
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                100,
                predicate_2.to_vec(),
                vec![],
            ))
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                200,
                predicate_3.to_vec(),
                vec![],
            ))
            .finalize();
        let fee =
            TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx, gas_price)
                .unwrap();

        let min_fee = fee.min_fee();
        let expected_min_fee = (tx.size() as u64 * fee_params.gas_per_byte()
            + gas_costs.vm_initialization().resolve(tx.size() as u64)
            + gas_costs.contract_root().resolve(predicate_1.len() as u64)
            + gas_costs.contract_root().resolve(predicate_2.len() as u64)
            + gas_costs.contract_root().resolve(predicate_3.len() as u64)
            + 3 * gas_costs.vm_initialization().resolve(tx.size() as u64)
            + 50
            + 100
            + 200
            + gas_costs.s256().resolve(tx.size() as u64))
            * gas_price;
        assert_eq!(min_fee, expected_min_fee);

        let max_fee = fee.max_fee();
        let expected_max_fee = min_fee + gas_limit * gas_price;
        assert_eq!(max_fee, expected_max_fee);
    }

    #[test]
    fn min_fee_multiple_signed_and_predicate_inputs() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_price = 100;
        let gas_limit = 1000;
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
        let predicate_1 = random_bytes::<1024, _>(rng);
        let predicate_2 = random_bytes::<2048, _>(rng);
        let predicate_3 = random_bytes::<4096, _>(rng);
        let tx = TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(gas_limit)
            // Set up 3 signed inputs
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                rng.gen::<u32>() as u64,
                vec![],
            )
            // Set up 3 predicate inputs
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                50,
                predicate_1.to_vec(),
                vec![],
            ))
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                100,
                predicate_2.to_vec(),
                vec![],
            ))
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                200,
                predicate_3.to_vec(),
                vec![],
            ))
            .finalize();
        let fee =
            TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx, gas_price)
                .unwrap();

        let min_fee = fee.min_fee();
        let expected_min_fee = (tx.metered_bytes_size() as u64
            * fee_params.gas_per_byte()
            + 3 * gas_costs.eck1()
            + gas_costs.vm_initialization().resolve(tx.size() as u64)
            + gas_costs.contract_root().resolve(predicate_1.len() as u64)
            + gas_costs.contract_root().resolve(predicate_2.len() as u64)
            + gas_costs.contract_root().resolve(predicate_3.len() as u64)
            + 3 * gas_costs.vm_initialization().resolve(tx.size() as u64)
            + 50
            + 100
            + 200
            + gas_costs.s256().resolve(tx.size() as u64))
            * gas_price;
        assert_eq!(min_fee, expected_min_fee);

        let max_fee = fee.max_fee();
        let expected_max_fee = min_fee + gas_limit * gas_price;
        assert_eq!(max_fee, expected_max_fee);
    }

    #[test]
    fn fee_create_tx() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_price = 100;
        let witness_limit = 1000;
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
        let gen_storage_slot = || rng.gen::<StorageSlot>();
        let storage_slots = core::iter::repeat_with(gen_storage_slot)
            .take(100)
            .collect::<Vec<_>>();
        let storage_slots_len = storage_slots.len();
        let bytecode = rng.gen::<Witness>();
        let bytecode_len = bytecode.as_ref().len();
        let salt = rng.gen::<Salt>();
        let tx = TransactionBuilder::create(bytecode.clone(), salt, storage_slots)
            .witness_limit(witness_limit)
            .finalize();
        let fee =
            TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx, gas_price)
                .unwrap();

        let min_fee = fee.min_fee();
        let expected_min_fee = (tx.metered_bytes_size() as u64
            * fee_params.gas_per_byte()
            + gas_costs.state_root().resolve(storage_slots_len as Word)
            + gas_costs.contract_root().resolve(bytecode_len as Word)
            + gas_costs.vm_initialization().resolve(tx.size() as u64)
            + gas_costs.s256().resolve(100)
            + gas_costs.s256().resolve(tx.size() as u64))
            * gas_price;
        assert_eq!(min_fee, expected_min_fee);

        let max_fee = fee.max_fee();
        let expected_max_fee = min_fee
            + (witness_limit - bytecode.size() as u64)
                * fee_params.gas_per_byte()
                * gas_price;
        assert_eq!(max_fee, expected_max_fee);
    }

    #[test]
    fn fee_create_tx_no_bytecode() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let gas_price = 100;
        let witness_limit = 1000;
        let gas_costs = GasCosts::default();
        let fee_params = FeeParameters::DEFAULT.with_gas_price_factor(1);
        let bytecode: Witness = Vec::<u8>::new().into();
        let salt = rng.gen::<Salt>();
        let tx = TransactionBuilder::create(bytecode.clone(), salt, vec![])
            .witness_limit(witness_limit)
            .finalize();
        let fee =
            TransactionFee::checked_from_tx(&gas_costs, &fee_params, &tx, gas_price)
                .unwrap();

        let min_fee = fee.min_fee();
        let expected_min_fee = (tx.metered_bytes_size() as u64
            * fee_params.gas_per_byte()
            + gas_costs.state_root().resolve(0)
            + gas_costs.contract_root().resolve(0)
            + gas_costs.vm_initialization().resolve(tx.size() as u64)
            + gas_costs.s256().resolve(100)
            + gas_costs.s256().resolve(tx.size() as u64))
            * gas_price;
        assert_eq!(min_fee, expected_min_fee);

        let max_fee = fee.max_fee();
        let expected_max_fee = min_fee
            + (witness_limit - bytecode.size_static() as u64)
                * fee_params.gas_per_byte()
                * gas_price;
        assert_eq!(max_fee, expected_max_fee);
    }

    #[test]
    fn checked_tx_rejects_invalid_tx() {
        // simple smoke test that invalid txs cannot be checked
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let asset = rng.gen();
        let gas_limit = 100;
        let input_amount = 1_000;

        // create a tx with invalid signature
        let tx = TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(gas_limit)
            .add_input(Input::coin_signed(
                rng.gen(),
                rng.gen(),
                input_amount,
                asset,
                rng.gen(),
                Default::default(),
            ))
            .add_input(Input::contract(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
            ))
            .add_output(Output::contract(1, rng.gen(), rng.gen()))
            .add_output(Output::coin(rng.gen(), 10, asset))
            .add_output(Output::change(rng.gen(), 0, asset))
            .add_witness(Default::default())
            .finalize();

        let err = tx
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect_err("Expected invalid transaction");

        // assert that tx without base input assets fails
        assert!(matches!(
            err,
            CheckError::Validity(ValidityError::InputInvalidSignature { .. })
        ));
    }

    #[test]
    fn into_checked__tx_fails_when_provided_fees_dont_cover_byte_costs() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        let arb_input_amount = 1;
        let gas_price = 2; // price > amount
        let gas_limit = 0; // don't include any gas execution fees
        let factor = 1;
        let zero_max_fee = 0;
        let params = params(factor);

        // setup "valid" transaction
        let transaction = base_asset_tx(rng, arb_input_amount, gas_limit, zero_max_fee);
        transaction
            .clone()
            .into_checked(Default::default(), &params)
            .unwrap();
        let fees = TransactionFee::checked_from_tx(
            &GasCosts::default(),
            params.fee_params(),
            &transaction,
            gas_price,
        )
        .unwrap();
        let real_max_fee = fees.max_fee();

        let new_input_amount = real_max_fee;
        let mut new_transaction =
            base_asset_tx(rng, new_input_amount, gas_limit, real_max_fee);
        new_transaction
            .clone()
            .into_checked(Default::default(), &params)
            .unwrap()
            .into_ready(gas_price, &GasCosts::default(), params.fee_params())
            .expect("`new_transaction` should be fully valid");

        // given
        // invalidating the transaction by increasing witness size
        new_transaction.witnesses_mut().push(rng.gen());
        let bigger_checked = new_transaction
            .into_checked(Default::default(), &params)
            .unwrap();

        // when
        let err = bigger_checked
            .into_ready(gas_price, &GasCosts::default(), params.fee_params())
            .expect_err("Expected invalid transaction");

        let max_fee_from_policies = match err {
            CheckError::InsufficientMaxFee {
                max_fee_from_policies,
                ..
            } => max_fee_from_policies,
            _ => panic!("expected insufficient max fee; found {err:?}"),
        };

        // then
        assert_eq!(max_fee_from_policies, real_max_fee);
    }

    #[test]
    fn into_checked__tx_fails_when_provided_fees_dont_cover_fee_limit() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        let input_amount = 10;
        let factor = 1;
        // make gas price too high for the input amount
        let gas_limit = input_amount + 1; // make gas cost 1 higher than input amount

        // given
        let input_amount = 10;
        let big_fee_limit = input_amount + 1;

        let transaction = base_asset_tx(rng, input_amount, gas_limit, big_fee_limit);

        let consensus_params = params(factor);

        // when
        let err = transaction
            .into_checked(Default::default(), &consensus_params)
            .expect_err("overflow expected");

        // then
        let provided = match err {
            CheckError::Validity(ValidityError::InsufficientFeeAmount {
                provided,
                ..
            }) => provided,
            _ => panic!("expected insufficient fee amount; found {err:?}"),
        };
        assert_eq!(provided, input_amount);
    }

    #[test]
    fn into_ready__bytes_fee_cant_overflow() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        let input_amount = 1000;
        let max_gas_price = Word::MAX;
        let gas_limit = 0; // ensure only bytes are included in fee
        let zero_fee_limit = 0;
        let transaction = base_asset_tx(rng, input_amount, gas_limit, zero_fee_limit);
        let gas_costs = GasCosts::default();

        let consensus_params = params(1);

        let fee_params = consensus_params.fee_params();
        let err = transaction
            .into_checked(Default::default(), &consensus_params)
            .unwrap()
            .into_ready(max_gas_price, &gas_costs, fee_params)
            .expect_err("overflow expected");

        assert_eq!(err, CheckError::Validity(ValidityError::BalanceOverflow));
    }

    #[test]
    fn into_ready__fails_if_fee_limit_too_low() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        let input_amount = 1000;
        let gas_price = 100;
        let gas_limit = 0; // ensure only bytes are included in fee
        let gas_costs = GasCosts::default();

        let consensus_params = params(1);

        let fee_params = consensus_params.fee_params();

        // given
        let zero_fee_limit = 0;
        let transaction = base_asset_tx(rng, input_amount, gas_limit, zero_fee_limit);

        // when
        let err = transaction
            .into_checked(Default::default(), &consensus_params)
            .unwrap()
            .into_ready(gas_price, &gas_costs, fee_params)
            .expect_err("overflow expected");

        // then
        assert!(matches!(err, CheckError::InsufficientMaxFee { .. }));
    }

    #[test]
    fn into_ready__tx_fails_if_tip_not_covered() {
        let rng = &mut StdRng::seed_from_u64(2322u64);

        // tx without tip and fee limit that is good
        let input_amount = 1;
        let gas_limit = 1000;
        let params = ConsensusParameters::standard();
        let block_height = 1.into();
        let gas_costs = GasCosts::default();
        let max_fee_limit = input_amount;
        let gas_price = 1;

        let tx_without_tip =
            base_asset_tx_with_tip(rng, input_amount, gas_limit, max_fee_limit, None);
        tx_without_tip
            .clone()
            .into_checked(block_height, &params)
            .unwrap()
            .into_ready(gas_price, &gas_costs, params.fee_params())
            .expect("Should be valid");

        // given
        let tip = 100;
        let tx_without_enough_to_pay_for_tip = base_asset_tx_with_tip(
            rng,
            input_amount,
            gas_limit,
            max_fee_limit,
            Some(tip),
        );
        tx_without_enough_to_pay_for_tip
            .into_checked(block_height, &params)
            .unwrap()
            .into_ready(gas_price, &gas_costs, params.fee_params())
            .expect_err("Expected invalid transaction");

        // when
        let new_input_amount = input_amount + tip;
        let new_gas_limit = new_input_amount;
        let tx = base_asset_tx_with_tip(
            rng,
            new_input_amount,
            gas_limit,
            new_gas_limit,
            Some(tip),
        );

        // then
        tx.clone()
            .into_checked(block_height, &params)
            .unwrap()
            .into_ready(gas_price, &GasCosts::default(), params.fee_params())
            .expect("Should be valid");
    }

    #[test]
    fn into_ready__return_overflow_error_if_gas_price_too_high() {
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let input_amount = 1000;
        let gas_price = Word::MAX;
        let gas_limit = 2; // 2 * max should cause gas fee overflow
        let max_fee_limit = 0;

        let transaction = base_asset_tx(rng, input_amount, gas_limit, max_fee_limit);

        let consensus_params = params(1);

        let err = transaction
            .into_checked(Default::default(), &consensus_params)
            .unwrap()
            .into_ready(
                gas_price,
                &GasCosts::default(),
                consensus_params.fee_params(),
            )
            .expect_err("overflow expected");

        assert_eq!(err, CheckError::Validity(ValidityError::BalanceOverflow));
    }

    #[test]
    fn checked_tx_fails_if_asset_is_overspent_by_coin_output() {
        let input_amount = 1_000;
        let rng = &mut StdRng::seed_from_u64(2322u64);
        let secret = SecretKey::random(rng);
        let any_asset = rng.gen();
        let tx = TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(100)
            // base asset
            .add_unsigned_coin_input(
                secret,
                rng.gen(),
                input_amount,
                AssetId::default(),
                rng.gen(),
            )
            .add_output(Output::change(rng.gen(), 0, AssetId::default()))
            // arbitrary spending asset
            .add_unsigned_coin_input(
                secret,
                rng.gen(),
                input_amount,
                any_asset,
                rng.gen(),
            )
            .add_output(Output::coin(rng.gen(), input_amount + 1, any_asset))
            .add_output(Output::change(rng.gen(), 0, any_asset))
            .finalize();

        let checked = tx
            .into_checked(Default::default(), &ConsensusParameters::standard())
            .expect_err("Expected valid transaction");

        assert_eq!(
            CheckError::Validity(ValidityError::InsufficientInputAmount {
                asset: any_asset,
                expected: input_amount + 1,
                provided: input_amount,
            }),
            checked
        );
    }

    #[cfg(feature = "std")]
    #[test]
    fn basic_check_marks_basic_flag() {
        let block_height = 1.into();

        let tx = Transaction::default_test_tx();
        // Sets Checks::Basic
        let checked = tx
            .into_checked_basic(block_height, &ConsensusParameters::standard())
            .unwrap();
        assert!(checked.checks().contains(Checks::Basic));
    }

    #[test]
    fn signatures_check_marks_signatures_flag() {
        let mut rng = StdRng::seed_from_u64(1);
        let block_height = 1.into();
        let max_fee_limit = 0;

        let tx = valid_coin_tx(&mut rng, 100000, 1000000, 10, max_fee_limit);
        let chain_id = ChainId::default();
        let checked = tx
            // Sets Checks::Basic
            .into_checked(
                block_height,
                &ConsensusParameters::standard_with_id(chain_id),
            )
            .unwrap()
            // Sets Checks::Signatures
            .check_signatures(&chain_id)
            .unwrap();

        assert!(checked
            .checks()
            .contains(Checks::Basic | Checks::Signatures));
    }

    #[test]
    fn predicates_check_marks_predicate_flag() {
        let mut rng = StdRng::seed_from_u64(1);
        let block_height = 1.into();
        let gas_costs = GasCosts::default();

        let tx = predicate_tx(&mut rng, 1000000, 1000000, 1000000, gas_costs.ret());

        let mut consensus_params = ConsensusParameters::standard();
        consensus_params.set_gas_costs(gas_costs);

        let check_predicate_params = CheckPredicateParams::from(&consensus_params);

        let checked = tx
            // Sets Checks::Basic
            .into_checked(
                block_height,
                &consensus_params,
            )
            .unwrap()
            // Sets Checks::Predicates
            .check_predicates(&check_predicate_params, MemoryInstance::new(), &EmptyStorage)
            .unwrap();
        assert!(checked
            .checks()
            .contains(Checks::Basic | Checks::Predicates));
    }

    fn is_valid_max_fee(
        tx: &Script,
        gas_price: u64,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
    ) -> Result<bool, ValidityError> {
        fn gas_to_fee(gas: u64, price: u64, factor: u64) -> u128 {
            let prices_gas = gas as u128 * price as u128;
            let fee = prices_gas / factor as u128;
            let fee_remainder = (prices_gas.rem_euclid(factor as u128) > 0) as u128;
            fee + fee_remainder
        }

        // cant overflow as metered bytes * gas_per_byte < u64::MAX
        let gas_used_by_bytes = fee_params
            .gas_per_byte()
            .saturating_mul(tx.metered_bytes_size() as u64);
        let gas_used_by_inputs = tx.gas_used_by_inputs(gas_costs);
        let gas_used_by_metadata = tx.gas_used_by_metadata(gas_costs);
        let min_gas = gas_used_by_bytes
            .saturating_add(gas_used_by_inputs)
            .saturating_add(gas_used_by_metadata)
            .saturating_add(
                gas_costs
                    .vm_initialization()
                    .resolve(tx.metered_bytes_size() as u64),
            );

        // use different division mechanism than impl
        let witness_limit_allowance = tx
            .witness_limit()
            .saturating_sub(tx.witnesses().size_dynamic() as u64)
            .saturating_mul(fee_params.gas_per_byte());
        let max_gas = min_gas
            .saturating_add(*tx.script_gas_limit())
            .saturating_add(witness_limit_allowance);
        let max_fee = gas_to_fee(max_gas, gas_price, fee_params.gas_price_factor());

        let max_fee_with_tip = max_fee.saturating_add(tx.tip() as u128);

        let result = max_fee_with_tip == tx.max_fee(gas_costs, fee_params, gas_price);
        Ok(result)
    }

    fn is_valid_min_fee<Tx>(
        tx: &Tx,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        gas_price: u64,
    ) -> Result<bool, ValidityError>
    where
        Tx: Chargeable + field::Inputs + field::Outputs,
    {
        // cant overflow as (metered bytes + gas_used_by_predicates) * gas_per_byte <
        // u64::MAX
        let gas_used_by_bytes = fee_params
            .gas_per_byte()
            .saturating_mul(tx.metered_bytes_size() as u64);
        let gas_used_by_inputs = tx.gas_used_by_inputs(gas_costs);
        let gas_used_by_metadata = tx.gas_used_by_metadata(gas_costs);
        let gas = gas_used_by_bytes
            .saturating_add(gas_used_by_inputs)
            .saturating_add(gas_used_by_metadata)
            .saturating_add(
                gas_costs
                    .vm_initialization()
                    .resolve(tx.metered_bytes_size() as u64),
            );
        let total = gas as u128 * gas_price as u128;
        // use different division mechanism than impl
        let fee = total / fee_params.gas_price_factor() as u128;
        let fee_remainder =
            (total.rem_euclid(fee_params.gas_price_factor() as u128) > 0) as u128;
        let rounded_fee = fee
            .saturating_add(fee_remainder)
            .saturating_add(tx.tip() as u128);
        let min_fee = rounded_fee;
        let calculated_min_fee = tx.min_fee(gas_costs, fee_params, gas_price);

        Ok(min_fee == calculated_min_fee)
    }

    fn valid_coin_tx(
        rng: &mut StdRng,
        gas_limit: u64,
        input_amount: u64,
        output_amount: u64,
        max_fee_limit: u64,
    ) -> Script {
        let asset = AssetId::default();
        TransactionBuilder::script(vec![], vec![])
            .script_gas_limit(gas_limit)
            .max_fee_limit(max_fee_limit)
            .add_unsigned_coin_input(
                SecretKey::random(rng),
                rng.gen(),
                input_amount,
                asset,
                rng.gen(),
            )
            .add_input(Input::contract(
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
                rng.gen(),
            ))
            .add_output(Output::contract(1, rng.gen(), rng.gen()))
            .add_output(Output::coin(rng.gen(), output_amount, asset))
            .add_output(Output::change(rng.gen(), 0, asset))
            .finalize()
    }

    // used when proptesting to avoid expensive crypto signatures
    fn predicate_tx(
        rng: &mut StdRng,
        gas_limit: u64,
        witness_limit: u64,
        fee_input_amount: u64,
        predicate_gas_used: u64,
    ) -> Script {
        let asset = AssetId::default();
        let predicate = vec![op::ret(1)].into_iter().collect::<Vec<u8>>();
        let owner = Input::predicate_owner(&predicate);
        let zero_fee_limit = 0;
        TransactionBuilder::script(vec![], vec![])
            .max_fee_limit(zero_fee_limit)
            .script_gas_limit(gas_limit)
            .witness_limit(witness_limit)
            .add_input(Input::coin_predicate(
                rng.gen(),
                owner,
                fee_input_amount,
                asset,
                rng.gen(),
                predicate_gas_used,
                predicate,
                vec![],
            ))
            .add_output(Output::change(rng.gen(), 0, asset))
            .finalize()
    }

    // used to verify message inputs can cover fees
    fn signed_message_coin_tx(
        rng: &mut StdRng,
        gas_limit: u64,
        input_amount: u64,
        max_fee: u64,
    ) -> Script {
        TransactionBuilder::script(vec![], vec![])
            .max_fee_limit(max_fee)
            .script_gas_limit(gas_limit)
            .add_unsigned_message_input(
                SecretKey::random(rng),
                rng.gen(),
                rng.gen(),
                input_amount,
                vec![],
            )
            .finalize()
    }

    fn predicate_message_coin_tx(
        rng: &mut StdRng,
        gas_limit: u64,
        input_amount: u64,
        tip: u64,
    ) -> Script {
        TransactionBuilder::script(vec![], vec![])
            .tip(tip)
            .script_gas_limit(gas_limit)
            .add_input(Input::message_coin_predicate(
                rng.gen(),
                rng.gen(),
                input_amount,
                rng.gen(),
                Default::default(),
                vec![],
                vec![],
            ))
            .finalize()
    }

    fn base_asset_tx(
        rng: &mut StdRng,
        input_amount: u64,
        gas_limit: u64,
        max_fee: u64,
    ) -> Script {
        base_asset_tx_with_tip(rng, input_amount, gas_limit, max_fee, None)
    }

    fn base_asset_tx_with_tip(
        rng: &mut StdRng,
        input_amount: u64,
        gas_limit: u64,
        max_fee: u64,
        tip: Option<u64>,
    ) -> Script {
        let mut builder = TransactionBuilder::script(vec![], vec![]);
        if let Some(tip) = tip {
            builder.tip(tip);
        }
        builder
            .max_fee_limit(max_fee)
            .script_gas_limit(gas_limit)
            .add_unsigned_coin_input(
                SecretKey::random(rng),
                rng.gen(),
                input_amount,
                AssetId::default(),
                rng.gen(),
            )
            .add_output(Output::change(rng.gen(), 0, AssetId::default()))
            .finalize()
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/lib.rs

Source
//! FuelVM implementation

#![cfg_attr(not(feature = "std"), no_std)]
#![warn(missing_docs)]
#![deny(unsafe_code)]
#![deny(unused_must_use)]
#![deny(unused_crate_dependencies)]
#![deny(
    clippy::arithmetic_side_effects,
    clippy::cast_sign_loss,
    clippy::cast_possible_truncation,
    clippy::cast_possible_wrap,
    clippy::string_slice
)]

#[doc(hidden)] // Needed by some of the exported macros
pub extern crate alloc;

extern crate core;
#[cfg(feature = "std")]
extern crate libm as _; // Not needed with stdlib

#[cfg(test)]
use criterion as _;

pub mod backtrace;
pub mod call;
pub mod checked_transaction;
pub mod constraints;
pub mod consts;
pub mod context;
mod convert;
pub mod crypto;
pub mod error;
pub mod interpreter;
#[cfg(feature = "test-helpers")]
pub mod memory_client;
pub mod pool;
pub mod predicate;
pub mod state;
pub mod storage;
pub mod transactor;
pub mod util;

#[cfg(feature = "profile-any")]
pub mod profiler;

#[cfg(test)]
mod tests;

#[cfg(not(feature = "profile-any"))]
/// Placeholder
pub mod profiler {
    use crate::constraints::InstructionLocation;

    /// Placeholder profiler.
    #[derive(Default, Debug, Clone)]
    pub struct Profiler;

    impl Profiler {
        /// Set the current coverage location.
        pub fn set_coverage(&mut self, _location: InstructionLocation) {}

        /// Add gas to the current coverage location.
        pub fn add_gas(&mut self, _location: InstructionLocation, _gas_use: u64) {}
    }
}

// Fully re-export fuel dependencies
#[doc(no_inline)]
pub use fuel_asm;
#[doc(no_inline)]
#[cfg(feature = "da-compression")]
pub use fuel_compression;
#[doc(no_inline)]
pub use fuel_crypto;
#[doc(no_inline)]
pub use fuel_merkle;
#[doc(no_inline)]
pub use fuel_storage;
#[doc(no_inline)]
pub use fuel_tx;
#[doc(no_inline)]
pub use fuel_types;

pub mod prelude {
    //! Required implementations for full functionality
    #[doc(no_inline)]
    pub use fuel_asm::{
        GMArgs,
        GTFArgs,
        Instruction,
        Opcode,
        PanicReason,
        RegId,
    };
    #[doc(no_inline)]
    pub use fuel_crypto::{
        Hasher,
        Message,
        PublicKey,
        SecretKey,
        Signature,
    };
    #[doc(no_inline)]
    pub use fuel_storage::{
        MerkleRoot,
        MerkleRootStorage,
        StorageAsMut,
        StorageAsRef,
        StorageInspect,
        StorageMutate,
    };
    #[doc(no_inline)]
    pub use fuel_tx::*;
    #[doc(no_inline)]
    pub use fuel_types::{
        Address,
        AssetId,
        BlobId,
        Bytes32,
        Bytes4,
        Bytes64,
        Bytes8,
        ContractId,
        Immediate06,
        Immediate12,
        Immediate18,
        Immediate24,
        RegisterId,
        Salt,
        Word,
    };

    pub use crate::{
        backtrace::Backtrace,
        call::{
            Call,
            CallFrame,
        },
        context::Context,
        error::{
            Bug,
            BugVariant,
            InterpreterError,
            RuntimeError,
        },
        interpreter::{
            predicates,
            ExecutableTransaction,
            Interpreter,
            Memory,
            MemoryInstance,
            MemoryRange,
        },
        pool::VmMemoryPool,
        predicate::RuntimePredicate,
        state::{
            Debugger,
            ProgramState,
            StateTransition,
            StateTransitionRef,
        },
        storage::{
            predicate::PredicateStorage,
            InterpreterStorage,
        },
        transactor::Transactor,
    };

    pub use crate::state::{
        Breakpoint,
        DebugEval,
    };

    #[cfg(any(test, feature = "test-helpers"))]
    pub use crate::{
        checked_transaction::{
            builder::TransactionBuilderExt,
            IntoChecked,
        },
        memory_client::MemoryClient,
        storage::MemoryStorage,
        util::test_helpers::TestBuilder,
    };

    #[cfg(all(
        feature = "profile-gas",
        feature = "std",
        any(test, feature = "test-helpers")
    ))]
    pub use crate::util::gas_profiling::GasProfiler;

    pub use crate::profiler::Profiler;
    #[cfg(feature = "profile-any")]
    pub use crate::profiler::{
        CoverageProfilingData,
        GasProfilingData,
        InstructionLocation,
        PerLocationIter,
        PerLocationKeys,
        PerLocationValues,
        ProfileReceiver,
        ProfilingData,
        StderrReceiver,
    };
}

/home/marten/fuel/fuel-vm/fuel-vm/src/pool.rs

Source
//! Pool of VM memory instances for reuse.

use crate::interpreter::Memory;

#[cfg(any(test, feature = "test-helpers"))]
use crate::interpreter::MemoryInstance;

/// Trait for a VM memory pool.
pub trait VmMemoryPool: Sync {
    /// The memory instance returned by this pool.
    type Memory: Memory + Send + Sync + 'static;

    /// Gets a new VM memory instance from the pool.
    fn get_new(&self) -> impl core::future::Future<Output = Self::Memory> + Send;
}

/// Dummy pool that just returns new instance every time.
#[cfg(any(test, feature = "test-helpers"))]
#[derive(Default, Clone)]
pub struct DummyPool;

#[cfg(any(test, feature = "test-helpers"))]
impl VmMemoryPool for DummyPool {
    type Memory = MemoryInstance;

    fn get_new(&self) -> impl core::future::Future<Output = Self::Memory> + Send {
        core::future::ready(MemoryInstance::new())
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/executors/predicate.rs

Source
use crate::{
    error::PredicateVerificationFailed,
    interpreter::{
        EcalHandler,
        Memory,
    },
    prelude::{
        ExecutableTransaction,
        Interpreter,
    },
    state::{
        ExecuteState,
        ProgramState,
    },
    storage::predicate::PredicateStorage,
};

use crate::storage::predicate::PredicateStorageRequirements;
use fuel_asm::PanicReason;

impl<M, Tx, Ecal, S> Interpreter<M, PredicateStorage<S>, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler,
    S: PredicateStorageRequirements,
{
    /// Verify a predicate that has been initialized already
    pub(crate) fn verify_predicate(
        &mut self,
    ) -> Result<ProgramState, PredicateVerificationFailed> {
        loop {
            match self.execute()? {
                ExecuteState::Return(r) => {
                    if r == 1 {
                        return Ok(ProgramState::Return(r))
                    } else {
                        return Err(PanicReason::PredicateReturnedNonOne.into())
                    }
                }

                // A predicate is not expected to return data
                ExecuteState::ReturnData(_) => {
                    return Err(PanicReason::ContractInstructionNotAllowed.into())
                }

                ExecuteState::Revert(r) => return Ok(ProgramState::Revert(r)),

                ExecuteState::Proceed => (),

                ExecuteState::DebugEvent(d) => {
                    return Ok(ProgramState::VerifyPredicate(d))
                }
            }
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/executors/debug.rs

Source
use crate::{
    error::InterpreterError,
    interpreter::{
        EcalHandler,
        ExecutableTransaction,
        Interpreter,
        Memory,
    },
    state::ProgramState,
    storage::InterpreterStorage,
};

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler,
{
    /// Continue the execution from a previously interrupted program flow.
    pub fn resume(&mut self) -> Result<ProgramState, InterpreterError<S::DataError>> {
        let state = self
            .debugger_last_state()
            .ok_or(InterpreterError::DebugStateNotInitialized)?;

        let state = match state {
            ProgramState::Return(w) => Ok(ProgramState::Return(w)),

            ProgramState::ReturnData(d) => Ok(ProgramState::ReturnData(d)),

            ProgramState::Revert(w) => Ok(ProgramState::Revert(w)),

            ProgramState::RunProgram(_) => self.run_program(),

            ProgramState::VerifyPredicate(_) => unimplemented!(),
        }?;

        if state.is_debug() {
            self.debugger_set_last_state(state);
        }

        Ok(state)
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/executors/instruction.rs

Source
use crate::{
    constraints::reg_key::ProgramRegistersSegment,
    error::{
        InterpreterError,
        IoResult,
        RuntimeError,
    },
    interpreter::{
        alu,
        flow::{
            JumpArgs,
            JumpMode,
        },
        EcalHandler,
        ExecutableTransaction,
        Interpreter,
        Memory,
    },
    state::ExecuteState,
    storage::InterpreterStorage,
};

use fuel_asm::{
    wideint,
    Instruction,
    PanicInstruction,
    PanicReason,
    RawInstruction,
    RegId,
};
use fuel_types::Word;

use core::ops::Div;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler,
{
    /// Execute the current instruction located in `$m[$pc]`.
    pub fn execute(&mut self) -> Result<ExecuteState, InterpreterError<S::DataError>> {
        let raw_instruction = self.fetch_instruction()?;
        self.instruction(raw_instruction)
    }

    /// Reads the current instruction located in `$m[$pc]`,
    /// performing memory boundary checks.
    fn fetch_instruction(
        &self,
    ) -> Result<RawInstruction, InterpreterError<S::DataError>> {
        let pc = self.registers[RegId::PC];
        let instruction = RawInstruction::from_be_bytes(
            self.memory().read_bytes(pc).map_err(|reason| {
                InterpreterError::PanicInstruction(PanicInstruction::error(
                    reason,
                    0, // The value is meaningless since fetch was out-of-bounds
                ))
            })?,
        );
        if pc < self.registers[RegId::IS] || pc >= self.registers[RegId::SSP] {
            return Err(InterpreterError::PanicInstruction(PanicInstruction::error(
                PanicReason::MemoryNotExecutable,
                instruction,
            )))
        }
        Ok(instruction)
    }

    /// Execute a provided instruction
    pub fn instruction<R: Into<RawInstruction> + Copy>(
        &mut self,
        raw: R,
    ) -> Result<ExecuteState, InterpreterError<S::DataError>> {
        if self.debugger.is_active() {
            let debug = self.eval_debugger_state();
            if !debug.should_continue() {
                return Ok(debug.into())
            }
        }

        self.instruction_inner(raw.into())
            .map_err(|e| InterpreterError::from_runtime(e, raw.into()))
    }

    fn instruction_inner(
        &mut self,
        raw: RawInstruction,
    ) -> IoResult<ExecuteState, S::DataError> {
        let instruction = Instruction::try_from(raw)
            .map_err(|_| RuntimeError::from(PanicReason::InvalidInstruction))?;

        // TODO additional branch that might be optimized after
        // https://github.com/FuelLabs/fuel-asm/issues/68
        if self.is_predicate() && !instruction.opcode().is_predicate_allowed() {
            return Err(PanicReason::ContractInstructionNotAllowed.into())
        }

        // Short-hand for retrieving the value from the register with the given ID.
        // We use a macro to "close over" `self.registers` without taking ownership of it.
        macro_rules! r {
            ($id:expr) => {
                self.registers[$id]
            };
        }

        match instruction {
            Instruction::ADD(add) => {
                self.gas_charge(self.gas_costs().add())?;
                let (a, b, c) = add.unpack();
                self.alu_capture_overflow(
                    a.into(),
                    u128::overflowing_add,
                    r!(b).into(),
                    r!(c).into(),
                )?;
            }

            Instruction::ADDI(addi) => {
                self.gas_charge(self.gas_costs().addi())?;
                let (a, b, imm) = addi.unpack();
                self.alu_capture_overflow(
                    a.into(),
                    u128::overflowing_add,
                    r!(b).into(),
                    imm.into(),
                )?;
            }

            Instruction::AND(and) => {
                self.gas_charge(self.gas_costs().and())?;
                let (a, b, c) = and.unpack();
                self.alu_set(a.into(), r!(b) & r!(c))?;
            }

            Instruction::ANDI(andi) => {
                self.gas_charge(self.gas_costs().andi())?;
                let (a, b, imm) = andi.unpack();
                self.alu_set(a.into(), r!(b) & Word::from(imm))?;
            }

            Instruction::DIV(div) => {
                self.gas_charge(self.gas_costs().div())?;
                let (a, b, c) = div.unpack();
                let c = r!(c);
                self.alu_error(a.into(), Word::div, r!(b), c, c == 0)?;
            }

            Instruction::DIVI(divi) => {
                self.gas_charge(self.gas_costs().divi())?;
                let (a, b, imm) = divi.unpack();
                let imm = Word::from(imm);
                self.alu_error(a.into(), Word::div, r!(b), imm, imm == 0)?;
            }

            Instruction::EQ(eq) => {
                self.gas_charge(self.gas_costs().eq_())?;
                let (a, b, c) = eq.unpack();
                self.alu_set(a.into(), (r!(b) == r!(c)) as Word)?;
            }

            Instruction::EXP(exp) => {
                self.gas_charge(self.gas_costs().exp())?;
                let (a, b, c) = exp.unpack();
                self.alu_boolean_overflow(a.into(), alu::exp, r!(b), r!(c))?;
            }

            Instruction::EXPI(expi) => {
                self.gas_charge(self.gas_costs().expi())?;
                let (a, b, imm) = expi.unpack();
                let expo = u32::from(imm);
                self.alu_boolean_overflow(a.into(), Word::overflowing_pow, r!(b), expo)?;
            }

            Instruction::GT(gt) => {
                self.gas_charge(self.gas_costs().gt())?;
                let (a, b, c) = gt.unpack();
                self.alu_set(a.into(), (r!(b) > r!(c)) as Word)?;
            }

            Instruction::LT(lt) => {
                self.gas_charge(self.gas_costs().lt())?;
                let (a, b, c) = lt.unpack();
                self.alu_set(a.into(), (r!(b) < r!(c)) as Word)?;
            }

            Instruction::WDCM(wdcm) => {
                self.gas_charge(self.gas_costs().wdcm())?;
                let (a, b, c, imm) = wdcm.unpack();
                let args = wideint::CompareArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_cmp_u128(a.into(), r!(b), r!(c), args)?;
            }

            Instruction::WQCM(wqcm) => {
                self.gas_charge(self.gas_costs().wqcm())?;
                let (a, b, c, imm) = wqcm.unpack();
                let args = wideint::CompareArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_cmp_u256(a.into(), r!(b), r!(c), args)?;
            }

            Instruction::WDOP(wdop) => {
                self.gas_charge(self.gas_costs().wdop())?;
                let (a, b, c, imm) = wdop.unpack();
                let args = wideint::MathArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_op_u128(r!(a), r!(b), r!(c), args)?;
            }

            Instruction::WQOP(wqop) => {
                self.gas_charge(self.gas_costs().wqop())?;
                let (a, b, c, imm) = wqop.unpack();
                let args = wideint::MathArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_op_u256(r!(a), r!(b), r!(c), args)?;
            }

            Instruction::WDML(wdml) => {
                self.gas_charge(self.gas_costs().wdml())?;
                let (a, b, c, imm) = wdml.unpack();
                let args = wideint::MulArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_mul_u128(r!(a), r!(b), r!(c), args)?;
            }

            Instruction::WQML(wqml) => {
                self.gas_charge(self.gas_costs().wqml())?;
                let (a, b, c, imm) = wqml.unpack();
                let args = wideint::MulArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_mul_u256(r!(a), r!(b), r!(c), args)?;
            }

            Instruction::WDDV(wddv) => {
                self.gas_charge(self.gas_costs().wddv())?;
                let (a, b, c, imm) = wddv.unpack();
                let args = wideint::DivArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_div_u128(r!(a), r!(b), r!(c), args)?;
            }

            Instruction::WQDV(wqdv) => {
                self.gas_charge(self.gas_costs().wqdv())?;
                let (a, b, c, imm) = wqdv.unpack();
                let args = wideint::DivArgs::from_imm(imm)
                    .ok_or(PanicReason::InvalidImmediateValue)?;
                self.alu_wideint_div_u256(r!(a), r!(b), r!(c), args)?;
            }

            Instruction::WDMD(wdmd) => {
                self.gas_charge(self.gas_costs().wdmd())?;
                let (a, b, c, d) = wdmd.unpack();
                self.alu_wideint_muldiv_u128(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::WQMD(wqmd) => {
                self.gas_charge(self.gas_costs().wqmd())?;
                let (a, b, c, d) = wqmd.unpack();
                self.alu_wideint_muldiv_u256(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::WDAM(wdam) => {
                self.gas_charge(self.gas_costs().wdam())?;
                let (a, b, c, d) = wdam.unpack();
                self.alu_wideint_addmod_u128(r!(a), r!(b), r!(c), r!(d))?;
            }
            Instruction::WQAM(wqam) => {
                self.gas_charge(self.gas_costs().wqam())?;
                let (a, b, c, d) = wqam.unpack();
                self.alu_wideint_addmod_u256(r!(a), r!(b), r!(c), r!(d))?;
            }
            Instruction::WDMM(wdmm) => {
                self.gas_charge(self.gas_costs().wdmm())?;
                let (a, b, c, d) = wdmm.unpack();
                self.alu_wideint_mulmod_u128(r!(a), r!(b), r!(c), r!(d))?;
            }
            Instruction::WQMM(wqmm) => {
                self.gas_charge(self.gas_costs().wqmm())?;
                let (a, b, c, d) = wqmm.unpack();
                self.alu_wideint_mulmod_u256(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::MLOG(mlog) => {
                self.gas_charge(self.gas_costs().mlog())?;
                let (a, b, c) = mlog.unpack();
                let (lhs, rhs) = (r!(b), r!(c));
                self.alu_error(
                    a.into(),
                    |l, r| {
                        l.checked_ilog(r)
                            .expect("checked_ilog returned None for valid values")
                            as Word
                    },
                    lhs,
                    rhs,
                    lhs == 0 || rhs <= 1,
                )?;
            }

            Instruction::MOD(mod_) => {
                self.gas_charge(self.gas_costs().mod_op())?;
                let (a, b, c) = mod_.unpack();
                let rhs = r!(c);
                self.alu_error(a.into(), Word::wrapping_rem, r!(b), rhs, rhs == 0)?;
            }

            Instruction::MODI(modi) => {
                self.gas_charge(self.gas_costs().modi())?;
                let (a, b, imm) = modi.unpack();
                let rhs = Word::from(imm);
                self.alu_error(a.into(), Word::wrapping_rem, r!(b), rhs, rhs == 0)?;
            }

            Instruction::MOVE(move_) => {
                self.gas_charge(self.gas_costs().move_op())?;
                let (a, b) = move_.unpack();
                self.alu_set(a.into(), r!(b))?;
            }

            Instruction::MOVI(movi) => {
                self.gas_charge(self.gas_costs().movi())?;
                let (a, imm) = movi.unpack();
                self.alu_set(a.into(), Word::from(imm))?;
            }

            Instruction::MROO(mroo) => {
                self.gas_charge(self.gas_costs().mroo())?;
                let (a, b, c) = mroo.unpack();
                let (lhs, rhs) = (r!(b), r!(c));
                self.alu_error(
                    a.into(),
                    |l, r| {
                        checked_nth_root(l, r)
                            .expect("checked_nth_root returned None for valid values")
                            as Word
                    },
                    lhs,
                    rhs,
                    rhs == 0,
                )?;
            }

            Instruction::MUL(mul) => {
                self.gas_charge(self.gas_costs().mul())?;
                let (a, b, c) = mul.unpack();
                self.alu_capture_overflow(
                    a.into(),
                    u128::overflowing_mul,
                    r!(b).into(),
                    r!(c).into(),
                )?;
            }

            Instruction::MULI(muli) => {
                self.gas_charge(self.gas_costs().muli())?;
                let (a, b, imm) = muli.unpack();
                self.alu_capture_overflow(
                    a.into(),
                    u128::overflowing_mul,
                    r!(b).into(),
                    imm.into(),
                )?;
            }

            Instruction::MLDV(mldv) => {
                self.gas_charge(self.gas_costs().mldv())?;
                let (a, b, c, d) = mldv.unpack();
                self.alu_muldiv(a.into(), r!(b), r!(c), r!(d))?;
            }

            Instruction::NOOP(_noop) => {
                self.gas_charge(self.gas_costs().noop())?;
                self.alu_clear()?;
            }

            Instruction::NOT(not) => {
                self.gas_charge(self.gas_costs().not())?;
                let (a, b) = not.unpack();
                self.alu_set(a.into(), !r!(b))?;
            }

            Instruction::OR(or) => {
                self.gas_charge(self.gas_costs().or())?;
                let (a, b, c) = or.unpack();
                self.alu_set(a.into(), r!(b) | r!(c))?;
            }

            Instruction::ORI(ori) => {
                self.gas_charge(self.gas_costs().ori())?;
                let (a, b, imm) = ori.unpack();
                self.alu_set(a.into(), r!(b) | Word::from(imm))?;
            }

            Instruction::SLL(sll) => {
                self.gas_charge(self.gas_costs().sll())?;
                let (a, b, c) = sll.unpack();

                self.alu_set(
                    a.into(),
                    if let Ok(c) = r!(c).try_into() {
                        Word::checked_shl(r!(b), c).unwrap_or_default()
                    } else {
                        0
                    },
                )?;
            }

            Instruction::SLLI(slli) => {
                self.gas_charge(self.gas_costs().slli())?;
                let (a, b, imm) = slli.unpack();
                let rhs = u32::from(imm);
                self.alu_set(a.into(), r!(b).checked_shl(rhs).unwrap_or_default())?;
            }

            Instruction::SRL(srl) => {
                self.gas_charge(self.gas_costs().srl())?;
                let (a, b, c) = srl.unpack();
                self.alu_set(
                    a.into(),
                    if let Ok(c) = r!(c).try_into() {
                        Word::checked_shr(r!(b), c).unwrap_or_default()
                    } else {
                        0
                    },
                )?;
            }

            Instruction::SRLI(srli) => {
                self.gas_charge(self.gas_costs().srli())?;
                let (a, b, imm) = srli.unpack();
                let rhs = u32::from(imm);
                self.alu_set(a.into(), r!(b).checked_shr(rhs).unwrap_or_default())?;
            }

            Instruction::SUB(sub) => {
                self.gas_charge(self.gas_costs().sub())?;
                let (a, b, c) = sub.unpack();
                self.alu_capture_overflow(
                    a.into(),
                    u128::overflowing_sub,
                    r!(b).into(),
                    r!(c).into(),
                )?;
            }

            Instruction::SUBI(subi) => {
                self.gas_charge(self.gas_costs().subi())?;
                let (a, b, imm) = subi.unpack();
                self.alu_capture_overflow(
                    a.into(),
                    u128::overflowing_sub,
                    r!(b).into(),
                    imm.into(),
                )?;
            }

            Instruction::XOR(xor) => {
                self.gas_charge(self.gas_costs().xor())?;
                let (a, b, c) = xor.unpack();
                self.alu_set(a.into(), r!(b) ^ r!(c))?;
            }

            Instruction::XORI(xori) => {
                self.gas_charge(self.gas_costs().xori())?;
                let (a, b, imm) = xori.unpack();
                self.alu_set(a.into(), r!(b) ^ Word::from(imm))?;
            }

            Instruction::JI(ji) => {
                self.gas_charge(self.gas_costs().ji())?;
                let imm = ji.unpack();
                self.jump(JumpArgs::new(JumpMode::Absolute).to_address(imm.into()))?;
            }

            Instruction::JNEI(jnei) => {
                self.gas_charge(self.gas_costs().jnei())?;
                let (a, b, imm) = jnei.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::Absolute)
                        .with_condition(r!(a) != r!(b))
                        .to_address(imm.into()),
                )?;
            }

            Instruction::JNZI(jnzi) => {
                self.gas_charge(self.gas_costs().jnzi())?;
                let (a, imm) = jnzi.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::Absolute)
                        .with_condition(r!(a) != 0)
                        .to_address(imm.into()),
                )?;
            }

            Instruction::JMP(jmp) => {
                self.gas_charge(self.gas_costs().jmp())?;
                let a = jmp.unpack();
                self.jump(JumpArgs::new(JumpMode::Absolute).to_address(r!(a)))?;
            }

            Instruction::JNE(jne) => {
                self.gas_charge(self.gas_costs().jne())?;
                let (a, b, c) = jne.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::Absolute)
                        .with_condition(r!(a) != r!(b))
                        .to_address(r!(c)),
                )?;
            }

            Instruction::JMPF(jmpf) => {
                self.gas_charge(self.gas_costs().jmpf())?;
                let (a, offset) = jmpf.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::RelativeForwards)
                        .to_address(r!(a))
                        .plus_fixed(offset.into()),
                )?;
            }

            Instruction::JMPB(jmpb) => {
                self.gas_charge(self.gas_costs().jmpb())?;
                let (a, offset) = jmpb.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::RelativeBackwards)
                        .to_address(r!(a))
                        .plus_fixed(offset.into()),
                )?;
            }

            Instruction::JNZF(jnzf) => {
                self.gas_charge(self.gas_costs().jnzf())?;
                let (a, b, offset) = jnzf.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::RelativeForwards)
                        .with_condition(r!(a) != 0)
                        .to_address(r!(b))
                        .plus_fixed(offset.into()),
                )?;
            }

            Instruction::JNZB(jnzb) => {
                self.gas_charge(self.gas_costs().jnzb())?;
                let (a, b, offset) = jnzb.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::RelativeBackwards)
                        .with_condition(r!(a) != 0)
                        .to_address(r!(b))
                        .plus_fixed(offset.into()),
                )?;
            }

            Instruction::JNEF(jnef) => {
                self.gas_charge(self.gas_costs().jnef())?;
                let (a, b, c, offset) = jnef.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::RelativeForwards)
                        .with_condition(r!(a) != r!(b))
                        .to_address(r!(c))
                        .plus_fixed(offset.into()),
                )?;
            }

            Instruction::JNEB(jneb) => {
                self.gas_charge(self.gas_costs().jneb())?;
                let (a, b, c, offset) = jneb.unpack();
                self.jump(
                    JumpArgs::new(JumpMode::RelativeBackwards)
                        .with_condition(r!(a) != r!(b))
                        .to_address(r!(c))
                        .plus_fixed(offset.into()),
                )?;
            }

            Instruction::RET(ret) => {
                self.gas_charge(self.gas_costs().ret())?;
                let a = ret.unpack();
                let ra = r!(a);
                self.ret(ra)?;
                return Ok(ExecuteState::Return(ra))
            }

            Instruction::RETD(retd) => {
                let (a, b) = retd.unpack();
                let len = r!(b);
                self.dependent_gas_charge(self.gas_costs().retd(), len)?;
                return Ok(self.ret_data(r!(a), len).map(ExecuteState::ReturnData)?)
            }

            Instruction::RVRT(rvrt) => {
                self.gas_charge(self.gas_costs().rvrt())?;
                let a = rvrt.unpack();
                let ra = r!(a);
                self.revert(ra)?;
                return Ok(ExecuteState::Revert(ra))
            }

            Instruction::SMO(smo) => {
                let (a, b, c, d) = smo.unpack();
                self.dependent_gas_charge(self.gas_costs().smo(), r!(c))?;
                self.message_output(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::ALOC(aloc) => {
                let a = aloc.unpack();
                let number_of_bytes = r!(a);
                self.dependent_gas_charge(self.gas_costs().aloc(), number_of_bytes)?;
                self.malloc(number_of_bytes)?;
            }

            Instruction::CFEI(cfei) => {
                let number_of_bytes = cfei.unpack().into();
                self.dependent_gas_charge(self.gas_costs().cfei(), number_of_bytes)?;
                self.stack_pointer_overflow(Word::overflowing_add, number_of_bytes)?;
            }

            Instruction::CFE(cfe) => {
                let a = cfe.unpack();
                let number_of_bytes = r!(a);
                self.dependent_gas_charge(self.gas_costs().cfe(), number_of_bytes)?;
                self.stack_pointer_overflow(Word::overflowing_add, number_of_bytes)?;
            }

            Instruction::CFSI(cfsi) => {
                self.gas_charge(self.gas_costs().cfsi())?;
                let imm = cfsi.unpack();
                self.stack_pointer_overflow(Word::overflowing_sub, imm.into())?;
            }

            Instruction::CFS(cfs) => {
                self.gas_charge(self.gas_costs().cfsi())?;
                let a = cfs.unpack();
                self.stack_pointer_overflow(Word::overflowing_sub, r!(a))?;
            }

            Instruction::PSHL(pshl) => {
                self.gas_charge(self.gas_costs().pshl())?;
                let bitmask = pshl.unpack();
                self.push_selected_registers(ProgramRegistersSegment::Low, bitmask)?;
            }

            Instruction::PSHH(pshh) => {
                self.gas_charge(self.gas_costs().pshh())?;
                let bitmask = pshh.unpack();
                self.push_selected_registers(ProgramRegistersSegment::High, bitmask)?;
            }

            Instruction::POPL(popl) => {
                self.gas_charge(self.gas_costs().popl())?;
                let bitmask = popl.unpack();
                self.pop_selected_registers(ProgramRegistersSegment::Low, bitmask)?;
            }

            Instruction::POPH(poph) => {
                self.gas_charge(self.gas_costs().poph())?;
                let bitmask = poph.unpack();
                self.pop_selected_registers(ProgramRegistersSegment::High, bitmask)?;
            }

            Instruction::LB(lb) => {
                self.gas_charge(self.gas_costs().lb())?;
                let (a, b, imm) = lb.unpack();
                self.load_byte(a.into(), r!(b), imm.into())?;
            }

            Instruction::LW(lw) => {
                self.gas_charge(self.gas_costs().lw())?;
                let (a, b, imm) = lw.unpack();
                self.load_word(a.into(), r!(b), imm)?;
            }

            Instruction::MCL(mcl) => {
                let (a, b) = mcl.unpack();
                let len = r!(b);
                self.dependent_gas_charge(self.gas_costs().mcl(), len)?;
                self.memclear(r!(a), len)?;
            }

            Instruction::MCLI(mcli) => {
                let (a, imm) = mcli.unpack();
                let len = Word::from(imm);
                self.dependent_gas_charge(self.gas_costs().mcli(), len)?;
                self.memclear(r!(a), len)?;
            }

            Instruction::MCP(mcp) => {
                let (a, b, c) = mcp.unpack();
                let len = r!(c);
                self.dependent_gas_charge(self.gas_costs().mcp(), len)?;
                self.memcopy(r!(a), r!(b), len)?;
            }

            Instruction::MCPI(mcpi) => {
                let (a, b, imm) = mcpi.unpack();
                let len = imm.into();
                self.dependent_gas_charge(self.gas_costs().mcpi(), len)?;
                self.memcopy(r!(a), r!(b), len)?;
            }

            Instruction::MEQ(meq) => {
                let (a, b, c, d) = meq.unpack();
                let len = r!(d);
                self.dependent_gas_charge(self.gas_costs().meq(), len)?;
                self.memeq(a.into(), r!(b), r!(c), len)?;
            }

            Instruction::SB(sb) => {
                self.gas_charge(self.gas_costs().sb())?;
                let (a, b, imm) = sb.unpack();
                self.store_byte(r!(a), r!(b), imm.into())?;
            }

            Instruction::SW(sw) => {
                self.gas_charge(self.gas_costs().sw())?;
                let (a, b, imm) = sw.unpack();
                self.store_word(r!(a), r!(b), imm)?;
            }

            Instruction::BAL(bal) => {
                self.gas_charge(self.gas_costs().bal())?;
                let (a, b, c) = bal.unpack();
                self.contract_balance(a.into(), r!(b), r!(c))?;
            }

            Instruction::BHEI(bhei) => {
                self.gas_charge(self.gas_costs().bhei())?;
                let a = bhei.unpack();
                self.block_height(a.into())?;
            }

            Instruction::BHSH(bhsh) => {
                self.gas_charge(self.gas_costs().bhsh())?;
                let (a, b) = bhsh.unpack();
                self.block_hash(r!(a), r!(b))?;
            }

            Instruction::BURN(burn) => {
                self.gas_charge(self.gas_costs().burn())?;
                let (a, b) = burn.unpack();
                self.burn(r!(a), r!(b))?;
            }

            Instruction::CALL(call) => {
                // We charge for the gas inside of the `prepare_call` function.
                let (a, b, c, d) = call.unpack();

                // Enter call context
                self.prepare_call(a, b, c, d)?;
            }

            Instruction::CB(cb) => {
                self.gas_charge(self.gas_costs().cb())?;
                let a = cb.unpack();
                self.block_proposer(r!(a))?;
            }

            Instruction::CCP(ccp) => {
                let (a, b, c, d) = ccp.unpack();
                self.code_copy(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::CROO(croo) => {
                let (a, b) = croo.unpack();
                self.code_root(r!(a), r!(b))?;
            }

            Instruction::CSIZ(csiz) => {
                // We charge for the gas inside of the `code_size` function.
                let (a, b) = csiz.unpack();
                self.code_size(a.into(), r!(b))?;
            }

            Instruction::LDC(ldc) => {
                // We charge for the gas inside of the `load_contract_code` function.
                let (a, b, c, mode) = ldc.unpack();
                self.load_contract_code(r!(a), r!(b), r!(c), mode)?;
            }

            Instruction::LOG(log) => {
                self.gas_charge(self.gas_costs().log())?;
                let (a, b, c, d) = log.unpack();
                self.log(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::LOGD(logd) => {
                let (a, b, c, d) = logd.unpack();
                self.dependent_gas_charge(self.gas_costs().logd(), r!(d))?;
                self.log_data(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::MINT(mint) => {
                self.gas_charge(self.gas_costs().mint())?;
                let (a, b) = mint.unpack();
                self.mint(r!(a), r!(b))?;
            }

            Instruction::SCWQ(scwq) => {
                let (a, b, c) = scwq.unpack();
                self.dependent_gas_charge(self.gas_costs().scwq(), r!(c))?;
                self.state_clear_qword(r!(a), b.into(), r!(c))?;
            }

            Instruction::SRW(srw) => {
                self.gas_charge(self.gas_costs().srw())?;
                let (a, b, c) = srw.unpack();
                self.state_read_word(a.into(), b.into(), r!(c))?;
            }

            Instruction::SRWQ(srwq) => {
                let (a, b, c, d) = srwq.unpack();
                self.dependent_gas_charge(self.gas_costs().srwq(), r!(d))?;
                self.state_read_qword(r!(a), b.into(), r!(c), r!(d))?;
            }

            Instruction::SWW(sww) => {
                self.gas_charge(self.gas_costs().sww())?;
                let (a, b, c) = sww.unpack();
                self.state_write_word(r!(a), b.into(), r!(c))?;
            }

            Instruction::SWWQ(swwq) => {
                let (a, b, c, d) = swwq.unpack();
                self.dependent_gas_charge(self.gas_costs().swwq(), r!(d))?;
                self.state_write_qword(r!(a), b.into(), r!(c), r!(d))?;
            }

            Instruction::TIME(time) => {
                self.gas_charge(self.gas_costs().time())?;
                let (a, b) = time.unpack();
                self.timestamp(a.into(), r!(b))?;
            }

            Instruction::ECK1(eck1) => {
                self.gas_charge(self.gas_costs().eck1())?;
                let (a, b, c) = eck1.unpack();
                self.secp256k1_recover(r!(a), r!(b), r!(c))?;
            }

            Instruction::ECR1(ecr1) => {
                self.gas_charge(self.gas_costs().ecr1())?;
                let (a, b, c) = ecr1.unpack();
                self.secp256r1_recover(r!(a), r!(b), r!(c))?;
            }

            Instruction::ED19(ed19) => {
                let (a, b, c, len) = ed19.unpack();
                let mut len = r!(len);

                // Backwards compatibility with old contracts
                if len == 0 {
                    len = 32;
                }

                self.dependent_gas_charge(self.gas_costs().ed19(), len)?;
                self.ed25519_verify(r!(a), r!(b), r!(c), len)?;
            }

            Instruction::K256(k256) => {
                let (a, b, c) = k256.unpack();
                let len = r!(c);
                self.dependent_gas_charge(self.gas_costs().k256(), len)?;
                self.keccak256(r!(a), r!(b), len)?;
            }

            Instruction::S256(s256) => {
                let (a, b, c) = s256.unpack();
                let len = r!(c);
                self.dependent_gas_charge(self.gas_costs().s256(), len)?;
                self.sha256(r!(a), r!(b), len)?;
            }

            Instruction::FLAG(flag) => {
                self.gas_charge(self.gas_costs().flag())?;
                let a = flag.unpack();
                self.set_flag(r!(a))?;
            }

            Instruction::GM(gm) => {
                self.gas_charge(self.gas_costs().gm())?;
                let (a, imm) = gm.unpack();
                self.metadata(a.into(), imm.into())?;
            }

            Instruction::GTF(gtf) => {
                self.gas_charge(self.gas_costs().gtf())?;
                let (a, b, imm) = gtf.unpack();
                self.get_transaction_field(a.into(), r!(b), imm.into())?;
            }

            Instruction::TR(tr) => {
                self.gas_charge(self.gas_costs().tr())?;
                let (a, b, c) = tr.unpack();
                self.transfer(r!(a), r!(b), r!(c))?;
            }

            Instruction::TRO(tro) => {
                self.gas_charge(self.gas_costs().tro())?;
                let (a, b, c, d) = tro.unpack();
                self.transfer_output(r!(a), r!(b), r!(c), r!(d))?;
            }

            Instruction::ECAL(ecal) => {
                let (a, b, c, d) = ecal.unpack();
                self.external_call(a, b, c, d)?;
            }

            Instruction::BSIZ(bsiz) => {
                // We charge for this inside the function.
                let (a, b) = bsiz.unpack();
                self.blob_size(a.into(), r!(b))?;
            }

            Instruction::BLDD(bldd) => {
                // We charge for this inside the function.
                let (a, b, c, d) = bldd.unpack();
                self.blob_load_data(r!(a), r!(b), r!(c), r!(d))?;
            }
        }

        Ok(ExecuteState::Proceed)
    }
}

/// Computes nth root of target, rounding down to nearest integer.
/// This function uses the floating point operation to get an approximate solution,
/// but corrects the result using exponentation to check for inaccuracy.
fn checked_nth_root(target: u64, nth_root: u64) -> Option<u64> {
    if nth_root == 0 {
        // Zeroth root is not defined
        return None
    }

    if nth_root == 1 || target <= 1 {
        // Corner cases
        return Some(target)
    }

    if nth_root >= target || nth_root > 64 {
        // For any root >= target, result always 1
        // For any n>1, n**64 can never fit into u64
        return Some(1)
    }

    let nth_root = u32::try_from(nth_root).expect("Never loses bits, checked above");

    // Use floating point operation to get an approximation for the starting point.
    // This is at most off by one in either direction.

    #[cfg(feature = "std")]
    let powf = f64::powf;
    #[cfg(not(feature = "std"))]
    let powf = libm::pow;

    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
    let guess = powf(target as f64, (nth_root as f64).recip()) as u64;

    debug_assert!(guess != 0, "This should never occur for {{target, n}} > 1");

    // Check if a value raised to nth_power is below the target value, handling overflow
    // correctly
    let is_nth_power_below_target = |v: u64| match v.checked_pow(nth_root) {
        Some(pow) => target < pow,
        None => true, // v**nth_root >= 2**64 and target < 2**64
    };

    // Compute guess**n to check if the guess is too large.
    // Note that if guess == 1, then g1 == 1 as well, meaning that we will not return
    // here.
    if is_nth_power_below_target(guess) {
        return Some(guess.saturating_sub(1))
    }

    // Check if the initial guess was correct
    let guess_plus_one = guess.checked_add(1).expect(
        "Guess cannot be u64::MAX, as we have taken a root > 2 of a value to get it",
    );
    if is_nth_power_below_target(guess_plus_one) {
        return Some(guess)
    }

    // If not, then the value above must be the correct one.
    Some(guess_plus_one)
}

#[cfg(test)]
mod tests;

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/executors/main.rs

Source
#[cfg(test)]
mod tests;

use crate::{
    checked_transaction::{
        Checked,
        IntoChecked,
        ParallelExecutor,
    },
    context::Context,
    error::{
        Bug,
        InterpreterError,
        PredicateVerificationFailed,
    },
    interpreter::{
        CheckedMetadata,
        EcalHandler,
        ExecutableTransaction,
        InitialBalances,
        Interpreter,
        Memory,
        RuntimeBalances,
    },
    pool::VmMemoryPool,
    predicate::RuntimePredicate,
    prelude::{
        BugVariant,
        RuntimeError,
    },
    state::{
        ExecuteState,
        ProgramState,
        StateTransitionRef,
    },
    storage::{
        predicate::PredicateStorage,
        BlobData,
        InterpreterStorage,
    },
};
use alloc::{
    vec,
    vec::Vec,
};
use core::fmt::Debug;

use crate::{
    checked_transaction::{
        CheckError,
        CheckPredicateParams,
        Ready,
    },
    interpreter::InterpreterParams,
    prelude::MemoryInstance,
    storage::{
        predicate::PredicateStorageRequirements,
        UploadedBytecode,
        UploadedBytecodes,
    },
};
use fuel_asm::PanicReason;
use fuel_storage::{
    StorageAsMut,
    StorageAsRef,
};
use fuel_tx::{
    field::{
        BlobId as _,
        BytecodeRoot,
        BytecodeWitnessIndex,
        ReceiptsRoot,
        Salt,
        Script as ScriptField,
        ScriptGasLimit,
        StorageSlots,
        SubsectionIndex,
        SubsectionsNumber,
        UpgradePurpose as UpgradePurposeField,
        Witnesses,
    },
    input::{
        coin::CoinPredicate,
        message::{
            MessageCoinPredicate,
            MessageDataPredicate,
        },
    },
    Blob,
    BlobIdExt,
    ConsensusParameters,
    Contract,
    Create,
    FeeParameters,
    GasCosts,
    Input,
    Receipt,
    ScriptExecutionResult,
    Upgrade,
    UpgradeMetadata,
    UpgradePurpose,
    Upload,
    ValidityError,
};
use fuel_types::{
    AssetId,
    BlobId,
    Word,
};

/// Predicates were checked succesfully
#[derive(Debug, Clone, Copy)]
pub struct PredicatesChecked {
    gas_used: Word,
}

impl PredicatesChecked {
    pub fn gas_used(&self) -> Word {
        self.gas_used
    }
}

enum PredicateRunKind<'a, Tx> {
    Verifying(&'a Tx),
    Estimating(&'a mut Tx),
}

impl<'a, Tx> PredicateRunKind<'a, Tx> {
    fn tx(&self) -> &Tx {
        match self {
            PredicateRunKind::Verifying(tx) => tx,
            PredicateRunKind::Estimating(tx) => tx,
        }
    }
}

#[derive(Debug, Clone, Copy)]
enum PredicateAction {
    Verifying,
    Estimating { available_gas: Word },
}

/// The module contains functions to check predicates defined in the inputs of a
/// transaction.
pub mod predicates {
    use super::*;
    use crate::storage::predicate::PredicateStorageProvider;

    /// Initialize the VM with the provided transaction and check all predicates defined
    /// in the inputs.
    ///
    /// The storage provider is not used since contract opcodes are not allowed for
    /// predicates.
    pub fn check_predicates<Tx>(
        checked: &Checked<Tx>,
        params: &CheckPredicateParams,
        mut memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction,
        <Tx as IntoChecked>::Metadata: CheckedMetadata,
    {
        let tx = checked.transaction();
        run_predicates(
            PredicateRunKind::Verifying(tx),
            params,
            memory.as_mut(),
            storage,
        )
    }

    /// Initialize the VM with the provided transaction and check all predicates defined
    /// in the inputs in parallel.
    ///
    /// The storage provider is not used since contract opcodes are not allowed for
    /// predicates.
    pub async fn check_predicates_async<Tx, E>(
        checked: &Checked<Tx>,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction + Send + 'static,
        <Tx as IntoChecked>::Metadata: CheckedMetadata,
        E: ParallelExecutor,
    {
        let tx = checked.transaction();

        let predicates_checked = run_predicate_async::<Tx, E>(
            PredicateRunKind::Verifying(tx),
            params,
            pool,
            storage,
        )
        .await?;

        Ok(predicates_checked)
    }

    /// Initialize the VM with the provided transaction, check all predicates defined in
    /// the inputs and set the predicate_gas_used to be the actual gas consumed during
    /// execution for each predicate.
    ///
    /// The storage provider is not used since contract opcodes are not allowed for
    /// predicates.
    pub fn estimate_predicates<Tx>(
        transaction: &mut Tx,
        params: &CheckPredicateParams,
        mut memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction,
    {
        let predicates_checked = run_predicates(
            PredicateRunKind::Estimating(transaction),
            params,
            memory.as_mut(),
            storage,
        )?;
        Ok(predicates_checked)
    }

    /// Initialize the VM with the provided transaction, check all predicates defined in
    /// the inputs and set the predicate_gas_used to be the actual gas consumed during
    /// execution for each predicate in parallel.
    ///
    /// The storage provider is not used since contract opcodes are not allowed for
    /// predicates.
    pub async fn estimate_predicates_async<Tx, E>(
        transaction: &mut Tx,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction + Send + 'static,
        E: ParallelExecutor,
    {
        let predicates_checked = run_predicate_async::<Tx, E>(
            PredicateRunKind::Estimating(transaction),
            params,
            pool,
            storage,
        )
        .await?;

        Ok(predicates_checked)
    }

    async fn run_predicate_async<Tx, E>(
        kind: PredicateRunKind<'_, Tx>,
        params: &CheckPredicateParams,
        pool: &impl VmMemoryPool,
        storage: &impl PredicateStorageProvider,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction + Send + 'static,
        E: ParallelExecutor,
    {
        let mut checks = vec![];
        let tx_offset = params.tx_offset;

        let max_gas_per_tx = params.max_gas_per_tx;
        let max_gas_per_predicate = params.max_gas_per_predicate;
        let available_gas = core::cmp::min(max_gas_per_predicate, max_gas_per_tx);
        let predicate_action = match kind {
            PredicateRunKind::Verifying(_) => PredicateAction::Verifying,
            PredicateRunKind::Estimating(_) => {
                PredicateAction::Estimating { available_gas }
            }
        };

        for index in 0..kind.tx().inputs().len() {
            if let Some(predicate) =
                RuntimePredicate::from_tx(kind.tx(), tx_offset, index)
            {
                let tx = kind.tx().clone();
                let my_params = params.clone();
                let mut memory = pool.get_new().await;
                let storage_instance = storage.storage();

                let verify_task = E::create_task(move || {
                    let (used_gas, result) = check_predicate(
                        tx,
                        index,
                        predicate_action,
                        predicate,
                        my_params,
                        memory.as_mut(),
                        &storage_instance,
                    );

                    result.map(|_| (used_gas, index))
                });

                checks.push(verify_task);
            }
        }

        let checks = E::execute_tasks(checks).await;

        finalize_check_predicate(kind, checks, params)
    }

    fn run_predicates<Tx>(
        kind: PredicateRunKind<'_, Tx>,
        params: &CheckPredicateParams,
        mut memory: impl Memory,
        storage: &impl PredicateStorageRequirements,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction,
    {
        let mut checks = vec![];

        let max_gas = kind.tx().max_gas(&params.gas_costs, &params.fee_params);
        let max_gas_per_tx = params.max_gas_per_tx;
        let max_gas_per_predicate = params.max_gas_per_predicate;
        let mut available_gas =
            core::cmp::min(max_gas_per_predicate, max_gas_per_tx).saturating_sub(max_gas);

        for index in 0..kind.tx().inputs().len() {
            let tx = kind.tx().clone();

            if let Some(predicate) =
                RuntimePredicate::from_tx(&tx, params.tx_offset, index)
            {
                let predicate_action = match kind {
                    PredicateRunKind::Verifying(_) => PredicateAction::Verifying,
                    PredicateRunKind::Estimating(_) => {
                        PredicateAction::Estimating { available_gas }
                    }
                };
                let (gas_used, result) = check_predicate(
                    tx,
                    index,
                    predicate_action,
                    predicate,
                    params.clone(),
                    memory.as_mut(),
                    storage,
                );
                available_gas = available_gas.saturating_sub(gas_used);
                let result = result.map(|_| (gas_used, index));
                checks.push(result);
            }
        }

        finalize_check_predicate(kind, checks, params)
    }

    fn check_predicate<Tx>(
        tx: Tx,
        index: usize,
        predicate_action: PredicateAction,
        predicate: RuntimePredicate,
        params: CheckPredicateParams,
        memory: &mut MemoryInstance,
        storage: &impl PredicateStorageRequirements,
    ) -> (Word, Result<(), PredicateVerificationFailed>)
    where
        Tx: ExecutableTransaction,
    {
        match &tx.inputs()[index] {
            Input::CoinPredicate(CoinPredicate {
                owner: address,
                predicate,
                ..
            })
            | Input::MessageDataPredicate(MessageDataPredicate {
                recipient: address,
                predicate,
                ..
            })
            | Input::MessageCoinPredicate(MessageCoinPredicate {
                predicate,
                recipient: address,
                ..
            }) => {
                if !Input::is_predicate_owner_valid(address, &**predicate) {
                    return (0, Err(PredicateVerificationFailed::InvalidOwner));
                }
            }
            _ => {}
        }

        let zero_gas_price = 0;
        let interpreter_params = InterpreterParams::new(zero_gas_price, params);

        let mut vm = Interpreter::<_, _, _>::with_storage(
            memory,
            PredicateStorage::new(storage),
            interpreter_params,
        );

        let (context, available_gas) = match predicate_action {
            PredicateAction::Verifying => {
                let context = Context::PredicateVerification { program: predicate };
                let available_gas = tx.inputs()[index]
                    .predicate_gas_used()
                    .expect("We only run predicates at this stage, so it should exist.");

                (context, available_gas)
            }
            PredicateAction::Estimating { available_gas } => {
                let context = Context::PredicateEstimation { program: predicate };

                (context, available_gas)
            }
        };

        if let Err(err) = vm.init_predicate(context, tx, available_gas) {
            return (0, Err(err.into()));
        }

        let result = vm.verify_predicate();
        let is_successful = matches!(result, Ok(ProgramState::Return(0x01)));

        let Some(gas_used) = available_gas.checked_sub(vm.remaining_gas()) else {
            return (0, Err(Bug::new(BugVariant::GlobalGasUnderflow).into()));
        };

        if let PredicateAction::Verifying = predicate_action {
            if !is_successful {
                return if let Err(err) = result {
                    (gas_used, Err(err))
                } else {
                    (gas_used, Err(PredicateVerificationFailed::False))
                }
            }

            if vm.remaining_gas() != 0 {
                return (gas_used, Err(PredicateVerificationFailed::GasMismatch));
            }
        }

        (gas_used, Ok(()))
    }

    fn finalize_check_predicate<Tx>(
        mut kind: PredicateRunKind<Tx>,
        checks: Vec<Result<(Word, usize), PredicateVerificationFailed>>,
        params: &CheckPredicateParams,
    ) -> Result<PredicatesChecked, PredicateVerificationFailed>
    where
        Tx: ExecutableTransaction,
    {
        if let PredicateRunKind::Estimating(tx) = &mut kind {
            checks.iter().for_each(|result| {
                if let Ok((gas_used, index)) = result {
                    match &mut tx.inputs_mut()[*index] {
                        Input::CoinPredicate(CoinPredicate {
                            predicate_gas_used,
                            ..
                        })
                        | Input::MessageCoinPredicate(MessageCoinPredicate {
                            predicate_gas_used,
                            ..
                        })
                        | Input::MessageDataPredicate(MessageDataPredicate {
                            predicate_gas_used,
                            ..
                        }) => {
                            *predicate_gas_used = *gas_used;
                        }
                        _ => {
                            unreachable!(
                                "It was checked before during iteration over predicates"
                            )
                        }
                    }
                }
            });
        }

        let max_gas = kind.tx().max_gas(&params.gas_costs, &params.fee_params);
        if max_gas > params.max_gas_per_tx {
            return Err(
                PredicateVerificationFailed::TransactionExceedsTotalGasAllowance(max_gas),
            );
        }

        let cumulative_gas_used = checks.into_iter().try_fold(0u64, |acc, result| {
            acc.checked_add(result.map(|(gas_used, _)| gas_used)?)
                .ok_or(PredicateVerificationFailed::OutOfGas)
        })?;

        Ok(PredicatesChecked {
            gas_used: cumulative_gas_used,
        })
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    fn deploy_inner(
        create: &mut Create,
        storage: &mut S,
        initial_balances: InitialBalances,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        base_asset_id: &AssetId,
        gas_price: Word,
    ) -> Result<(), InterpreterError<S::DataError>> {
        let metadata = create.metadata().as_ref();
        debug_assert!(
            metadata.is_some(),
            "`deploy_inner` is called without cached metadata"
        );
        let salt = create.salt();
        let storage_slots = create.storage_slots();
        let contract = Contract::try_from(&*create)?;
        let root = if let Some(m) = metadata {
            m.body.contract_root
        } else {
            contract.root()
        };

        let storage_root = if let Some(m) = metadata {
            m.body.state_root
        } else {
            Contract::initial_state_root(storage_slots.iter())
        };

        let id = if let Some(m) = metadata {
            m.body.contract_id
        } else {
            contract.id(salt, &root, &storage_root)
        };

        // Prevent redeployment of contracts
        if storage
            .storage_contract_exists(&id)
            .map_err(RuntimeError::Storage)?
        {
            return Err(InterpreterError::Panic(
                PanicReason::ContractIdAlreadyDeployed,
            ));
        }

        storage
            .deploy_contract_with_id(storage_slots, &contract, &id)
            .map_err(RuntimeError::Storage)?;
        Self::finalize_outputs(
            create,
            gas_costs,
            fee_params,
            base_asset_id,
            false,
            0,
            &initial_balances,
            &RuntimeBalances::try_from(initial_balances.clone())?,
            gas_price,
        )?;
        Ok(())
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    fn upgrade_inner(
        upgrade: &mut Upgrade,
        storage: &mut S,
        initial_balances: InitialBalances,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        base_asset_id: &AssetId,
        gas_price: Word,
    ) -> Result<(), InterpreterError<S::DataError>> {
        let metadata = upgrade.metadata().as_ref();
        debug_assert!(
            metadata.is_some(),
            "`upgrade_inner` is called without cached metadata"
        );

        match upgrade.upgrade_purpose() {
            UpgradePurpose::ConsensusParameters { .. } => {
                let consensus_parameters = if let Some(metadata) = metadata {
                    Self::get_consensus_parameters(&metadata.body)?
                } else {
                    let metadata = UpgradeMetadata::compute(upgrade)?;
                    Self::get_consensus_parameters(&metadata)?
                };

                let current_version = storage
                    .consensus_parameters_version()
                    .map_err(RuntimeError::Storage)?;
                let next_version = current_version.saturating_add(1);

                let prev = storage
                    .set_consensus_parameters(next_version, &consensus_parameters)
                    .map_err(RuntimeError::Storage)?;

                if prev.is_some() {
                    return Err(InterpreterError::Panic(
                        PanicReason::OverridingConsensusParameters,
                    ));
                }
            }
            UpgradePurpose::StateTransition { root } => {
                let exists = storage
                    .contains_state_transition_bytecode_root(root)
                    .map_err(RuntimeError::Storage)?;

                if !exists {
                    return Err(InterpreterError::Panic(
                        PanicReason::UnknownStateTransactionBytecodeRoot,
                    ))
                }

                let current_version = storage
                    .state_transition_version()
                    .map_err(RuntimeError::Storage)?;
                let next_version = current_version.saturating_add(1);

                let prev = storage
                    .set_state_transition_bytecode(next_version, root)
                    .map_err(RuntimeError::Storage)?;

                if prev.is_some() {
                    return Err(InterpreterError::Panic(
                        PanicReason::OverridingStateTransactionBytecode,
                    ));
                }
            }
        }

        Self::finalize_outputs(
            upgrade,
            gas_costs,
            fee_params,
            base_asset_id,
            false,
            0,
            &initial_balances,
            &RuntimeBalances::try_from(initial_balances.clone())?,
            gas_price,
        )?;
        Ok(())
    }

    fn get_consensus_parameters(
        metadata: &UpgradeMetadata,
    ) -> Result<ConsensusParameters, InterpreterError<S::DataError>> {
        match &metadata {
            UpgradeMetadata::ConsensusParameters {
                consensus_parameters,
                ..
            } => Ok(consensus_parameters.as_ref().clone()),
            UpgradeMetadata::StateTransition => {
                // It shouldn't be possible since `Check<Upgrade>` guarantees that.
                Err(InterpreterError::CheckError(CheckError::Validity(
                    ValidityError::TransactionMetadataMismatch,
                )))
            }
        }
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    fn upload_inner(
        upload: &mut Upload,
        storage: &mut S,
        initial_balances: InitialBalances,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        base_asset_id: &AssetId,
        gas_price: Word,
    ) -> Result<(), InterpreterError<S::DataError>> {
        let root = *upload.bytecode_root();
        let uploaded_bytecode = storage
            .storage_as_ref::<UploadedBytecodes>()
            .get(&root)
            .map_err(RuntimeError::Storage)?
            .map(|x| x.into_owned())
            .unwrap_or_else(|| UploadedBytecode::Uncompleted {
                bytecode: vec![],
                uploaded_subsections_number: 0,
            });

        let new_bytecode = match uploaded_bytecode {
            UploadedBytecode::Uncompleted {
                bytecode,
                uploaded_subsections_number,
            } => Self::upload_bytecode_subsection(
                upload,
                bytecode,
                uploaded_subsections_number,
            )?,
            UploadedBytecode::Completed(_) => {
                return Err(InterpreterError::Panic(
                    PanicReason::BytecodeAlreadyUploaded,
                ));
            }
        };

        storage
            .storage_as_mut::<UploadedBytecodes>()
            .insert(&root, &new_bytecode)
            .map_err(RuntimeError::Storage)?;

        Self::finalize_outputs(
            upload,
            gas_costs,
            fee_params,
            base_asset_id,
            false,
            0,
            &initial_balances,
            &RuntimeBalances::try_from(initial_balances.clone())?,
            gas_price,
        )?;
        Ok(())
    }

    fn upload_bytecode_subsection(
        upload: &Upload,
        mut uploaded_bytecode: Vec<u8>,
        uploaded_subsections_number: u16,
    ) -> Result<UploadedBytecode, InterpreterError<S::DataError>> {
        let index_of_next_subsection = uploaded_subsections_number;

        if *upload.subsection_index() != index_of_next_subsection {
            return Err(InterpreterError::Panic(
                PanicReason::ThePartIsNotSequentiallyConnected,
            ));
        }

        let bytecode_subsection = upload
            .witnesses()
            .get(*upload.bytecode_witness_index() as usize)
            .ok_or(InterpreterError::Bug(Bug::new(
                // It shouldn't be possible since `Checked<Upload>` guarantees
                // the existence of the witness.
                BugVariant::WitnessIndexOutOfBounds,
            )))?;

        uploaded_bytecode.extend(bytecode_subsection.as_ref());

        let new_uploaded_subsections_number = uploaded_subsections_number
            .checked_add(1)
            .ok_or(InterpreterError::Panic(PanicReason::ArithmeticOverflow))?;

        // It shouldn't be possible since `Checked<Upload>` guarantees
        // the validity of the Merkle proof.
        if new_uploaded_subsections_number > *upload.subsections_number() {
            return Err(InterpreterError::Bug(Bug::new(
                BugVariant::NextSubsectionIndexIsHigherThanTotalNumberOfParts,
            )))
        }

        let updated_uploaded_bytecode =
            if *upload.subsections_number() == new_uploaded_subsections_number {
                UploadedBytecode::Completed(uploaded_bytecode)
            } else {
                UploadedBytecode::Uncompleted {
                    bytecode: uploaded_bytecode,
                    uploaded_subsections_number: new_uploaded_subsections_number,
                }
            };

        Ok(updated_uploaded_bytecode)
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    fn blob_inner(
        blob: &mut Blob,
        storage: &mut S,
        initial_balances: InitialBalances,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        base_asset_id: &AssetId,
        gas_price: Word,
    ) -> Result<(), InterpreterError<S::DataError>> {
        let blob_data = blob
            .witnesses()
            .get(*blob.bytecode_witness_index() as usize)
            .ok_or(InterpreterError::Bug(Bug::new(
                // It shouldn't be possible since `Checked<Blob>` guarantees
                // the existence of the witness.
                BugVariant::WitnessIndexOutOfBounds,
            )))?;

        let blob_id = blob.blob_id();

        debug_assert_eq!(
            BlobId::compute(blob_data.as_ref()),
            *blob_id,
            "Tx has invalid BlobId",
        );

        let old = storage
            .storage_as_mut::<BlobData>()
            .replace(blob_id, blob_data.as_ref())
            .map_err(RuntimeError::Storage)?;

        if old.is_some() {
            return Err(InterpreterError::Panic(PanicReason::BlobIdAlreadyUploaded));
        }

        Self::finalize_outputs(
            blob,
            gas_costs,
            fee_params,
            base_asset_id,
            false,
            0,
            &initial_balances,
            &RuntimeBalances::try_from(initial_balances.clone())?,
            gas_price,
        )?;

        Ok(())
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler,
{
    fn update_transaction_outputs(
        &mut self,
    ) -> Result<(), InterpreterError<S::DataError>> {
        let outputs = self.transaction().outputs().len();
        (0..outputs).try_for_each(|o| self.update_memory_output(o))?;
        Ok(())
    }

    pub(crate) fn run(&mut self) -> Result<ProgramState, InterpreterError<S::DataError>> {
        // TODO: Remove `Create`, `Upgrade`, and `Upload` from here
        //  https://github.com/FuelLabs/fuel-vm/issues/251
        let gas_costs = self.gas_costs().clone();
        let fee_params = *self.fee_params();
        let base_asset_id = *self.base_asset_id();
        let gas_price = self.gas_price();
        let state = if let Some(create) = self.tx.as_create_mut() {
            Self::deploy_inner(
                create,
                &mut self.storage,
                self.initial_balances.clone(),
                &gas_costs,
                &fee_params,
                &base_asset_id,
                gas_price,
            )?;
            ProgramState::Return(1)
        } else if let Some(upgrade) = self.tx.as_upgrade_mut() {
            Self::upgrade_inner(
                upgrade,
                &mut self.storage,
                self.initial_balances.clone(),
                &gas_costs,
                &fee_params,
                &base_asset_id,
                gas_price,
            )?;
            ProgramState::Return(1)
        } else if let Some(upload) = self.tx.as_upload_mut() {
            Self::upload_inner(
                upload,
                &mut self.storage,
                self.initial_balances.clone(),
                &gas_costs,
                &fee_params,
                &base_asset_id,
                gas_price,
            )?;
            ProgramState::Return(1)
        } else if let Some(blob) = self.tx.as_blob_mut() {
            Self::blob_inner(
                blob,
                &mut self.storage,
                self.initial_balances.clone(),
                &gas_costs,
                &fee_params,
                &base_asset_id,
                gas_price,
            )?;
            ProgramState::Return(1)
        } else {
            if self.transaction().inputs().iter().any(|input| {
                if let Input::Contract(contract) = input {
                    !self
                        .check_contract_exists(&contract.contract_id)
                        .unwrap_or(false)
                } else {
                    false
                }
            }) {
                return Err(InterpreterError::Panic(PanicReason::ContractNotInInputs));
            }

            let gas_limit;
            let is_empty_script;
            if let Some(script) = self.transaction().as_script() {
                gas_limit = *script.script_gas_limit();
                is_empty_script = script.script().is_empty();
            } else {
                unreachable!("Only `Create` and `Script` transactions can be executed inside of the VM")
            }

            // TODO set tree balance

            // `Interpreter` supports only `Create` and `Script` transactions. It is not
            // `Create` -> it is `Script`.
            let program = if !is_empty_script {
                self.run_program()
            } else {
                // Return `1` as successful execution.
                let return_val = 1;
                self.ret(return_val)?;
                Ok(ProgramState::Return(return_val))
            };

            let gas_used = gas_limit
                .checked_sub(self.remaining_gas())
                .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;

            // Catch VM panic and don't propagate, generating a receipt
            let (status, program) = match program {
                Ok(s) => {
                    // either a revert or success
                    let res = if let ProgramState::Revert(_) = &s {
                        ScriptExecutionResult::Revert
                    } else {
                        ScriptExecutionResult::Success
                    };
                    (res, s)
                }

                Err(e) => match e.instruction_result() {
                    Some(result) => {
                        self.append_panic_receipt(result);

                        (ScriptExecutionResult::Panic, ProgramState::Revert(0))
                    }

                    // This isn't a specified case of an erroneous program and should be
                    // propagated. If applicable, OS errors will fall into this category.
                    None => return Err(e),
                },
            };

            let receipt = Receipt::script_result(status, gas_used);

            self.receipts.push(receipt)?;

            if program.is_debug() {
                self.debugger_set_last_state(program);
            }

            let revert = matches!(program, ProgramState::Revert(_));
            let gas_price = self.gas_price();
            Self::finalize_outputs(
                &mut self.tx,
                &gas_costs,
                &fee_params,
                &base_asset_id,
                revert,
                gas_used,
                &self.initial_balances,
                &self.balances,
                gas_price,
            )?;

            program
        };
        self.update_transaction_outputs()?;

        Ok(state)
    }

    pub(crate) fn run_program(
        &mut self,
    ) -> Result<ProgramState, InterpreterError<S::DataError>> {
        loop {
            // Check whether the instruction will be executed in a call context
            let in_call = !self.frames.is_empty();

            let state = self.execute()?;

            if in_call {
                // Only reverts should terminate execution from a call context
                if let ExecuteState::Revert(r) = state {
                    return Ok(ProgramState::Revert(r));
                }
            } else {
                match state {
                    ExecuteState::Return(r) => return Ok(ProgramState::Return(r)),

                    ExecuteState::ReturnData(d) => return Ok(ProgramState::ReturnData(d)),

                    ExecuteState::Revert(r) => return Ok(ProgramState::Revert(r)),

                    ExecuteState::Proceed => (),

                    ExecuteState::DebugEvent(d) => return Ok(ProgramState::RunProgram(d)),
                }
            }
        }
    }

    /// Update tx fields after execution
    pub(crate) fn post_execute(&mut self) {
        if let Some(script) = self.tx.as_script_mut() {
            *script.receipts_root_mut() = self.receipts.root();
        }
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,
    Ecal: EcalHandler,
{
    /// Initialize a pre-allocated instance of [`Interpreter`] with the provided
    /// transaction and execute it. The result will be bound to the lifetime
    /// of the interpreter and will avoid unnecessary copy with the data
    /// that can be referenced from the interpreter instance itself.
    pub fn transact(
        &mut self,
        tx: Ready<Tx>,
    ) -> Result<StateTransitionRef<'_, Tx>, InterpreterError<S::DataError>> {
        self.verify_ready_tx(&tx)?;

        let state_result = self.init_script(tx).and_then(|_| self.run());
        self.post_execute();

        #[cfg(feature = "profile-any")]
        {
            let r = match &state_result {
                Ok(state) => Ok(state),
                Err(err) => Err(err.erase_generics()),
            };
            self.profiler.on_transaction(r);
        }

        let state = state_result?;
        Ok(StateTransitionRef::new(
            state,
            self.transaction(),
            self.receipts(),
        ))
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    /// Deploys `Create` transaction without initialization VM and without invalidation of
    /// the last state of execution of the `Script` transaction.
    ///
    /// Returns `Create` transaction with all modifications after execution.
    pub fn deploy(
        &mut self,
        tx: Ready<Create>,
    ) -> Result<Create, InterpreterError<S::DataError>> {
        self.verify_ready_tx(&tx)?;

        let (_, checked) = tx.decompose();
        let (mut create, metadata): (Create, <Create as IntoChecked>::Metadata) =
            checked.into();
        let base_asset_id = *self.base_asset_id();
        let gas_price = self.gas_price();
        Self::deploy_inner(
            &mut create,
            &mut self.storage,
            metadata.balances(),
            &self.interpreter_params.gas_costs,
            &self.interpreter_params.fee_params,
            &base_asset_id,
            gas_price,
        )?;
        Ok(create)
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    /// Executes `Upgrade` transaction without initialization VM and without invalidation
    /// of the last state of execution of the `Script` transaction.
    ///
    /// Returns `Upgrade` transaction with all modifications after execution.
    pub fn upgrade(
        &mut self,
        tx: Ready<Upgrade>,
    ) -> Result<Upgrade, InterpreterError<S::DataError>> {
        self.verify_ready_tx(&tx)?;

        let (_, checked) = tx.decompose();
        let (mut upgrade, metadata): (Upgrade, <Upgrade as IntoChecked>::Metadata) =
            checked.into();
        let base_asset_id = *self.base_asset_id();
        let gas_price = self.gas_price();
        Self::upgrade_inner(
            &mut upgrade,
            &mut self.storage,
            metadata.balances(),
            &self.interpreter_params.gas_costs,
            &self.interpreter_params.fee_params,
            &base_asset_id,
            gas_price,
        )?;
        Ok(upgrade)
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    /// Executes `Upload` transaction without initialization VM and without invalidation
    /// of the last state of execution of the `Script` transaction.
    ///
    /// Returns `Upload` transaction with all modifications after execution.
    pub fn upload(
        &mut self,
        tx: Ready<Upload>,
    ) -> Result<Upload, InterpreterError<S::DataError>> {
        self.verify_ready_tx(&tx)?;

        let (_, checked) = tx.decompose();
        let (mut upload, metadata): (Upload, <Upload as IntoChecked>::Metadata) =
            checked.into();
        let base_asset_id = *self.base_asset_id();
        let gas_price = self.gas_price();
        Self::upload_inner(
            &mut upload,
            &mut self.storage,
            metadata.balances(),
            &self.interpreter_params.gas_costs,
            &self.interpreter_params.fee_params,
            &base_asset_id,
            gas_price,
        )?;
        Ok(upload)
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    S: InterpreterStorage,
{
    /// Executes `Blob` transaction without initialization VM and without invalidation
    /// of the last state of execution of the `Script` transaction.
    ///
    /// Returns `Blob` transaction with all modifications after execution.
    pub fn blob(
        &mut self,
        tx: Ready<Blob>,
    ) -> Result<Blob, InterpreterError<S::DataError>> {
        self.verify_ready_tx(&tx)?;

        let (_, checked) = tx.decompose();
        let (mut blob, metadata): (Blob, <Blob as IntoChecked>::Metadata) =
            checked.into();
        let base_asset_id = *self.base_asset_id();
        let gas_price = self.gas_price();
        Self::blob_inner(
            &mut blob,
            &mut self.storage,
            metadata.balances(),
            &self.interpreter_params.gas_costs,
            &self.interpreter_params.fee_params,
            &base_asset_id,
            gas_price,
        )?;
        Ok(blob)
    }
}

impl<M, S: InterpreterStorage, Tx, Ecal> Interpreter<M, S, Tx, Ecal> {
    fn verify_ready_tx<Tx2: IntoChecked>(
        &self,
        tx: &Ready<Tx2>,
    ) -> Result<(), InterpreterError<S::DataError>> {
        self.gas_price_matches(tx)?;
        Ok(())
    }

    fn gas_price_matches<Tx2: IntoChecked>(
        &self,
        tx: &Ready<Tx2>,
    ) -> Result<(), InterpreterError<S::DataError>> {
        if tx.gas_price() != self.gas_price() {
            Err(InterpreterError::ReadyTransactionWrongGasPrice {
                expected: self.gas_price(),
                actual: tx.gas_price(),
            })
        } else {
            Ok(())
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/ecal.rs

Source
//! See `fuel-vm/examples/external.rs` for example usage.

use fuel_asm::{
    PanicReason,
    RegId,
};

use crate::{
    constraints::reg_key::{
        split_registers,
        SystemRegisters,
    },
    error::SimpleResult,
    interpreter::NotSupportedEcal,
};

use super::{
    internal::inc_pc,
    Interpreter,
    Memory,
};

/// ECAL opcode handler
pub trait EcalHandler: Clone
where
    Self: Sized,
{
    /// Whether to increment PC after executing ECAL. If this is false,
    /// the handler must increment PC itself.
    const INC_PC: bool = true;

    /// ECAL opcode handler
    fn ecal<M, S, Tx>(
        vm: &mut Interpreter<M, S, Tx, Self>,
        a: RegId,
        b: RegId,
        c: RegId,
        d: RegId,
    ) -> SimpleResult<()>
    where
        M: Memory;
}

/// Default ECAL opcode handler function, which just errors immediately.
impl EcalHandler for NotSupportedEcal {
    fn ecal<M, S, Tx>(
        _: &mut Interpreter<M, S, Tx, Self>,
        _: RegId,
        _: RegId,
        _: RegId,
        _: RegId,
    ) -> SimpleResult<()> {
        Err(PanicReason::EcalError)?
    }
}

/// ECAL is not allowed in predicates
#[derive(Debug, Clone, Copy, Default)]
pub struct PredicateErrorEcal;

/// ECAL is not allowed in predicates
impl EcalHandler for PredicateErrorEcal {
    fn ecal<M, S, Tx>(
        _vm: &mut Interpreter<M, S, Tx, Self>,
        _: RegId,
        _: RegId,
        _: RegId,
        _: RegId,
    ) -> SimpleResult<()> {
        Err(PanicReason::ContractInstructionNotAllowed)?
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Ecal: EcalHandler,
{
    /// Executes ECAL opcode handler function and increments PC
    pub(crate) fn external_call(
        &mut self,
        a: RegId,
        b: RegId,
        c: RegId,
        d: RegId,
    ) -> SimpleResult<()> {
        Ecal::ecal(self, a, b, c, d)?;
        let (SystemRegisters { pc, .. }, _) = split_registers(&mut self.registers);
        if Ecal::INC_PC {
            Ok(inc_pc(pc)?)
        } else {
            Ok(())
        }
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    Ecal: EcalHandler,
{
    /// Read access to the ECAL state
    pub fn ecal_state(&self) -> &Ecal {
        &self.ecal_state
    }

    /// Write access to the ECAL state
    pub fn ecal_state_mut(&mut self) -> &mut Ecal {
        &mut self.ecal_state
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/receipts.rs

Source
use alloc::vec::Vec;
use core::{
    mem,
    ops::Index,
};
use fuel_asm::PanicReason;

use fuel_merkle::binary::root_calculator::MerkleRootCalculator as MerkleTree;
use fuel_tx::Receipt;
use fuel_types::{
    canonical::Serialize,
    Bytes32,
};

use crate::{
    error::SimpleResult,
    prelude::{
        Bug,
        BugVariant,
    },
};

/// Receipts and the associated Merkle tree
#[derive(Debug, Default, Clone)]
pub struct ReceiptsCtx {
    receipts: Vec<Receipt>,
    receipts_tree: MerkleTree,
}

impl ReceiptsCtx {
    /// The maximum number of receipts that can be stored in a single context.
    /// https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/instruction-set.md#Receipts
    pub const MAX_RECEIPTS: usize = u16::MAX as usize;

    /// Add a new receipt, updating the Merkle tree as well.
    /// Returns a panic if the context is full.
    pub fn push(&mut self, receipt: Receipt) -> SimpleResult<()> {
        if self.receipts.len() == Self::MAX_RECEIPTS {
            return Err(Bug::new(BugVariant::ReceiptsCtxFull).into())
        }

        // Last two slots can be only used for ending the script,
        // with a script result optinally preceded by a panic
        if (self.receipts.len() == Self::MAX_RECEIPTS - 1
            && !matches!(receipt, Receipt::ScriptResult { .. }))
            || (self.receipts.len() == Self::MAX_RECEIPTS - 2
                && !matches!(
                    receipt,
                    Receipt::ScriptResult { .. } | Receipt::Panic { .. }
                ))
        {
            return Err(PanicReason::TooManyReceipts.into())
        }

        self.receipts_tree.push(receipt.to_bytes().as_slice());
        self.receipts.push(receipt);
        Ok(())
    }

    /// Reset the context to an empty state
    pub fn clear(&mut self) {
        self.receipts_tree = MerkleTree::new();
        self.receipts.clear();
    }

    /// Return how many receipts are in this context
    pub fn len(&self) -> usize {
        self.receipts.len()
    }

    /// Returns `true` if the context has no receipts.
    pub fn is_empty(&self) -> bool {
        self.receipts.len() == 0
    }

    /// Return current Merkle root of the receipts
    pub fn root(&self) -> Bytes32 {
        self.receipts_tree.clone().root().into()
    }

    /// Get a mutable lock on this context
    pub fn lock(&mut self) -> ReceiptsCtxMut {
        ReceiptsCtxMut::new(self)
    }

    /// Recalculates the Merkle root of the receipts from scratch. This should
    /// only be used when the list of receipts has been mutated externally.
    fn recalculate_root(&mut self) {
        self.receipts_tree = MerkleTree::new();
        for receipt in &self.receipts {
            self.receipts_tree.push(receipt.to_bytes().as_slice())
        }
    }
}

impl Index<usize> for ReceiptsCtx {
    type Output = Receipt;

    fn index(&self, index: usize) -> &Self::Output {
        &self.as_ref()[index]
    }
}

impl AsRef<Vec<Receipt>> for ReceiptsCtx {
    fn as_ref(&self) -> &Vec<Receipt> {
        &self.receipts
    }
}

impl PartialEq for ReceiptsCtx {
    fn eq(&self, other: &Self) -> bool {
        self.root() == other.root()
    }
}

impl Eq for ReceiptsCtx {}

#[cfg(any(test, feature = "test-helpers"))]
impl From<Vec<Receipt>> for ReceiptsCtx {
    fn from(receipts: Vec<Receipt>) -> Self {
        let mut ctx = Self::default();
        for receipt in receipts {
            ctx.push(receipt).expect("Too many receipts");
        }
        ctx
    }
}

impl From<ReceiptsCtx> for Vec<Receipt> {
    fn from(mut ctx: ReceiptsCtx) -> Self {
        mem::take(&mut ctx.receipts)
    }
}

/// When modifying the list of receipts directly, it is imperative that the
/// receipts tree remain in sync with the modified list. Therefore, we lock
/// mutable access to the list of receipts behind an opaque context with
/// explicit getters and automatic root calculation. As long as the mutable
/// context is in scope, access to the original context is forbidden due to
/// borrowing semantics. When the mutable context is dropped, we recalculate the
/// root and return access to the original context.
pub struct ReceiptsCtxMut<'a> {
    receipts_ctx: &'a mut ReceiptsCtx,
}

impl<'a> ReceiptsCtxMut<'a> {
    pub fn new(receipts_ctx: &'a mut ReceiptsCtx) -> Self {
        Self { receipts_ctx }
    }

    pub fn receipts_mut(&mut self) -> &mut Vec<Receipt> {
        &mut self.receipts_ctx.receipts
    }
}

impl<'a> Drop for ReceiptsCtxMut<'a> {
    fn drop(&mut self) {
        // The receipts may have been modified; recalculate the root
        self.receipts_ctx.recalculate_root()
    }
}

#[cfg(test)]
mod tests {
    use crate::{
        crypto::ephemeral_merkle_root,
        interpreter::receipts::ReceiptsCtx,
    };
    use core::iter;
    use fuel_tx::Receipt;
    use fuel_types::canonical::Serialize;

    use alloc::vec::Vec;

    fn create_receipt() -> Receipt {
        Receipt::call(
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
            Default::default(),
        )
    }

    #[test]
    fn root_returns_merkle_root_of_pushed_receipts() {
        let mut ctx = ReceiptsCtx::default();
        let receipts = iter::repeat(create_receipt()).take(5);
        for receipt in receipts.clone() {
            ctx.push(receipt).expect("context not full");
        }

        let root = ctx.root();

        let leaves = receipts
            .map(|receipt| receipt.to_bytes())
            .collect::<Vec<_>>()
            .into_iter();
        let expected_root = ephemeral_merkle_root(leaves);
        assert_eq!(root, expected_root)
    }

    #[test]
    fn root_returns_merkle_root_of_directly_modified_receipts() {
        let mut ctx = ReceiptsCtx::default();
        let receipts = iter::repeat(create_receipt()).take(5);

        {
            let mut ctx_mut = ctx.lock();
            *ctx_mut.receipts_mut() = receipts.clone().collect();
        }

        let root = ctx.root();

        let leaves = receipts
            .map(|receipt| receipt.to_bytes())
            .collect::<Vec<_>>()
            .into_iter();
        let expected_root = ephemeral_merkle_root(leaves);
        assert_eq!(root, expected_root)
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/crypto.rs

Source
use super::{
    internal::{
        clear_err,
        inc_pc,
        set_err,
    },
    memory::OwnershipRegisters,
    ExecutableTransaction,
    Interpreter,
    Memory,
    MemoryInstance,
};
use crate::{
    constraints::reg_key::*,
    error::SimpleResult,
};

use fuel_crypto::{
    Hasher,
    Message,
    PublicKey,
    Signature,
};
use fuel_types::{
    Bytes32,
    Bytes64,
    Word,
};

#[cfg(test)]
mod tests;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
{
    pub(crate) fn secp256k1_recover(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
    ) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        let (SystemRegisters { err, pc, .. }, _) = split_registers(&mut self.registers);
        secp256k1_recover(self.memory.as_mut(), owner, err, pc, a, b, c)
    }

    pub(crate) fn secp256r1_recover(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
    ) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        let (SystemRegisters { err, pc, .. }, _) = split_registers(&mut self.registers);
        secp256r1_recover(self.memory.as_mut(), owner, err, pc, a, b, c)
    }

    pub(crate) fn ed25519_verify(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
        len: Word,
    ) -> SimpleResult<()> {
        let (SystemRegisters { err, pc, .. }, _) = split_registers(&mut self.registers);
        ed25519_verify(self.memory.as_mut(), err, pc, a, b, c, len)
    }

    pub(crate) fn keccak256(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        keccak256(
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
            b,
            c,
        )
    }

    pub(crate) fn sha256(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        sha256(
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
            b,
            c,
        )
    }
}

pub(crate) fn secp256k1_recover(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    err: RegMut<ERR>,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Word,
) -> SimpleResult<()> {
    let sig = Bytes64::from(memory.read_bytes(b)?);
    let msg = Bytes32::from(memory.read_bytes(c)?);

    let signature = Signature::from_bytes_ref(&sig);
    let message = Message::from_bytes_ref(&msg);

    match signature.recover(message) {
        Ok(pub_key) => {
            memory.write_bytes(owner, a, *pub_key)?;
            clear_err(err);
        }
        Err(_) => {
            memory.write_bytes(owner, a, [0; PublicKey::LEN])?;
            set_err(err);
        }
    }

    Ok(inc_pc(pc)?)
}

pub(crate) fn secp256r1_recover(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    err: RegMut<ERR>,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Word,
) -> SimpleResult<()> {
    let sig = Bytes64::from(memory.read_bytes(b)?);
    let msg = Bytes32::from(memory.read_bytes(c)?);
    let message = Message::from_bytes_ref(&msg);

    match fuel_crypto::secp256r1::recover(&sig, message) {
        Ok(pub_key) => {
            memory.write_bytes(owner, a, *pub_key)?;
            clear_err(err);
        }
        Err(_) => {
            memory.write_bytes(owner, a, [0; PublicKey::LEN])?;
            set_err(err);
        }
    }

    Ok(inc_pc(pc)?)
}

pub(crate) fn ed25519_verify(
    memory: &mut MemoryInstance,
    err: RegMut<ERR>,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Word,
    len: Word,
) -> SimpleResult<()> {
    let pub_key = Bytes32::from(memory.read_bytes(a)?);
    let sig = Bytes64::from(memory.read_bytes(b)?);
    let msg = memory.read(c, len)?;

    if fuel_crypto::ed25519::verify(&pub_key, &sig, msg).is_ok() {
        clear_err(err);
    } else {
        set_err(err);
    }

    Ok(inc_pc(pc)?)
}

pub(crate) fn keccak256(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Word,
) -> SimpleResult<()> {
    use sha3::{
        Digest,
        Keccak256,
    };
    let mut h = Keccak256::new();
    h.update(memory.read(b, c)?);

    memory.write_bytes(owner, a, *h.finalize().as_ref())?;

    Ok(inc_pc(pc)?)
}

pub(crate) fn sha256(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Word,
) -> SimpleResult<()> {
    memory.write_bytes(owner, a, *Hasher::hash(memory.read(b, c)?))?;
    Ok(inc_pc(pc)?)
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/internal.rs

Source
use super::{
    ExecutableTransaction,
    Interpreter,
    Memory,
    MemoryInstance,
    RuntimeBalances,
};
use crate::{
    constraints::reg_key::*,
    context::Context,
    error::SimpleResult,
};

use fuel_asm::{
    Flags,
    Instruction,
    PanicReason,
};
use fuel_tx::{
    field::Outputs,
    Output,
};
use fuel_types::{
    canonical::Serialize,
    AssetId,
    BlockHeight,
    Bytes32,
    ContractId,
    Word,
};

use core::ops::Range;

#[cfg(test)]
mod message_tests;
#[cfg(test)]
mod tests;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
{
    pub(crate) fn update_memory_output(&mut self, idx: usize) -> SimpleResult<()> {
        let tx_offset = self.tx_offset();
        update_memory_output(&mut self.tx, self.memory.as_mut(), tx_offset, idx)
    }
}

/// Increase the variable output with a given asset ID. Modifies both the referenced tx
/// and the serialized tx in vm memory.
pub(crate) fn set_variable_output<Tx: ExecutableTransaction>(
    tx: &mut Tx,
    memory: &mut MemoryInstance,
    tx_offset: usize,
    idx: usize,
    variable: Output,
) -> SimpleResult<()> {
    tx.replace_variable_output(idx, variable)?;
    update_memory_output(tx, memory, tx_offset, idx)
}

fn absolute_output_offset<Tx: Outputs>(
    tx: &Tx,
    tx_offset: usize,
    idx: usize,
) -> Option<usize> {
    tx.outputs_offset_at(idx)
        .map(|offset| tx_offset.saturating_add(offset))
}

pub(crate) fn absolute_output_mem_range<Tx: Outputs>(
    tx: &Tx,
    tx_offset: usize,
    idx: usize,
) -> Option<Range<usize>> {
    let offset = absolute_output_offset(tx, tx_offset, idx)?;
    let size = tx.outputs().get(idx)?.size();
    Some(offset..offset.saturating_add(size))
}

pub(crate) fn update_memory_output<Tx: ExecutableTransaction>(
    tx: &mut Tx,
    memory: &mut MemoryInstance,
    tx_offset: usize,
    idx: usize,
) -> SimpleResult<()> {
    let range = absolute_output_mem_range(tx, tx_offset, idx)
        .ok_or(PanicReason::OutputNotFound)?;
    let mut mem = memory.write_noownerchecks(range.start, range.len())?;
    let output = tx
        .outputs_mut()
        .get_mut(idx)
        .expect("Invalid output index; checked above");
    output
        .encode(&mut mem)
        .expect("Unable to write output into given memory range");
    Ok(())
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
{
    pub(crate) fn set_flag(&mut self, a: Word) -> SimpleResult<()> {
        let (SystemRegisters { flag, pc, .. }, _) = split_registers(&mut self.registers);
        set_flag(flag, pc, a)
    }

    pub(crate) const fn context(&self) -> &Context {
        &self.context
    }

    pub(crate) const fn is_predicate(&self) -> bool {
        matches!(
            self.context,
            Context::PredicateEstimation { .. } | Context::PredicateVerification { .. }
        )
    }

    pub(crate) fn internal_contract(&self) -> Result<ContractId, PanicReason> {
        internal_contract(&self.context, self.registers.fp(), self.memory.as_ref())
    }

    pub(crate) fn get_block_height(&self) -> Result<BlockHeight, PanicReason> {
        self.context()
            .block_height()
            .ok_or(PanicReason::TransactionValidity)
    }
}

pub(crate) fn clear_err(mut err: RegMut<ERR>) {
    *err = 0;
}

pub(crate) fn set_err(mut err: RegMut<ERR>) {
    *err = 1;
}

pub(crate) fn set_flag(
    mut flag: RegMut<FLAG>,
    pc: RegMut<PC>,
    a: Word,
) -> SimpleResult<()> {
    let Some(flags) = Flags::from_bits(a) else {
        return Err(PanicReason::InvalidFlags.into())
    };

    *flag = flags.bits();

    Ok(inc_pc(pc)?)
}

pub(crate) fn inc_pc(mut pc: RegMut<PC>) -> Result<(), PanicReason> {
    pc.checked_add(Instruction::SIZE as Word)
        .ok_or(PanicReason::MemoryOverflow)
        .map(|i| *pc = i)
}

pub(crate) fn tx_id(memory: &MemoryInstance) -> Bytes32 {
    Bytes32::new(memory.read_bytes(0u64).expect("Bytes32::LEN < MEM_SIZE"))
}

/// Reduces the unspent balance of the base asset
pub(crate) fn base_asset_balance_sub(
    base_asset_id: &AssetId,
    balances: &mut RuntimeBalances,
    memory: &mut MemoryInstance,
    value: Word,
) -> SimpleResult<()> {
    external_asset_id_balance_sub(balances, memory, base_asset_id, value)
}

/// Reduces the unspent balance of a given asset ID
pub(crate) fn external_asset_id_balance_sub(
    balances: &mut RuntimeBalances,
    memory: &mut MemoryInstance,
    asset_id: &AssetId,
    value: Word,
) -> SimpleResult<()> {
    balances
        .checked_balance_sub(memory, asset_id, value)
        .ok_or(PanicReason::NotEnoughBalance)?;

    Ok(())
}

pub(crate) fn current_contract(
    context: &Context,
    fp: Reg<FP>,
    memory: &MemoryInstance,
) -> Result<Option<ContractId>, PanicReason> {
    if context.is_internal() {
        Ok(Some(ContractId::new(memory.read_bytes(*fp)?)))
    } else {
        Ok(None)
    }
}

pub(crate) fn internal_contract(
    context: &Context,
    fp: Reg<FP>,
    memory: &MemoryInstance,
) -> Result<ContractId, PanicReason> {
    current_contract(context, fp, memory)?.ok_or(PanicReason::ExpectedInternalContext)
}

pub(crate) fn set_frame_pointer(
    context: &mut Context,
    mut register: RegMut<FP>,
    fp: Word,
) {
    context.update_from_frame_pointer(fp);

    *register = fp;
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/flow.rs

Source
use crate::{
    call::{
        Call,
        CallFrame,
    },
    constraints::reg_key::*,
    consts::*,
    context::Context,
    error::{
        IoResult,
        RuntimeError,
        SimpleResult,
    },
    interpreter::{
        contract::{
            balance_decrease,
            balance_increase,
            contract_size,
        },
        gas::{
            dependent_gas_charge_without_base,
            gas_charge,
            ProfileGas,
        },
        internal::{
            current_contract,
            external_asset_id_balance_sub,
            inc_pc,
            internal_contract,
            set_frame_pointer,
        },
        receipts::ReceiptsCtx,
        ExecutableTransaction,
        InputContracts,
        Interpreter,
        Memory,
        MemoryInstance,
        PanicContext,
        RuntimeBalances,
    },
    prelude::{
        Bug,
        BugVariant,
    },
    profiler::Profiler,
    storage::{
        ContractsAssetsStorage,
        ContractsRawCode,
        InterpreterStorage,
    },
};
use alloc::vec::Vec;
use core::cmp;
use fuel_asm::{
    Instruction,
    PanicInstruction,
    RegId,
};
use fuel_storage::{
    StorageAsRef,
    StorageRead,
    StorageSize,
};
use fuel_tx::{
    DependentCost,
    PanicReason,
    Receipt,
};
use fuel_types::{
    bytes::padded_len_usize,
    canonical::Serialize,
    AssetId,
    Bytes32,
    ContractId,
    Word,
};

#[cfg(test)]
mod jump_tests;
#[cfg(test)]
mod ret_tests;
#[cfg(test)]
mod tests;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
{
    pub(crate) fn jump(&mut self, args: JumpArgs) -> SimpleResult<()> {
        let (SystemRegisters { pc, is, .. }, _) = split_registers(&mut self.registers);
        args.jump(is.as_ref(), pc)
    }

    pub(crate) fn ret(&mut self, a: Word) -> SimpleResult<()> {
        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?;
        let input = RetCtx {
            receipts: &mut self.receipts,
            frames: &mut self.frames,
            registers: &mut self.registers,
            memory: self.memory.as_ref(),
            context: &mut self.context,
            current_contract,
        };
        input.ret(a)
    }

    pub(crate) fn ret_data(&mut self, a: Word, b: Word) -> SimpleResult<Bytes32> {
        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?;
        let input = RetCtx {
            frames: &mut self.frames,
            registers: &mut self.registers,
            memory: self.memory.as_mut(),
            receipts: &mut self.receipts,
            context: &mut self.context,
            current_contract,
        };
        input.ret_data(a, b)
    }

    pub(crate) fn revert(&mut self, a: Word) -> SimpleResult<()> {
        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())
                .unwrap_or(Some(ContractId::zeroed()));
        revert(
            &mut self.receipts,
            current_contract,
            self.registers.pc(),
            self.registers.is(),
            a,
        )
    }

    pub(crate) fn append_panic_receipt(&mut self, result: PanicInstruction) {
        let pc = self.registers[RegId::PC];
        let is = self.registers[RegId::IS];

        let mut receipt =
            Receipt::panic(self.internal_contract().unwrap_or_default(), result, pc, is);

        match self.panic_context {
            PanicContext::None => {}
            PanicContext::ContractId(contract_id) => {
                receipt = receipt.with_panic_contract_id(Some(contract_id));
            }
        };
        self.panic_context = PanicContext::None;

        self.receipts
            .push(receipt)
            .expect("Appending a panic receipt cannot fail");
    }
}

struct RetCtx<'vm> {
    frames: &'vm mut Vec<CallFrame>,
    registers: &'vm mut [Word; VM_REGISTER_COUNT],
    memory: &'vm MemoryInstance,
    receipts: &'vm mut ReceiptsCtx,
    context: &'vm mut Context,
    current_contract: Option<ContractId>,
}

impl RetCtx<'_> {
    pub(crate) fn ret(self, a: Word) -> SimpleResult<()> {
        let receipt = Receipt::ret(
            self.current_contract.unwrap_or_else(ContractId::zeroed),
            a,
            self.registers[RegId::PC],
            self.registers[RegId::IS],
        );

        self.registers[RegId::RET] = a;
        self.registers[RegId::RETL] = 0;

        // TODO if ret instruction is in memory boundary, inc_pc shouldn't fail
        self.return_from_context(receipt)
    }

    pub(crate) fn return_from_context(mut self, receipt: Receipt) -> SimpleResult<()> {
        if let Some(frame) = self.frames.pop() {
            let registers = &mut self.registers;
            let context = &mut self.context;

            registers[RegId::CGAS] = registers[RegId::CGAS]
                .checked_add(frame.context_gas())
                .ok_or_else(|| Bug::new(BugVariant::ContextGasOverflow))?;

            let cgas = registers[RegId::CGAS];
            let ggas = registers[RegId::GGAS];
            let ret = registers[RegId::RET];
            let retl = registers[RegId::RETL];
            let hp = registers[RegId::HP];

            registers.copy_from_slice(frame.registers());

            registers[RegId::CGAS] = cgas;
            registers[RegId::GGAS] = ggas;
            registers[RegId::RET] = ret;
            registers[RegId::RETL] = retl;
            registers[RegId::HP] = hp;

            let fp = registers[RegId::FP];
            set_frame_pointer(context, registers.fp_mut(), fp);
        }

        self.receipts.push(receipt)?;

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

    pub(crate) fn ret_data(self, a: Word, b: Word) -> SimpleResult<Bytes32> {
        let data = self.memory.read(a, b)?.to_vec();

        let receipt = Receipt::return_data(
            self.current_contract.unwrap_or_else(ContractId::zeroed),
            a,
            self.registers[RegId::PC],
            self.registers[RegId::IS],
            data,
        );
        let digest = *receipt
            .digest()
            .expect("Receipt is created above and `digest` should exist");

        self.registers[RegId::RET] = a;
        self.registers[RegId::RETL] = b;

        self.return_from_context(receipt)?;

        Ok(digest)
    }
}

pub(crate) fn revert(
    receipts: &mut ReceiptsCtx,
    current_contract: Option<ContractId>,
    pc: Reg<PC>,
    is: Reg<IS>,
    a: Word,
) -> SimpleResult<()> {
    let receipt = Receipt::revert(
        current_contract.unwrap_or_else(ContractId::zeroed),
        a,
        *pc,
        *is,
    );

    receipts.push(receipt)
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum JumpMode {
    /// `$pc = $is + address`
    Absolute,
    /// `$pc = $pc + address`
    RelativeForwards,
    /// `$pc = $pc - address`
    RelativeBackwards,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct JumpArgs {
    /// Condition. The jump is performed only if this is true.
    condition: bool,
    /// The kind of jump performed
    mode: JumpMode,
    /// Dynamic part of the jump target, i.e. register value
    dynamic: Word,
    /// Fixed part of the jump target, i.e. immediate value
    fixed: Word,
}

impl JumpArgs {
    pub(crate) fn new(mode: JumpMode) -> Self {
        Self {
            condition: true,
            mode,
            dynamic: 0,
            fixed: 0,
        }
    }

    pub(crate) fn with_condition(mut self, condition: bool) -> Self {
        self.condition = condition;
        self
    }

    pub(crate) fn to_address(mut self, addr: Word) -> Self {
        self.dynamic = addr;
        self
    }

    pub(crate) fn plus_fixed(mut self, addr: Word) -> Self {
        self.fixed = addr;
        self
    }

    pub(crate) fn jump(&self, is: Reg<IS>, mut pc: RegMut<PC>) -> SimpleResult<()> {
        if !self.condition {
            return Ok(inc_pc(pc)?)
        }

        let offset_instructions = match self.mode {
            JumpMode::Absolute => self.dynamic.saturating_add(self.fixed),
            // Here +1 is added since jumping to the jump instruction itself doesn't make
            // sense
            JumpMode::RelativeForwards | JumpMode::RelativeBackwards => {
                self.dynamic.saturating_add(self.fixed).saturating_add(1)
            }
        };

        let offset_bytes = offset_instructions.saturating_mul(Instruction::SIZE as Word);

        let target_addr = match self.mode {
            JumpMode::Absolute => is.saturating_add(offset_bytes),
            JumpMode::RelativeForwards => pc.saturating_add(offset_bytes),
            JumpMode::RelativeBackwards => pc
                .checked_sub(offset_bytes)
                .ok_or(PanicReason::MemoryOverflow)?,
        };

        if target_addr >= VM_MAX_RAM {
            return Err(PanicReason::MemoryOverflow.into())
        }

        *pc = target_addr;
        Ok(())
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
{
    /// Prepare a call instruction for execution
    pub fn prepare_call(
        &mut self,
        ra: RegId,
        rb: RegId,
        rc: RegId,
        rd: RegId,
    ) -> IoResult<(), S::DataError> {
        self.prepare_call_inner(
            self.registers[ra],
            self.registers[rb],
            self.registers[rc],
            self.registers[rd],
        )
    }

    /// Prepare a call instruction for execution
    fn prepare_call_inner(
        &mut self,
        call_params_pointer: Word,
        amount_of_coins_to_forward: Word,
        asset_id_pointer: Word,
        amount_of_gas_to_forward: Word,
    ) -> IoResult<(), S::DataError> {
        let params = PrepareCallParams {
            call_params_pointer,
            asset_id_pointer,
            amount_of_coins_to_forward,
            amount_of_gas_to_forward,
        };
        let gas_cost = self.gas_costs().call();
        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte();
        // Charge only for the `base` execution.
        // We will charge for the frame size in the `prepare_call`.
        self.gas_charge(gas_cost.base())?;
        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?;

        PrepareCallCtx {
            params,
            registers: (&mut self.registers).into(),
            memory: self.memory.as_mut(),
            context: &mut self.context,
            gas_cost,
            runtime_balances: &mut self.balances,
            storage: &mut self.storage,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            new_storage_gas_per_byte,
            receipts: &mut self.receipts,
            frames: &mut self.frames,
            current_contract,
            profiler: &mut self.profiler,
        }
        .prepare_call()
    }
}

#[cfg_attr(test, derive(Default))]
struct PrepareCallParams {
    /// Register A of input
    pub call_params_pointer: Word,
    /// Register B of input
    pub amount_of_coins_to_forward: Word,
    /// Register C of input
    pub asset_id_pointer: Word,
    /// Register D of input
    pub amount_of_gas_to_forward: Word,
}

struct PrepareCallSystemRegisters<'a> {
    hp: Reg<'a, HP>,
    sp: RegMut<'a, SP>,
    ssp: RegMut<'a, SSP>,
    fp: RegMut<'a, FP>,
    pc: RegMut<'a, PC>,
    is: RegMut<'a, IS>,
    bal: RegMut<'a, BAL>,
    cgas: RegMut<'a, CGAS>,
    ggas: RegMut<'a, GGAS>,
    flag: RegMut<'a, FLAG>,
}

struct PrepareCallRegisters<'a> {
    system_registers: PrepareCallSystemRegisters<'a>,
    program_registers: ProgramRegistersRef<'a>,
    unused_registers: PrepareCallUnusedRegisters<'a>,
}

struct PrepareCallUnusedRegisters<'a> {
    zero: Reg<'a, ZERO>,
    one: Reg<'a, ONE>,
    of: Reg<'a, OF>,
    err: Reg<'a, ERR>,
    ret: Reg<'a, RET>,
    retl: Reg<'a, RETL>,
}

impl<'a> PrepareCallRegisters<'a> {
    fn copy_registers(&self) -> [Word; VM_REGISTER_COUNT] {
        copy_registers(&self.into(), &self.program_registers)
    }
}

struct PrepareCallCtx<'vm, S> {
    params: PrepareCallParams,
    registers: PrepareCallRegisters<'vm>,
    memory: &'vm mut MemoryInstance,
    context: &'vm mut Context,
    gas_cost: DependentCost,
    runtime_balances: &'vm mut RuntimeBalances,
    new_storage_gas_per_byte: Word,
    storage: &'vm mut S,
    input_contracts: InputContracts<'vm>,
    receipts: &'vm mut ReceiptsCtx,
    frames: &'vm mut Vec<CallFrame>,
    current_contract: Option<ContractId>,
    profiler: &'vm mut Profiler,
}

impl<'vm, S> PrepareCallCtx<'vm, S>
where
    S: InterpreterStorage,
{
    fn prepare_call(mut self) -> IoResult<(), S::DataError>
    where
        S: StorageSize<ContractsRawCode>
            + ContractsAssetsStorage
            + StorageRead<ContractsRawCode>
            + StorageAsRef,
    {
        let call_bytes = self
            .memory
            .read(self.params.call_params_pointer, Call::LEN)?;
        let call = Call::try_from(call_bytes)?;
        let asset_id =
            AssetId::new(self.memory.read_bytes(self.params.asset_id_pointer)?);

        let code_size = contract_size(&self.storage, call.to())? as usize;
        let code_size_padded =
            padded_len_usize(code_size).ok_or(PanicReason::MemoryOverflow)?;

        let total_size_in_stack = CallFrame::serialized_size()
            .checked_add(code_size_padded)
            .ok_or_else(|| Bug::new(BugVariant::CodeSizeOverflow))?;

        let profiler = ProfileGas {
            pc: self.registers.system_registers.pc.as_ref(),
            is: self.registers.system_registers.is.as_ref(),
            current_contract: self.current_contract,
            profiler: self.profiler,
        };
        dependent_gas_charge_without_base(
            self.registers.system_registers.cgas.as_mut(),
            self.registers.system_registers.ggas.as_mut(),
            profiler,
            self.gas_cost,
            code_size_padded as Word,
        )?;

        if let Some(source_contract) = self.current_contract {
            balance_decrease(
                self.storage,
                &source_contract,
                &asset_id,
                self.params.amount_of_coins_to_forward,
            )?;
        } else {
            let amount = self.params.amount_of_coins_to_forward;
            external_asset_id_balance_sub(
                self.runtime_balances,
                self.memory,
                &asset_id,
                amount,
            )?;
        }

        self.input_contracts.check(call.to())?;

        // credit contract asset_id balance
        let (_, created_new_entry) = balance_increase(
            self.storage,
            call.to(),
            &asset_id,
            self.params.amount_of_coins_to_forward,
        )?;

        if created_new_entry {
            // If a new entry was created, we must charge gas for it
            let profiler = ProfileGas {
                pc: self.registers.system_registers.pc.as_ref(),
                is: self.registers.system_registers.is.as_ref(),
                current_contract: self.current_contract,
                profiler: self.profiler,
            };
            gas_charge(
                self.registers.system_registers.cgas.as_mut(),
                self.registers.system_registers.ggas.as_mut(),
                profiler,
                ((Bytes32::LEN + WORD_SIZE) as u64)
                    .saturating_mul(self.new_storage_gas_per_byte),
            )?;
        }

        let forward_gas_amount = cmp::min(
            *self.registers.system_registers.cgas,
            self.params.amount_of_gas_to_forward,
        );

        // subtract gas
        *self.registers.system_registers.cgas = (*self.registers.system_registers.cgas)
            .checked_sub(forward_gas_amount)
            .ok_or_else(|| Bug::new(BugVariant::ContextGasUnderflow))?;

        // Construct frame
        let mut frame = CallFrame::new(
            *call.to(),
            asset_id,
            self.registers.copy_registers(),
            code_size_padded,
            call.a(),
            call.b(),
        )
        .ok_or(PanicReason::MemoryOverflow)?;
        *frame.context_gas_mut() = *self.registers.system_registers.cgas;
        *frame.global_gas_mut() = *self.registers.system_registers.ggas;

        // Allocate stack memory
        let old_sp = *self.registers.system_registers.sp;
        let new_sp = old_sp.saturating_add(total_size_in_stack as Word);
        self.memory.grow_stack(new_sp)?;
        *self.registers.system_registers.sp = new_sp;
        *self.registers.system_registers.ssp = new_sp;

        let id = internal_contract(
            self.context,
            self.registers.system_registers.fp.as_ref(),
            self.memory,
        )
        .unwrap_or_default();

        set_frame_pointer(
            self.context,
            self.registers.system_registers.fp.as_mut(),
            old_sp,
        );

        // Write the frame to memory
        // Ownership checks are disabled because we just allocated the memory above.
        let dst = self.memory.write_noownerchecks(
            *self.registers.system_registers.fp,
            total_size_in_stack,
        )?;
        let (mem_frame, mem_code) = dst.split_at_mut(CallFrame::serialized_size());
        mem_frame.copy_from_slice(&frame.to_bytes());
        let (mem_code, mem_code_padding) = mem_code.split_at_mut(code_size);
        read_contract(call.to(), self.storage, mem_code)?;
        mem_code_padding.fill(0);

        #[allow(clippy::arithmetic_side_effects)] // Checked above
        let code_start =
            (*self.registers.system_registers.fp) + CallFrame::serialized_size() as Word;

        *self.registers.system_registers.pc = code_start;
        *self.registers.system_registers.bal = self.params.amount_of_coins_to_forward;
        *self.registers.system_registers.is = *self.registers.system_registers.pc;
        *self.registers.system_registers.cgas = forward_gas_amount;
        *self.registers.system_registers.flag = 0;

        let receipt = Receipt::call(
            id,
            *call.to(),
            self.params.amount_of_coins_to_forward,
            asset_id,
            forward_gas_amount,
            call.a(),
            call.b(),
            *self.registers.system_registers.pc,
            *self.registers.system_registers.is,
        );

        self.receipts.push(receipt)?;

        self.frames.push(frame);

        Ok(())
    }
}

fn read_contract<S>(
    contract: &ContractId,
    storage: &S,
    dst: &mut [u8],
) -> IoResult<(), S::Error>
where
    S: StorageSize<ContractsRawCode> + StorageRead<ContractsRawCode> + StorageAsRef,
{
    let bytes_read = storage
        .storage::<ContractsRawCode>()
        .read(contract, dst)
        .map_err(RuntimeError::Storage)?
        .ok_or(PanicReason::ContractNotFound)?;
    if bytes_read != dst.len() {
        return Err(PanicReason::ContractMismatch.into())
    }
    Ok(())
}

impl<'a> From<&'a PrepareCallRegisters<'_>> for SystemRegistersRef<'a> {
    fn from(registers: &'a PrepareCallRegisters) -> Self {
        Self {
            hp: registers.system_registers.hp,
            sp: registers.system_registers.sp.as_ref(),
            ssp: registers.system_registers.ssp.as_ref(),
            fp: registers.system_registers.fp.as_ref(),
            pc: registers.system_registers.pc.as_ref(),
            is: registers.system_registers.is.as_ref(),
            bal: registers.system_registers.bal.as_ref(),
            cgas: registers.system_registers.cgas.as_ref(),
            ggas: registers.system_registers.ggas.as_ref(),
            flag: registers.system_registers.flag.as_ref(),
            zero: registers.unused_registers.zero,
            one: registers.unused_registers.one,
            of: registers.unused_registers.of,
            err: registers.unused_registers.err,
            ret: registers.unused_registers.ret,
            retl: registers.unused_registers.retl,
        }
    }
}

impl<'reg> From<&'reg mut [Word; VM_REGISTER_COUNT]> for PrepareCallRegisters<'reg> {
    fn from(registers: &'reg mut [Word; VM_REGISTER_COUNT]) -> Self {
        let (r, w) = split_registers(registers);
        let (r, u) = r.into();
        Self {
            system_registers: r,
            program_registers: w.into(),
            unused_registers: u,
        }
    }
}

impl<'reg> From<SystemRegisters<'reg>>
    for (
        PrepareCallSystemRegisters<'reg>,
        PrepareCallUnusedRegisters<'reg>,
    )
{
    fn from(registers: SystemRegisters<'reg>) -> Self {
        let read = PrepareCallSystemRegisters {
            hp: registers.hp.into(),
            sp: registers.sp,
            ssp: registers.ssp,
            fp: registers.fp,
            pc: registers.pc,
            is: registers.is,
            bal: registers.bal,
            cgas: registers.cgas,
            ggas: registers.ggas,
            flag: registers.flag,
        };

        (
            read,
            PrepareCallUnusedRegisters {
                zero: registers.zero.into(),
                one: registers.one.into(),
                of: registers.of.into(),
                err: registers.err.into(),
                ret: registers.ret.into(),
                retl: registers.retl.into(),
            },
        )
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/metadata.rs

Source
use super::{
    internal::inc_pc,
    ExecutableTransaction,
    Interpreter,
    Memory,
};
use crate::{
    call::CallFrame,
    constraints::reg_key::*,
    consts::*,
    context::Context,
    convert,
    error::SimpleResult,
};

use fuel_asm::{
    GMArgs,
    GTFArgs,
    PanicReason,
    RegId,
};
use fuel_tx::{
    field::{
        BytecodeWitnessIndex,
        Salt,
        Script as ScriptField,
        ScriptData,
        ScriptGasLimit,
        StorageSlots,
    },
    policies::PolicyType,
    Input,
    InputRepr,
    Output,
    OutputRepr,
    UtxoId,
};
use fuel_types::{
    ChainId,
    Immediate12,
    Immediate18,
    RegisterId,
    Word,
};

#[cfg(test)]
mod tests;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
{
    pub(crate) fn metadata(
        &mut self,
        ra: RegisterId,
        imm: Immediate18,
    ) -> SimpleResult<()> {
        let tx_offset = self.tx_offset() as Word;
        let chain_id = self.chain_id();
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        metadata(
            &self.context,
            &self.frames,
            pc,
            result,
            imm,
            chain_id,
            tx_offset,
        )
    }

    pub(crate) fn get_transaction_field(
        &mut self,
        ra: RegisterId,
        b: Word,
        imm: Immediate12,
    ) -> SimpleResult<()> {
        let tx_offset = self.tx_offset();
        // Tx size is stored just below the tx bytes
        let tx_size_ptr = tx_offset.checked_sub(8).expect("Tx offset is not valid");
        let tx_size = Word::from_be_bytes(
            self.memory()
                .read_bytes(tx_size_ptr)
                .expect("Tx length not in memory"),
        );
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        let input = GTFInput {
            tx: &self.tx,
            input_contracts_index_to_output_index: &self
                .input_contracts_index_to_output_index,
            tx_offset,
            tx_size,
            pc,
        };
        input.get_transaction_field(result, b, imm)
    }
}

pub(crate) fn metadata(
    context: &Context,
    frames: &[CallFrame],
    pc: RegMut<PC>,
    result: &mut Word,
    imm: Immediate18,
    chain_id: ChainId,
    tx_offset: Word,
) -> SimpleResult<()> {
    let parent = context
        .is_internal()
        .then(|| frames.last().map(|f| f.registers()[RegId::FP]))
        .flatten();

    *result = match GMArgs::try_from(imm)? {
        GMArgs::GetVerifyingPredicate => context
            .predicate()
            .map(|p| p.idx() as Word)
            .ok_or(PanicReason::TransactionValidity)?,
        GMArgs::GetChainId => chain_id.into(),
        GMArgs::BaseAssetId => VM_MEMORY_BASE_ASSET_ID_OFFSET as Word,
        GMArgs::TxStart => tx_offset,
        GMArgs::GetCaller => match parent {
            Some(0) => return Err(PanicReason::ExpectedNestedCaller.into()),
            Some(parent) => parent,
            None => return Err(PanicReason::ExpectedInternalContext.into()),
        },
        GMArgs::IsCallerExternal => match parent {
            Some(p) => (p == 0) as Word,
            None => return Err(PanicReason::ExpectedInternalContext.into()),
        },
    };

    inc_pc(pc)?;
    Ok(())
}

struct GTFInput<'vm, Tx> {
    tx: &'vm Tx,
    input_contracts_index_to_output_index: &'vm alloc::collections::BTreeMap<u16, u16>,
    tx_offset: usize,
    tx_size: Word,
    pc: RegMut<'vm, PC>,
}

impl<Tx> GTFInput<'_, Tx> {
    pub(crate) fn get_transaction_field(
        self,
        result: &mut Word,
        b: Word,
        imm: Immediate12,
    ) -> SimpleResult<()>
    where
        Tx: ExecutableTransaction,
    {
        let b = convert::to_usize(b).ok_or(PanicReason::InvalidMetadataIdentifier)?;
        let args = GTFArgs::try_from(imm)?;
        let tx = self.tx;
        let input_contract_to_output_index = self.input_contracts_index_to_output_index;
        let ofs = self.tx_offset;

        // We use saturating_add with tx offset below.
        // In case any addition overflows, this function returns value
        // for the field that's above VM_MAX_RAM.

        let a = match args {
            GTFArgs::Type => Tx::transaction_type(),

            // General
            GTFArgs::ScriptGasLimit => tx
                .as_script()
                .map(|script| *script.script_gas_limit())
                .unwrap_or_default(),
            GTFArgs::PolicyTypes => tx.policies().bits() as Word,
            GTFArgs::PolicyTip => tx
                .policies()
                .get(PolicyType::Tip)
                .ok_or(PanicReason::PolicyIsNotSet)?,
            GTFArgs::PolicyWitnessLimit => tx
                .policies()
                .get(PolicyType::WitnessLimit)
                .ok_or(PanicReason::PolicyIsNotSet)?,
            GTFArgs::PolicyMaturity => tx
                .policies()
                .get(PolicyType::Maturity)
                .ok_or(PanicReason::PolicyIsNotSet)?,
            GTFArgs::PolicyMaxFee => tx
                .policies()
                .get(PolicyType::MaxFee)
                .ok_or(PanicReason::PolicyIsNotSet)?,
            GTFArgs::ScriptInputsCount | GTFArgs::CreateInputsCount => {
                tx.inputs().len() as Word
            }
            GTFArgs::ScriptOutputsCount | GTFArgs::CreateOutputsCount => {
                tx.outputs().len() as Word
            }
            GTFArgs::ScriptWitnessesCount | GTFArgs::CreateWitnessesCount => {
                tx.witnesses().len() as Word
            }
            GTFArgs::ScriptInputAtIndex | GTFArgs::CreateInputAtIndex => ofs
                .saturating_add(tx.inputs_offset_at(b).ok_or(PanicReason::InputNotFound)?)
                as Word,
            GTFArgs::ScriptOutputAtIndex | GTFArgs::CreateOutputAtIndex => {
                ofs.saturating_add(
                    tx.outputs_offset_at(b).ok_or(PanicReason::OutputNotFound)?,
                ) as Word
            }
            GTFArgs::ScriptWitnessAtIndex | GTFArgs::CreateWitnessAtIndex => {
                ofs.saturating_add(
                    tx.witnesses_offset_at(b)
                        .ok_or(PanicReason::WitnessNotFound)?,
                ) as Word
            }
            GTFArgs::TxLength => self.tx_size,

            // Input
            GTFArgs::InputType => {
                tx.inputs()
                    .get(b)
                    .map(InputRepr::from)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputCoinTxId => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .map(Input::repr)
                    .and_then(|r| r.utxo_id_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputCoinOutputIndex => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::utxo_id)
                    .map(UtxoId::output_index)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputCoinOwner => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .map(Input::repr)
                    .and_then(|r| r.owner_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputCoinAmount => tx
                .inputs()
                .get(b)
                .filter(|i| i.is_coin())
                .and_then(Input::amount)
                .ok_or(PanicReason::InputNotFound)?,
            GTFArgs::InputCoinAssetId => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .map(Input::repr)
                    .and_then(|r| r.asset_id_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputCoinTxPointer => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .map(Input::repr)
                    .and_then(|r| r.tx_pointer_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputCoinWitnessIndex => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::witness_index)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputCoinPredicateLength => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::predicate_len)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputCoinPredicateDataLength => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::predicate_data_len)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputCoinPredicateGasUsed => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::predicate_gas_used)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputCoinPredicate => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::predicate_offset)
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputCoinPredicateData => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_coin())
                    .and_then(Input::predicate_data_offset)
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputContractTxId => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_contract())
                    .map(Input::repr)
                    .and_then(|r| r.utxo_id_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputContractOutputIndex => {
                let b = u16::try_from(b)
                    .map_err(|_| PanicReason::InvalidMetadataIdentifier)?;
                input_contract_to_output_index
                    .get(&b)
                    .copied()
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputContractId => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_contract())
                    .map(Input::repr)
                    .and_then(|r| r.contract_id_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputMessageSender => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .map(Input::repr)
                    .and_then(|r| r.message_sender_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputMessageRecipient => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .map(Input::repr)
                    .and_then(|r| r.message_recipient_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputMessageAmount => tx
                .inputs()
                .get(b)
                .filter(|i| i.is_message())
                .and_then(Input::amount)
                .ok_or(PanicReason::InputNotFound)?,
            GTFArgs::InputMessageNonce => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .map(Input::repr)
                    .and_then(|r| r.message_nonce_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputMessageWitnessIndex => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::witness_index)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputMessageDataLength => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::input_data_len)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputMessagePredicateLength => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::predicate_len)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputMessagePredicateDataLength => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::predicate_data_len)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputMessagePredicateGasUsed => {
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::predicate_gas_used)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::InputMessageData => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .map(Input::repr)
                    .and_then(|r| r.data_offset())
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputMessagePredicate => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::predicate_offset)
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,
            GTFArgs::InputMessagePredicateData => ofs.saturating_add(
                tx.inputs()
                    .get(b)
                    .filter(|i| i.is_message())
                    .and_then(Input::predicate_data_offset)
                    .and_then(|ofs| tx.inputs_offset_at(b).map(|o| o.saturating_add(ofs)))
                    .ok_or(PanicReason::InputNotFound)?,
            ) as Word,

            // Output
            GTFArgs::OutputType => {
                tx.outputs()
                    .get(b)
                    .map(OutputRepr::from)
                    .ok_or(PanicReason::OutputNotFound)? as Word
            }
            GTFArgs::OutputCoinTo => ofs.saturating_add(
                tx.outputs()
                    .get(b)
                    .filter(|o| o.is_coin() || o.is_change())
                    .map(Output::repr)
                    .and_then(|r| r.to_offset())
                    .and_then(|ofs| {
                        tx.outputs_offset_at(b).map(|o| o.saturating_add(ofs))
                    })
                    .ok_or(PanicReason::OutputNotFound)?,
            ) as Word,
            GTFArgs::OutputCoinAmount => tx
                .outputs()
                .get(b)
                .filter(|o| o.is_coin())
                .and_then(Output::amount)
                .ok_or(PanicReason::OutputNotFound)?,
            GTFArgs::OutputCoinAssetId => ofs.saturating_add(
                tx.outputs()
                    .get(b)
                    .filter(|o| o.is_coin() || o.is_change())
                    .map(Output::repr)
                    .and_then(|r| r.asset_id_offset())
                    .and_then(|ofs| {
                        tx.outputs_offset_at(b).map(|o| o.saturating_add(ofs))
                    })
                    .ok_or(PanicReason::OutputNotFound)?,
            ) as Word,
            GTFArgs::OutputContractInputIndex => {
                tx.outputs()
                    .get(b)
                    .filter(|o| o.is_contract())
                    .and_then(Output::input_index)
                    .ok_or(PanicReason::InputNotFound)? as Word
            }
            GTFArgs::OutputContractCreatedContractId => ofs.saturating_add(
                tx.outputs()
                    .get(b)
                    .filter(|o| o.is_contract_created())
                    .map(Output::repr)
                    .and_then(|r| r.contract_id_offset())
                    .and_then(|ofs| {
                        tx.outputs_offset_at(b).map(|o| o.saturating_add(ofs))
                    })
                    .ok_or(PanicReason::OutputNotFound)?,
            ) as Word,
            GTFArgs::OutputContractCreatedStateRoot => ofs.saturating_add(
                tx.outputs()
                    .get(b)
                    .filter(|o| o.is_contract_created())
                    .map(Output::repr)
                    .and_then(|r| r.contract_created_state_root_offset())
                    .and_then(|ofs| {
                        tx.outputs_offset_at(b).map(|o| o.saturating_add(ofs))
                    })
                    .ok_or(PanicReason::OutputNotFound)?,
            ) as Word,

            // Witness
            GTFArgs::WitnessDataLength => {
                tx.witnesses()
                    .get(b)
                    .map(|w| w.as_ref().len())
                    .ok_or(PanicReason::WitnessNotFound)? as Word
            }
            GTFArgs::WitnessData => {
                tx.witnesses_offset_at(b)
                    .map(|w| ofs.saturating_add(w).saturating_add(WORD_SIZE))
                    .ok_or(PanicReason::WitnessNotFound)? as Word
            }

            // If it is not any above commands, it is something specific to the
            // transaction type.
            specific_args => {
                let as_script = tx.as_script();
                let as_create = tx.as_create();
                match (as_script, as_create, specific_args) {
                    // Script
                    (Some(script), None, GTFArgs::ScriptLength) => {
                        script.script().len() as Word
                    }
                    (Some(script), None, GTFArgs::ScriptDataLength) => {
                        script.script_data().len() as Word
                    }
                    (Some(script), None, GTFArgs::Script) => {
                        ofs.saturating_add(script.script_offset()) as Word
                    }
                    (Some(script), None, GTFArgs::ScriptData) => {
                        ofs.saturating_add(script.script_data_offset()) as Word
                    }

                    // Create
                    (None, Some(create), GTFArgs::CreateBytecodeWitnessIndex) => {
                        *create.bytecode_witness_index() as Word
                    }
                    (None, Some(create), GTFArgs::CreateStorageSlotsCount) => {
                        create.storage_slots().len() as Word
                    }
                    (None, Some(create), GTFArgs::CreateSalt) => {
                        ofs.saturating_add(create.salt_offset()) as Word
                    }
                    (None, Some(create), GTFArgs::CreateStorageSlotAtIndex) => {
                        // TODO: Maybe we need to return panic error
                        // `StorageSlotsNotFound`?
                        (ofs.saturating_add(
                            create.storage_slots_offset_at(b).unwrap_or_default(),
                        )) as Word
                    }
                    _ => return Err(PanicReason::InvalidMetadataIdentifier.into()),
                }
            }
        };

        *result = a;

        inc_pc(self.pc)?;
        Ok(())
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/alu.rs

Source
use super::{
    internal::inc_pc,
    is_unsafe_math,
    is_wrapping,
    ExecutableTransaction,
    Interpreter,
};
use crate::{
    constraints::reg_key::*,
    error::SimpleResult,
};

use fuel_asm::PanicReason;
use fuel_types::{
    RegisterId,
    Word,
};

mod muldiv;
mod wideint;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
{
    /// Stores the overflowed wrapped value into RegId::OF
    pub(crate) fn alu_capture_overflow<F, B, C>(
        &mut self,
        ra: RegisterId,
        f: F,
        b: B,
        c: C,
    ) -> SimpleResult<()>
    where
        F: FnOnce(B, C) -> (u128, bool),
    {
        let (
            SystemRegisters {
                flag, of, err, pc, ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let dest = &mut w[ra.try_into()?];
        let common = AluCommonReg { of, err, pc };
        alu_capture_overflow(dest, flag.as_ref(), common, f, b, c)
    }

    /// Set RegId::OF to true and zero the result register if overflow occurred.
    pub(crate) fn alu_boolean_overflow<F, B, C>(
        &mut self,
        ra: RegisterId,
        f: F,
        b: B,
        c: C,
    ) -> SimpleResult<()>
    where
        F: FnOnce(B, C) -> (Word, bool),
    {
        let (
            SystemRegisters {
                flag, of, err, pc, ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let dest = &mut w[ra.try_into()?];
        let common = AluCommonReg { of, err, pc };
        alu_boolean_overflow(dest, flag.as_ref(), common, f, b, c)
    }

    pub(crate) fn alu_error<F, B, C>(
        &mut self,
        ra: RegisterId,
        f: F,
        b: B,
        c: C,
        err_bool: bool,
    ) -> SimpleResult<()>
    where
        F: FnOnce(B, C) -> Word,
    {
        let (
            SystemRegisters {
                flag, of, err, pc, ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let dest = &mut w[ra.try_into()?];
        let common = AluCommonReg { of, err, pc };
        alu_error(dest, flag.as_ref(), common, f, b, c, err_bool)
    }

    pub(crate) fn alu_set(&mut self, ra: RegisterId, b: Word) -> SimpleResult<()> {
        let (SystemRegisters { of, err, pc, .. }, mut w) =
            split_registers(&mut self.registers);
        let dest = &mut w[ra.try_into()?];
        let common = AluCommonReg { of, err, pc };
        alu_set(dest, common, b)
    }

    pub(crate) fn alu_clear(&mut self) -> SimpleResult<()> {
        let (SystemRegisters { of, err, pc, .. }, _) =
            split_registers(&mut self.registers);
        let common = AluCommonReg { of, err, pc };
        alu_clear(common)
    }
}

pub(crate) fn exp(b: Word, c: Word) -> (Word, bool) {
    if let Ok(expo) = u32::try_from(c) {
        Word::overflowing_pow(b, expo)
    } else if b < 2 {
        (b, false)
    } else {
        (0, true)
    }
}

pub(crate) struct AluCommonReg<'a> {
    pub of: RegMut<'a, OF>,
    pub err: RegMut<'a, ERR>,
    pub pc: RegMut<'a, PC>,
}

/// Stores the overflowed wrapped value into RegId::OF
pub(crate) fn alu_capture_overflow<F, B, C>(
    dest: &mut Word,
    flag: Reg<FLAG>,
    mut common: AluCommonReg,
    f: F,
    b: B,
    c: C,
) -> SimpleResult<()>
where
    F: FnOnce(B, C) -> (u128, bool),
{
    let (result, _overflow) = f(b, c);

    if result > Word::MAX as u128 && !is_wrapping(flag) {
        return Err(PanicReason::ArithmeticOverflow.into())
    }

    // set the OF register to high bits of the u128 result
    *common.of = (result >> 64) as u64;
    *common.err = 0;

    // set the return value to the low bits of the u128 result
    *dest = u64::try_from(result & Word::MAX as u128)
        .expect("We already truncated the result");

    Ok(inc_pc(common.pc)?)
}

/// Set RegId::OF to true and zero the result register if overflow occurred.
pub(crate) fn alu_boolean_overflow<F, B, C>(
    dest: &mut Word,
    flag: Reg<FLAG>,
    mut common: AluCommonReg,
    f: F,
    b: B,
    c: C,
) -> SimpleResult<()>
where
    F: FnOnce(B, C) -> (Word, bool),
{
    let (result, overflow) = f(b, c);

    if overflow && !is_wrapping(flag) {
        return Err(PanicReason::ArithmeticOverflow.into())
    }

    // set the OF register to 1 if an overflow occurred
    *common.of = overflow as Word;
    *common.err = 0;

    *dest = if overflow { 0 } else { result };

    Ok(inc_pc(common.pc)?)
}

pub(crate) fn alu_error<F, B, C>(
    dest: &mut Word,
    flag: Reg<FLAG>,
    mut common: AluCommonReg,
    f: F,
    b: B,
    c: C,
    err_bool: bool,
) -> SimpleResult<()>
where
    F: FnOnce(B, C) -> Word,
{
    if err_bool && !is_unsafe_math(flag) {
        return Err(PanicReason::ArithmeticError.into())
    }

    *common.of = 0;
    *common.err = err_bool as Word;

    *dest = if err_bool { 0 } else { f(b, c) };

    Ok(inc_pc(common.pc)?)
}

pub(crate) fn alu_set(
    dest: &mut Word,
    mut common: AluCommonReg,
    b: Word,
) -> SimpleResult<()> {
    *common.of = 0;
    *common.err = 0;

    *dest = b;

    Ok(inc_pc(common.pc)?)
}

pub(crate) fn alu_clear(mut common: AluCommonReg) -> SimpleResult<()> {
    *common.of = 0;
    *common.err = 0;

    Ok(inc_pc(common.pc)?)
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/blockchain.rs

Source
use crate::{
    call::CallFrame,
    constraints::reg_key::*,
    consts::*,
    context::Context,
    convert,
    error::{
        IoResult,
        RuntimeError,
        SimpleResult,
    },
    interpreter::{
        contract::{
            balance,
            balance_decrease,
            contract_size,
        },
        gas::{
            dependent_gas_charge_without_base,
            gas_charge,
            ProfileGas,
        },
        internal::{
            base_asset_balance_sub,
            current_contract,
            inc_pc,
            internal_contract,
            tx_id,
        },
        memory::{
            copy_from_slice_zero_fill,
            OwnershipRegisters,
        },
        receipts::ReceiptsCtx,
        ExecutableTransaction,
        InputContracts,
        Interpreter,
        Memory,
        MemoryInstance,
        RuntimeBalances,
    },
    prelude::Profiler,
    storage::{
        BlobData,
        ContractsAssetsStorage,
        ContractsRawCode,
        ContractsStateData,
        InterpreterStorage,
    },
};
use alloc::vec::Vec;
use fuel_asm::{
    Imm06,
    PanicReason,
};
use fuel_storage::{
    StorageInspect,
    StorageSize,
};
use fuel_tx::{
    consts::BALANCE_ENTRY_SIZE,
    BlobId,
    ContractIdExt,
    DependentCost,
    Receipt,
};
use fuel_types::{
    bytes::{
        self,
        padded_len_word,
    },
    Address,
    AssetId,
    BlockHeight,
    Bytes32,
    ContractId,
    RegisterId,
    Word,
};

#[cfg(test)]
mod code_tests;
#[cfg(test)]
mod croo_tests;
#[cfg(test)]
mod other_tests;
#[cfg(test)]
mod smo_tests;
#[cfg(test)]
mod test;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    /// Loads contract ID pointed by `contract_id_addr`, and then for that contract,
    /// copies `length_unpadded` bytes from it starting from offset `contract_offset` into
    /// the stack.
    ///
    /// ```txt
    /// contract_id = mem[$rA, 32]
    /// contract_code = contracts[contract_id]
    /// mem[$ssp, $rC] = contract_code[$rB, $rC]
    /// ```
    pub(crate) fn load_contract_code(
        &mut self,
        addr: Word,
        offset: Word,
        length_unpadded: Word,
        mode: Imm06,
    ) -> IoResult<(), S::DataError> {
        let gas_cost = self.gas_costs().ldc();
        // Charge only for the `base` execution.
        // We will charge for the contracts size in the `load_contract_code`.
        self.gas_charge(gas_cost.base())?;
        let contract_max_size = self.contract_max_size();
        let (
            SystemRegisters {
                cgas,
                ggas,
                ssp,
                sp,
                hp,
                fp,
                pc,
                is,
                ..
            },
            _,
        ) = split_registers(&mut self.registers);
        let input = LoadContractCodeCtx {
            memory: self.memory.as_mut(),
            context: &self.context,
            profiler: &mut self.profiler,
            storage: &mut self.storage,
            contract_max_size,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            gas_cost,
            cgas,
            ggas,
            ssp,
            sp,
            hp: hp.as_ref(),
            fp: fp.as_ref(),
            pc,
            is: is.as_ref(),
        };

        match mode.to_u8() {
            0 => input.load_contract_code(addr, offset, length_unpadded),
            1 => input.load_blob_code(addr, offset, length_unpadded),
            2 => input.load_memory_code(addr, offset, length_unpadded),
            _ => Err(PanicReason::InvalidImmediateValue.into()),
        }
    }

    pub(crate) fn burn(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
        let (SystemRegisters { fp, pc, is, .. }, _) =
            split_registers(&mut self.registers);
        BurnCtx {
            storage: &mut self.storage,
            context: &self.context,
            memory: self.memory.as_ref(),
            receipts: &mut self.receipts,
            fp: fp.as_ref(),
            pc,
            is: is.as_ref(),
        }
        .burn(a, b)
    }

    pub(crate) fn mint(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte();
        let (
            SystemRegisters {
                cgas,
                ggas,
                fp,
                pc,
                is,
                ..
            },
            _,
        ) = split_registers(&mut self.registers);
        MintCtx {
            storage: &mut self.storage,
            context: &self.context,
            memory: self.memory.as_ref(),
            receipts: &mut self.receipts,
            profiler: &mut self.profiler,
            new_storage_gas_per_byte,
            cgas,
            ggas,
            fp: fp.as_ref(),
            pc,
            is: is.as_ref(),
        }
        .mint(a, b)
    }

    pub(crate) fn code_copy(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
        d: Word,
    ) -> IoResult<(), S::DataError> {
        let gas_cost = self.gas_costs().ccp();
        // Charge only for the `base` execution.
        // We will charge for the contract's size in the `code_copy`.
        self.gas_charge(gas_cost.base())?;

        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?;
        let owner = self.ownership_registers();
        let (
            SystemRegisters {
                cgas, ggas, pc, is, ..
            },
            _,
        ) = split_registers(&mut self.registers);
        let input = CodeCopyCtx {
            memory: self.memory.as_mut(),
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            storage: &mut self.storage,
            profiler: &mut self.profiler,
            current_contract,
            owner,
            gas_cost,
            cgas,
            ggas,
            pc,
            is: is.as_ref(),
        };
        input.code_copy(a, b, c, d)
    }

    pub(crate) fn block_hash(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
        let owner = self.ownership_registers();
        block_hash(
            &self.storage,
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
            b,
        )
    }

    pub(crate) fn block_height(&mut self, ra: RegisterId) -> IoResult<(), S::DataError> {
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        Ok(block_height(&self.context, pc, result)?)
    }

    pub(crate) fn block_proposer(&mut self, a: Word) -> IoResult<(), S::DataError> {
        let owner = self.ownership_registers();
        coinbase(
            &self.storage,
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
        )
    }

    pub(crate) fn code_root(&mut self, a: Word, b: Word) -> IoResult<(), S::DataError> {
        let gas_cost = self.gas_costs().croo();
        self.gas_charge(gas_cost.base())?;
        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?;
        let owner = self.ownership_registers();
        let (
            SystemRegisters {
                cgas, ggas, pc, is, ..
            },
            _,
        ) = split_registers(&mut self.registers);
        CodeRootCtx {
            memory: self.memory.as_mut(),
            storage: &mut self.storage,
            gas_cost,
            profiler: &mut self.profiler,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            current_contract,
            cgas,
            ggas,
            owner,
            pc,
            is: is.as_ref(),
        }
        .code_root(a, b)
    }

    pub(crate) fn code_size(
        &mut self,
        ra: RegisterId,
        b: Word,
    ) -> IoResult<(), S::DataError> {
        let gas_cost = self.gas_costs().csiz();
        // Charge only for the `base` execution.
        // We will charge for the contracts size in the `code_size`.
        self.gas_charge(gas_cost.base())?;
        let current_contract =
            current_contract(&self.context, self.registers.fp(), self.memory.as_ref())?;
        let (
            SystemRegisters {
                cgas, ggas, pc, is, ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        let input = CodeSizeCtx {
            memory: self.memory.as_mut(),
            storage: &mut self.storage,
            gas_cost,
            profiler: &mut self.profiler,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            current_contract,
            cgas,
            ggas,
            pc,
            is: is.as_ref(),
        };
        input.code_size(result, b)
    }

    pub(crate) fn state_clear_qword(
        &mut self,
        a: Word,
        rb: RegisterId,
        c: Word,
    ) -> IoResult<(), S::DataError> {
        let contract_id = self.internal_contract();
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(rb)?];

        let input = StateClearQWord::new(a, c)?;
        let Self {
            ref mut storage,
            ref memory,
            ..
        } = self;

        state_clear_qword(&contract_id?, storage, memory.as_ref(), pc, result, input)
    }

    pub(crate) fn state_read_word(
        &mut self,
        ra: RegisterId,
        rb: RegisterId,
        c: Word,
    ) -> IoResult<(), S::DataError> {
        let (SystemRegisters { fp, pc, .. }, mut w) =
            split_registers(&mut self.registers);
        let (result, got_result) = w
            .get_mut_two(WriteRegKey::try_from(ra)?, WriteRegKey::try_from(rb)?)
            .ok_or(RuntimeError::Recoverable(
                PanicReason::ReservedRegisterNotWritable,
            ))?;
        let Self {
            ref mut storage,
            ref memory,
            ref context,
            ..
        } = self;
        state_read_word(
            StateReadWordCtx {
                storage,
                memory: memory.as_ref(),
                context,
                fp: fp.as_ref(),
                pc,
            },
            result,
            got_result,
            c,
        )
    }

    pub(crate) fn state_read_qword(
        &mut self,
        a: Word,
        rb: RegisterId,
        c: Word,
        d: Word,
    ) -> IoResult<(), S::DataError> {
        let owner = self.ownership_registers();
        let (SystemRegisters { pc, fp, .. }, mut w) =
            split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(rb)?];

        let Self {
            ref storage,
            ref context,
            ref mut memory,
            ..
        } = self;

        state_read_qword(
            storage,
            context,
            memory.as_mut(),
            pc,
            fp.as_ref(),
            owner,
            result,
            StateReadQWordParams {
                destination_pointer: a,
                origin_key_pointer: c,
                num_slots: d,
            },
        )
    }

    pub(crate) fn state_write_word(
        &mut self,
        a: Word,
        rb: RegisterId,
        c: Word,
    ) -> IoResult<(), S::DataError> {
        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte();
        let (
            SystemRegisters {
                cgas,
                ggas,
                is,
                fp,
                pc,
                ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let exists = &mut w[WriteRegKey::try_from(rb)?];
        let Self {
            ref mut storage,
            ref memory,
            ref context,
            ..
        } = self;
        state_write_word(
            StateWriteWordCtx {
                storage,
                memory: memory.as_ref(),
                context,
                profiler: &mut self.profiler,
                new_storage_gas_per_byte,
                current_contract: self.frames.last().map(|frame| frame.to()).copied(),
                cgas,
                ggas,
                is: is.as_ref(),
                fp: fp.as_ref(),
                pc,
            },
            a,
            exists,
            c,
        )
    }

    pub(crate) fn state_write_qword(
        &mut self,
        a: Word,
        rb: RegisterId,
        c: Word,
        d: Word,
    ) -> IoResult<(), S::DataError> {
        let new_storage_per_byte = self.gas_costs().new_storage_per_byte();
        let contract_id = self.internal_contract();
        let (
            SystemRegisters {
                is, cgas, ggas, pc, ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(rb)?];

        let input = StateWriteQWord {
            starting_storage_key_pointer: a,
            source_pointer: c,
            num_slots: d,
        };

        let Self {
            ref mut storage,
            ref mut memory,
            ..
        } = self;

        state_write_qword(
            &contract_id?,
            storage,
            memory.as_ref(),
            &mut self.profiler,
            new_storage_per_byte,
            self.frames.last().map(|frame| frame.to()).copied(),
            cgas,
            ggas,
            is.as_ref(),
            pc,
            result,
            input,
        )
    }

    pub(crate) fn timestamp(
        &mut self,
        ra: RegisterId,
        b: Word,
    ) -> IoResult<(), S::DataError> {
        let block_height = self.get_block_height()?;
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        timestamp(&self.storage, block_height, pc, result, b)
    }

    pub(crate) fn message_output(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
        d: Word,
    ) -> IoResult<(), S::DataError> {
        let base_asset_id = self.interpreter_params.base_asset_id;
        let max_message_data_length = self.max_message_data_length();
        let (SystemRegisters { fp, pc, .. }, _) = split_registers(&mut self.registers);
        let input = MessageOutputCtx {
            base_asset_id,
            max_message_data_length,
            memory: self.memory.as_mut(),
            receipts: &mut self.receipts,
            balances: &mut self.balances,
            storage: &mut self.storage,
            current_contract: self.frames.last().map(|frame| frame.to()).copied(),
            fp: fp.as_ref(),
            pc,
            recipient_mem_address: a,
            msg_data_ptr: b,
            msg_data_len: c,
            amount_coins_to_send: d,
        };
        input.message_output()
    }
}

struct LoadContractCodeCtx<'vm, S> {
    contract_max_size: u64,
    memory: &'vm mut MemoryInstance,
    context: &'vm Context,
    profiler: &'vm mut Profiler,
    input_contracts: InputContracts<'vm>,
    storage: &'vm S,
    gas_cost: DependentCost,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    ssp: RegMut<'vm, SSP>,
    sp: RegMut<'vm, SP>,
    hp: Reg<'vm, HP>,
    fp: Reg<'vm, FP>,
    pc: RegMut<'vm, PC>,
    is: Reg<'vm, IS>,
}

impl<'vm, S> LoadContractCodeCtx<'vm, S>
where
    S: InterpreterStorage,
{
    /// Loads contract ID pointed by `a`, and then for that contract,
    /// copies `c` bytes from it starting from offset `b` into the stack.
    /// ```txt
    /// contract_id = mem[$rA, 32]
    /// contract_code = contracts[contract_id]
    /// mem[$ssp, $rC] = contract_code[$rB, $rC]
    /// ```
    pub(crate) fn load_contract_code(
        mut self,
        contract_id_addr: Word,
        contract_offset: Word,
        length_unpadded: Word,
    ) -> IoResult<(), S::DataError>
    where
        S: InterpreterStorage,
    {
        let ssp = *self.ssp;
        let sp = *self.sp;
        let region_start = ssp;

        // only blobs are allowed in predicates
        if self.context.is_predicate() {
            return Err(PanicReason::ContractInstructionNotAllowed.into())
        }

        if ssp != sp {
            return Err(PanicReason::ExpectedUnallocatedStack.into())
        }

        let contract_id = ContractId::from(self.memory.read_bytes(contract_id_addr)?);
        let current_contract = current_contract(self.context, self.fp, self.memory)?;

        let length =
            padded_len_word(length_unpadded).ok_or(PanicReason::MemoryOverflow)?;

        if length > self.contract_max_size {
            return Err(PanicReason::ContractMaxSize.into())
        }

        self.input_contracts.check(&contract_id)?;

        // Fetch the storage contract
        let profiler = ProfileGas {
            pc: self.pc.as_ref(),
            is: self.is,
            current_contract,
            profiler: self.profiler,
        };
        let contract_len = contract_size(&self.storage, &contract_id)?;
        let charge_len = core::cmp::max(contract_len as u64, length);
        dependent_gas_charge_without_base(
            self.cgas,
            self.ggas,
            profiler,
            self.gas_cost,
            charge_len,
        )?;
        let contract = super::contract::contract(self.storage, &contract_id)?;
        let contract_bytes = contract.as_ref().as_ref();

        let new_sp = ssp.saturating_add(length);
        self.memory.grow_stack(new_sp)?;

        // Set up ownership registers for the copy using old ssp
        let owner =
            OwnershipRegisters::only_allow_stack_write(new_sp, *self.ssp, *self.hp);

        // Mark stack space as allocated
        *self.sp = new_sp;
        *self.ssp = new_sp;

        // Copy the code.
        copy_from_slice_zero_fill(
            self.memory,
            owner,
            contract_bytes,
            region_start,
            contract_offset,
            length,
        )?;

        // Update frame code size, if we have a stack frame (i.e. fp > 0)
        if self.context.is_internal() {
            let code_size_ptr =
                (*self.fp).saturating_add(CallFrame::code_size_offset() as Word);
            let old_code_size =
                Word::from_be_bytes(self.memory.read_bytes(code_size_ptr)?);
            let old_code_size =
                padded_len_word(old_code_size).ok_or(PanicReason::MemoryOverflow)?;
            let new_code_size = old_code_size
                .checked_add(length as Word)
                .ok_or(PanicReason::MemoryOverflow)?;

            self.memory
                .write_bytes_noownerchecks(code_size_ptr, new_code_size.to_be_bytes())?;
        }

        inc_pc(self.pc)?;

        Ok(())
    }

    /// Loads blob ID pointed by `a`, and then for that blob,
    /// copies `c` bytes from it starting from offset `b` into the stack.
    /// ```txt
    /// blob_id = mem[$rA, 32]
    /// blob_code = blobs[blob_id]
    /// mem[$ssp, $rC] = blob_code[$rB, $rC]
    /// ```
    pub(crate) fn load_blob_code(
        mut self,
        blob_id_addr: Word,
        blob_offset: Word,
        length_unpadded: Word,
    ) -> IoResult<(), S::DataError>
    where
        S: InterpreterStorage,
    {
        let ssp = *self.ssp;
        let sp = *self.sp;
        let region_start = ssp;

        if ssp != sp {
            return Err(PanicReason::ExpectedUnallocatedStack.into())
        }

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

        let current_contract = current_contract(self.context, self.fp, self.memory)?;

        let length = bytes::padded_len_word(length_unpadded).unwrap_or(Word::MAX);

        let blob_len =
            <S as StorageSize<BlobData>>::size_of_value(self.storage, &blob_id)
                .map_err(RuntimeError::Storage)?
                .ok_or(PanicReason::BlobNotFound)?;

        // Fetch the storage blob
        let profiler = ProfileGas {
            pc: self.pc.as_ref(),
            is: self.is,
            current_contract,
            profiler: self.profiler,
        };
        let charge_len = core::cmp::max(blob_len as u64, length);
        dependent_gas_charge_without_base(
            self.cgas,
            self.ggas,
            profiler,
            self.gas_cost,
            charge_len,
        )?;
        let blob = <S as StorageInspect<BlobData>>::get(self.storage, &blob_id)
            .map_err(RuntimeError::Storage)?
            .ok_or(PanicReason::BlobNotFound)?;
        let blob_bytes = blob.as_ref().as_ref();

        let new_sp = ssp.saturating_add(length);
        self.memory.grow_stack(new_sp)?;

        // Set up ownership registers for the copy using old ssp
        let owner =
            OwnershipRegisters::only_allow_stack_write(new_sp, *self.ssp, *self.hp);

        // Mark stack space as allocated
        *self.sp = new_sp;
        *self.ssp = new_sp;

        // Copy the code.
        copy_from_slice_zero_fill(
            self.memory,
            owner,
            blob_bytes,
            region_start,
            blob_offset,
            length,
        )?;

        // Update frame code size, if we have a stack frame (i.e. fp > 0)
        if self.context.is_internal() {
            let code_size_ptr =
                (*self.fp).saturating_add(CallFrame::code_size_offset() as Word);
            let old_code_size =
                Word::from_be_bytes(self.memory.read_bytes(code_size_ptr)?);
            let old_code_size = padded_len_word(old_code_size)
                .expect("Code size cannot overflow with padding");
            let new_code_size = old_code_size
                .checked_add(length as Word)
                .ok_or(PanicReason::MemoryOverflow)?;

            self.memory
                .write_bytes_noownerchecks(code_size_ptr, new_code_size.to_be_bytes())?;
        }

        inc_pc(self.pc)?;

        Ok(())
    }

    /// Copies `c` bytes from starting the memory `a` and offset `b` into the
    /// stack.
    ///
    /// ```txt
    /// mem[$ssp, $rC] = memory[$rA + $rB, $rC]
    /// ```
    pub(crate) fn load_memory_code(
        mut self,
        input_src_addr: Word,
        input_offset: Word,
        length_unpadded: Word,
    ) -> IoResult<(), S::DataError>
    where
        S: InterpreterStorage,
    {
        let ssp = *self.ssp;
        let sp = *self.sp;
        let dst = ssp;

        if ssp != sp {
            return Err(PanicReason::ExpectedUnallocatedStack.into())
        }

        if length_unpadded == 0 {
            inc_pc(self.pc)?;
            return Ok(())
        }

        let current_contract = current_contract(self.context, self.fp, self.memory)?;

        let length = bytes::padded_len_word(length_unpadded).unwrap_or(Word::MAX);

        // Fetch the storage blob
        let profiler = ProfileGas {
            pc: self.pc.as_ref(),
            is: self.is,
            current_contract,
            profiler: self.profiler,
        };
        let charge_len = length;
        dependent_gas_charge_without_base(
            self.cgas,
            self.ggas,
            profiler,
            self.gas_cost,
            charge_len,
        )?;

        let new_sp = ssp.saturating_add(length);
        self.memory.grow_stack(new_sp)?;

        // Set up ownership registers for the copy using old ssp
        let owner = OwnershipRegisters::only_allow_stack_write(new_sp, ssp, *self.hp);
        let src = input_src_addr.saturating_add(input_offset);

        // Copy the code.
        self.memory.memcopy(dst, src, length, owner)?;

        // Mark stack space as allocated
        *self.sp = new_sp;
        *self.ssp = new_sp;

        // Update frame code size, if we have a stack frame (i.e. fp > 0)
        if self.context.is_internal() {
            let code_size_ptr =
                (*self.fp).saturating_add(CallFrame::code_size_offset() as Word);
            let old_code_size =
                Word::from_be_bytes(self.memory.read_bytes(code_size_ptr)?);
            let old_code_size = padded_len_word(old_code_size)
                .expect("Code size cannot overflow with padding");
            let new_code_size = old_code_size
                .checked_add(length as Word)
                .ok_or(PanicReason::MemoryOverflow)?;

            self.memory
                .write_bytes_noownerchecks(code_size_ptr, new_code_size.to_be_bytes())?;
        }

        inc_pc(self.pc)?;

        Ok(())
    }
}

struct BurnCtx<'vm, S> {
    storage: &'vm mut S,
    context: &'vm Context,
    memory: &'vm MemoryInstance,
    receipts: &'vm mut ReceiptsCtx,
    fp: Reg<'vm, FP>,
    pc: RegMut<'vm, PC>,
    is: Reg<'vm, IS>,
}

impl<'vm, S> BurnCtx<'vm, S>
where
    S: ContractsAssetsStorage,
{
    pub(crate) fn burn(self, a: Word, b: Word) -> IoResult<(), S::Error> {
        let contract_id = internal_contract(self.context, self.fp, self.memory)?;
        let sub_id = Bytes32::new(self.memory.read_bytes(b)?);
        let asset_id = contract_id.asset_id(&sub_id);

        let balance = balance(self.storage, &contract_id, &asset_id)?;
        let balance = balance
            .checked_sub(a)
            .ok_or(PanicReason::NotEnoughBalance)?;

        self.storage
            .contract_asset_id_balance_insert(&contract_id, &asset_id, balance)
            .map_err(RuntimeError::Storage)?;

        let receipt = Receipt::burn(sub_id, contract_id, a, *self.pc, *self.is);

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }
}

struct MintCtx<'vm, S> {
    storage: &'vm mut S,
    context: &'vm Context,
    memory: &'vm MemoryInstance,
    profiler: &'vm mut Profiler,
    receipts: &'vm mut ReceiptsCtx,
    new_storage_gas_per_byte: Word,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    fp: Reg<'vm, FP>,
    pc: RegMut<'vm, PC>,
    is: Reg<'vm, IS>,
}

impl<'vm, S> MintCtx<'vm, S>
where
    S: ContractsAssetsStorage,
{
    pub(crate) fn mint(self, a: Word, b: Word) -> Result<(), RuntimeError<S::Error>> {
        let contract_id = internal_contract(self.context, self.fp, self.memory)?;
        let sub_id = Bytes32::new(self.memory.read_bytes(b)?);
        let asset_id = contract_id.asset_id(&sub_id);

        let balance = balance(self.storage, &contract_id, &asset_id)?;
        let balance = balance.checked_add(a).ok_or(PanicReason::BalanceOverflow)?;

        let old_value = self
            .storage
            .contract_asset_id_balance_replace(&contract_id, &asset_id, balance)
            .map_err(RuntimeError::Storage)?;

        if old_value.is_none() {
            // New data was written, charge gas for it
            let profiler = ProfileGas {
                pc: self.pc.as_ref(),
                is: self.is,
                current_contract: Some(contract_id),
                profiler: self.profiler,
            };
            gas_charge(
                self.cgas,
                self.ggas,
                profiler,
                (BALANCE_ENTRY_SIZE as u64).saturating_mul(self.new_storage_gas_per_byte),
            )?;
        }

        let receipt = Receipt::mint(sub_id, contract_id, a, *self.pc, *self.is);

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }
}

struct CodeCopyCtx<'vm, S> {
    memory: &'vm mut MemoryInstance,
    input_contracts: InputContracts<'vm>,
    storage: &'vm S,
    profiler: &'vm mut Profiler,
    current_contract: Option<ContractId>,
    owner: OwnershipRegisters,
    gas_cost: DependentCost,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    pc: RegMut<'vm, PC>,
    is: Reg<'vm, IS>,
}

impl<'vm, S> CodeCopyCtx<'vm, S>
where
    S: InterpreterStorage,
{
    pub(crate) fn code_copy(
        mut self,
        dst_addr: Word,
        contract_id_addr: Word,
        contract_offset: Word,
        length: Word,
    ) -> IoResult<(), S::DataError>
    where
        S: InterpreterStorage,
    {
        let contract_id = ContractId::from(self.memory.read_bytes(contract_id_addr)?);

        self.memory.write(self.owner, dst_addr, length)?;
        self.input_contracts.check(&contract_id)?;

        let contract = super::contract::contract(self.storage, &contract_id)?;
        let contract_bytes = contract.as_ref().as_ref();
        let contract_len = contract_bytes.len();
        let charge_len = core::cmp::max(contract_len as u64, length);
        let profiler = ProfileGas {
            pc: self.pc.as_ref(),
            is: self.is,
            current_contract: self.current_contract,
            profiler: self.profiler,
        };
        dependent_gas_charge_without_base(
            self.cgas,
            self.ggas,
            profiler,
            self.gas_cost,
            charge_len,
        )?;

        // Owner checks already performed above
        copy_from_slice_zero_fill(
            self.memory,
            self.owner,
            contract.as_ref().as_ref(),
            dst_addr,
            contract_offset,
            length,
        )?;

        Ok(inc_pc(self.pc)?)
    }
}

pub(crate) fn block_hash<S: InterpreterStorage>(
    storage: &S,
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
) -> IoResult<(), S::DataError> {
    let height = u32::try_from(b)
        .map_err(|_| PanicReason::InvalidBlockHeight)?
        .into();
    let hash = storage.block_hash(height).map_err(RuntimeError::Storage)?;

    memory.write_bytes(owner, a, *hash)?;

    inc_pc(pc)?;
    Ok(())
}

pub(crate) fn block_height(
    context: &Context,
    pc: RegMut<PC>,
    result: &mut Word,
) -> SimpleResult<()> {
    context
        .block_height()
        .map(|h| *h as Word)
        .map(|h| *result = h)
        .ok_or(PanicReason::TransactionValidity)?;

    inc_pc(pc)?;
    Ok(())
}

pub(crate) fn coinbase<S: InterpreterStorage>(
    storage: &S,
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
) -> IoResult<(), S::DataError> {
    let coinbase = storage.coinbase().map_err(RuntimeError::Storage)?;
    memory.write_bytes(owner, a, *coinbase)?;
    inc_pc(pc)?;
    Ok(())
}

struct CodeRootCtx<'vm, S> {
    storage: &'vm S,
    memory: &'vm mut MemoryInstance,
    gas_cost: DependentCost,
    profiler: &'vm mut Profiler,
    input_contracts: InputContracts<'vm>,
    current_contract: Option<ContractId>,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    owner: OwnershipRegisters,
    pc: RegMut<'vm, PC>,
    is: Reg<'vm, IS>,
}

impl<'vm, S> CodeRootCtx<'vm, S> {
    pub(crate) fn code_root(mut self, a: Word, b: Word) -> IoResult<(), S::DataError>
    where
        S: InterpreterStorage,
    {
        self.memory.write_noownerchecks(a, Bytes32::LEN)?;

        let contract_id = ContractId::new(self.memory.read_bytes(b)?);

        self.input_contracts.check(&contract_id)?;

        let len = contract_size(self.storage, &contract_id)?;
        let profiler = ProfileGas {
            pc: self.pc.as_ref(),
            is: self.is,
            current_contract: self.current_contract,
            profiler: self.profiler,
        };
        dependent_gas_charge_without_base(
            self.cgas,
            self.ggas,
            profiler,
            self.gas_cost,
            len as u64,
        )?;
        let root = self
            .storage
            .storage_contract(&contract_id)
            .transpose()
            .ok_or(PanicReason::ContractNotFound)?
            .map_err(RuntimeError::Storage)?
            .root();

        self.memory.write_bytes(self.owner, a, *root)?;

        Ok(inc_pc(self.pc)?)
    }
}

struct CodeSizeCtx<'vm, S> {
    storage: &'vm S,
    memory: &'vm mut MemoryInstance,
    gas_cost: DependentCost,
    profiler: &'vm mut Profiler,
    input_contracts: InputContracts<'vm>,
    current_contract: Option<ContractId>,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    pc: RegMut<'vm, PC>,
    is: Reg<'vm, IS>,
}

impl<'vm, S> CodeSizeCtx<'vm, S> {
    pub(crate) fn code_size(
        mut self,
        result: &mut Word,
        b: Word,
    ) -> Result<(), RuntimeError<S::Error>>
    where
        S: StorageSize<ContractsRawCode>,
    {
        let contract_id = ContractId::new(self.memory.read_bytes(b)?);

        self.input_contracts.check(&contract_id)?;

        let len = contract_size(self.storage, &contract_id)?;
        let profiler = ProfileGas {
            pc: self.pc.as_ref(),
            is: self.is,
            current_contract: self.current_contract,
            profiler: self.profiler,
        };
        dependent_gas_charge_without_base(
            self.cgas,
            self.ggas,
            profiler,
            self.gas_cost,
            len as u64,
        )?;
        *result = len as u64;

        Ok(inc_pc(self.pc)?)
    }
}

pub(crate) struct StateReadWordCtx<'vm, S> {
    pub storage: &'vm mut S,
    pub memory: &'vm MemoryInstance,
    pub context: &'vm Context,
    pub fp: Reg<'vm, FP>,
    pub pc: RegMut<'vm, PC>,
}

pub(crate) fn state_read_word<S: InterpreterStorage>(
    StateReadWordCtx {
        storage,
        memory,
        context,
        fp,
        pc,
        ..
    }: StateReadWordCtx<S>,
    result: &mut Word,
    got_result: &mut Word,
    c: Word,
) -> IoResult<(), S::DataError> {
    let key = Bytes32::new(memory.read_bytes(c)?);
    let contract = internal_contract(context, fp, memory)?;

    let value = storage
        .contract_state(&contract, &key)
        .map_err(RuntimeError::Storage)?
        .map(|bytes| {
            Word::from_be_bytes(
                bytes.as_ref().as_ref()[..8]
                    .try_into()
                    .expect("8 bytes can be converted to a Word"),
            )
        });

    *result = value.unwrap_or(0);
    *got_result = value.is_some() as Word;

    Ok(inc_pc(pc)?)
}

pub(crate) struct StateWriteWordCtx<'vm, S> {
    pub storage: &'vm mut S,
    pub memory: &'vm MemoryInstance,
    pub context: &'vm Context,
    pub profiler: &'vm mut Profiler,
    pub new_storage_gas_per_byte: Word,
    pub current_contract: Option<ContractId>,
    pub cgas: RegMut<'vm, CGAS>,
    pub ggas: RegMut<'vm, GGAS>,
    pub is: Reg<'vm, IS>,
    pub fp: Reg<'vm, FP>,
    pub pc: RegMut<'vm, PC>,
}

pub(crate) fn state_write_word<S: InterpreterStorage>(
    StateWriteWordCtx {
        storage,
        memory,
        context,
        profiler,
        new_storage_gas_per_byte,
        current_contract,
        cgas,
        ggas,
        is,
        fp,
        pc,
    }: StateWriteWordCtx<S>,
    a: Word,
    created_new: &mut Word,
    c: Word,
) -> IoResult<(), S::DataError> {
    let key = Bytes32::new(memory.read_bytes(a)?);
    let contract = internal_contract(context, fp, memory)?;

    let mut value = Bytes32::zeroed();
    value.as_mut()[..WORD_SIZE].copy_from_slice(&c.to_be_bytes());

    let prev = storage
        .contract_state_replace(&contract, &key, value.as_ref())
        .map_err(RuntimeError::Storage)?;

    *created_new = prev.is_none() as Word;

    if prev.is_none() {
        // New data was written, charge gas for it
        let profiler = ProfileGas {
            pc: pc.as_ref(),
            is,
            current_contract,
            profiler,
        };
        gas_charge(
            cgas,
            ggas,
            profiler,
            (Bytes32::LEN as u64)
                .saturating_mul(2)
                .saturating_mul(new_storage_gas_per_byte),
        )?;
    }

    Ok(inc_pc(pc)?)
}

pub(crate) fn timestamp<S: InterpreterStorage>(
    storage: &S,
    block_height: BlockHeight,
    pc: RegMut<PC>,
    result: &mut Word,
    b: Word,
) -> IoResult<(), S::DataError> {
    let b = u32::try_from(b)
        .map_err(|_| PanicReason::InvalidBlockHeight)?
        .into();
    (b <= block_height)
        .then_some(())
        .ok_or(PanicReason::TransactionValidity)?;

    *result = storage.timestamp(b).map_err(RuntimeError::Storage)?;

    Ok(inc_pc(pc)?)
}
struct MessageOutputCtx<'vm, S>
where
    S: ContractsAssetsStorage + ?Sized,
{
    base_asset_id: AssetId,
    max_message_data_length: u64,
    memory: &'vm mut MemoryInstance,
    receipts: &'vm mut ReceiptsCtx,
    balances: &'vm mut RuntimeBalances,
    storage: &'vm mut S,
    current_contract: Option<ContractId>,
    fp: Reg<'vm, FP>,
    pc: RegMut<'vm, PC>,
    /// A
    recipient_mem_address: Word,
    /// B
    msg_data_ptr: Word,
    /// C
    msg_data_len: Word,
    /// D
    amount_coins_to_send: Word,
}

impl<S> MessageOutputCtx<'_, S>
where
    S: ContractsAssetsStorage + ?Sized,
{
    pub(crate) fn message_output(self) -> Result<(), RuntimeError<S::Error>> {
        if self.msg_data_len > self.max_message_data_length {
            return Err(RuntimeError::Recoverable(PanicReason::MessageDataTooLong));
        }

        let msg_data = self
            .memory
            .read(self.msg_data_ptr, self.msg_data_len)?
            .to_vec();
        let recipient = Address::new(self.memory.read_bytes(self.recipient_mem_address)?);
        let sender = Address::new(self.memory.read_bytes(*self.fp)?);

        // validations passed, perform the mutations

        if let Some(source_contract) = self.current_contract {
            balance_decrease(
                self.storage,
                &source_contract,
                &self.base_asset_id,
                self.amount_coins_to_send,
            )?;
        } else {
            base_asset_balance_sub(
                &self.base_asset_id,
                self.balances,
                self.memory,
                self.amount_coins_to_send,
            )?;
        }

        let txid = tx_id(self.memory);
        let receipt = Receipt::message_out(
            &txid,
            self.receipts.len() as Word,
            sender,
            recipient,
            self.amount_coins_to_send,
            msg_data,
        );

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }
}

struct StateReadQWordParams {
    destination_pointer: Word,
    origin_key_pointer: Word,
    num_slots: Word,
}

#[allow(clippy::too_many_arguments)]
fn state_read_qword<S: InterpreterStorage>(
    storage: &S,
    context: &Context,
    memory: &mut MemoryInstance,
    pc: RegMut<PC>,
    fp: Reg<FP>,
    ownership_registers: OwnershipRegisters,
    result_register: &mut Word,
    params: StateReadQWordParams,
) -> IoResult<(), S::DataError> {
    let StateReadQWordParams {
        destination_pointer,
        origin_key_pointer,
        num_slots,
    } = params;

    let contract_id = internal_contract(context, fp, memory)?;
    let num_slots = convert::to_usize(num_slots).ok_or(PanicReason::TooManySlots)?;
    let slots_len = Bytes32::LEN.saturating_mul(num_slots);
    let origin_key = Bytes32::new(memory.read_bytes(origin_key_pointer)?);
    let dst = memory.write(ownership_registers, destination_pointer, slots_len)?;

    let mut all_set = true;
    let result: Vec<u8> = storage
        .contract_state_range(&contract_id, &origin_key, num_slots)
        .map_err(RuntimeError::Storage)?
        .into_iter()
        .flat_map(|bytes| match bytes {
            Some(bytes) => bytes.into_owned(),
            None => {
                all_set = false;
                ContractsStateData::from(Bytes32::zeroed().as_ref())
            }
        })
        .collect();

    *result_register = all_set as Word;

    dst.copy_from_slice(&result);

    inc_pc(pc)?;

    Ok(())
}

struct StateWriteQWord {
    /// The starting storage key location is stored in this range of memory.
    starting_storage_key_pointer: Word,
    /// The source data memory address is stored in this range of memory.
    source_pointer: Word,
    /// How many slots to write.
    num_slots: Word,
}

#[allow(clippy::too_many_arguments)]
fn state_write_qword<'vm, S: InterpreterStorage>(
    contract_id: &ContractId,
    storage: &mut S,
    memory: &MemoryInstance,
    profiler: &'vm mut Profiler,
    new_storage_gas_per_byte: Word,
    current_contract: Option<ContractId>,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    is: Reg<'vm, IS>,
    pc: RegMut<PC>,
    result_register: &mut Word,
    input: StateWriteQWord,
) -> IoResult<(), S::DataError> {
    let destination_key =
        Bytes32::new(memory.read_bytes(input.starting_storage_key_pointer)?);

    let values = memory
        .read(
            input.source_pointer,
            (Bytes32::LEN as Word).saturating_mul(input.num_slots),
        )?
        .chunks_exact(Bytes32::LEN);

    let unset_count = storage
        .contract_state_insert_range(contract_id, &destination_key, values)
        .map_err(RuntimeError::Storage)?;
    *result_register = unset_count as Word;

    if unset_count > 0 {
        // New data was written, charge gas for it
        let profiler = ProfileGas {
            pc: pc.as_ref(),
            is,
            current_contract,
            profiler,
        };
        gas_charge(
            cgas,
            ggas,
            profiler,
            (unset_count as u64)
                .saturating_mul(2)
                .saturating_mul(Bytes32::LEN as u64)
                .saturating_mul(new_storage_gas_per_byte),
        )?;
    }

    inc_pc(pc)?;

    Ok(())
}

struct StateClearQWord {
    /// The starting storage key location is stored in this address.
    start_storage_key_pointer: Word,
    /// Number of slots to read.
    num_slots: usize,
}

impl StateClearQWord {
    fn new(start_storage_key_pointer: Word, num_slots: Word) -> SimpleResult<Self> {
        let num_slots = convert::to_usize(num_slots).ok_or(PanicReason::TooManySlots)?;
        Ok(Self {
            start_storage_key_pointer,
            num_slots,
        })
    }
}

fn state_clear_qword<S: InterpreterStorage>(
    contract_id: &ContractId,
    storage: &mut S,
    memory: &MemoryInstance,
    pc: RegMut<PC>,
    result_register: &mut Word,
    input: StateClearQWord,
) -> IoResult<(), S::DataError> {
    let start_key = Bytes32::new(memory.read_bytes(input.start_storage_key_pointer)?);

    let all_previously_set = storage
        .contract_state_remove_range(contract_id, &start_key, input.num_slots)
        .map_err(RuntimeError::Storage)?
        .is_some();

    *result_register = all_previously_set as Word;

    inc_pc(pc)?;

    Ok(())
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/debug.rs

Source
use super::Interpreter;
use crate::prelude::*;
use fuel_asm::RegId;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
{
    /// Get single-stepping mode
    pub const fn single_stepping(&self) -> bool {
        self.debugger.single_stepping()
    }

    /// Set single-stepping mode
    pub fn set_single_stepping(&mut self, single_stepping: bool) {
        self.debugger.set_single_stepping(single_stepping)
    }

    /// Clear all set breakpoints.
    pub fn clear_breakpoints(&mut self) {
        self.debugger.clear_breakpoints();
    }

    /// Set a new breakpoint for the provided location.
    pub fn set_breakpoint(&mut self, breakpoint: Breakpoint) {
        self.debugger.set_breakpoint(breakpoint)
    }

    /// Overwrite all breakpoints with a new set of breakpoints.
    pub fn overwrite_breakpoints(&mut self, breakpoints: &[Breakpoint]) {
        self.debugger.clear_breakpoints();
        for bp in breakpoints {
            self.debugger.set_breakpoint(*bp);
        }
    }

    /// Remove a previously set breakpoint.
    pub fn remove_breakpoint(&mut self, breakpoint: &Breakpoint) {
        self.debugger.remove_breakpoint(breakpoint)
    }

    pub(crate) fn eval_debugger_state(&mut self) -> DebugEval {
        let debugger = &mut self.debugger;

        let contract = self.frames.last().map(CallFrame::to);
        let pc = self.registers[RegId::PC].saturating_sub(self.registers[RegId::IS]);

        debugger.eval_state(contract, pc)
    }

    pub(crate) fn debugger_set_last_state(&mut self, state: ProgramState) {
        self.debugger.set_last_state(state)
    }

    pub(crate) const fn debugger_last_state(&self) -> &Option<ProgramState> {
        self.debugger.last_state()
    }
}

#[cfg(test)]
mod tests {
    use alloc::{
        vec,
        vec::Vec,
    };

    use super::Interpreter;
    use crate::prelude::*;
    use fuel_asm::RegId;

    #[test]
    fn breakpoint_script() {
        use fuel_asm::op;
        use fuel_tx::ConsensusParameters;

        let mut vm = Interpreter::<_, _, _>::with_memory_storage();

        let gas_limit = 1_000_000;
        let gas_price = 0;
        let height = Default::default();

        let script = [
            op::addi(0x10, RegId::ZERO, 8),
            op::addi(0x11, RegId::ZERO, 16),
            op::addi(0x12, RegId::ZERO, 32),
            op::addi(0x13, RegId::ZERO, 64),
            op::addi(0x14, RegId::ZERO, 128),
            op::ret(0x10),
        ]
        .into_iter()
        .collect();

        let consensus_params = ConsensusParameters::standard();

        let tx = TransactionBuilder::script(script, vec![])
            .script_gas_limit(gas_limit)
            .add_fee_input()
            .finalize()
            .into_checked(height, &consensus_params)
            .expect("failed to generate checked tx")
            .into_ready(
                gas_price,
                consensus_params.gas_costs(),
                consensus_params.fee_params(),
            )
            .unwrap();

        let suite = vec![
            (
                Breakpoint::script(0),
                vec![(0x10, 0), (0x11, 0), (0x12, 0), (0x13, 0), (0x14, 0)],
            ),
            (
                Breakpoint::script(2),
                vec![(0x10, 8), (0x11, 16), (0x12, 0), (0x13, 0), (0x14, 0)],
            ),
            (
                Breakpoint::script(3),
                vec![(0x10, 8), (0x11, 16), (0x12, 32), (0x13, 0), (0x14, 0)],
            ),
            (
                Breakpoint::script(5),
                vec![(0x10, 8), (0x11, 16), (0x12, 32), (0x13, 64), (0x14, 128)],
            ),
        ];

        suite.iter().for_each(|(b, _)| vm.set_breakpoint(*b));

        let state = vm
            .transact(tx)
            .map(ProgramState::from)
            .expect("Failed to execute script!");

        suite
            .into_iter()
            .fold(state, |state, (breakpoint, registers)| {
                let debug = state.debug_ref().expect("Expected breakpoint");
                let b = debug
                    .breakpoint()
                    .expect("State without expected breakpoint");

                assert_eq!(&breakpoint, b);
                registers.into_iter().for_each(|(r, w)| {
                    assert_eq!(w, vm.registers()[r]);
                });

                vm.resume().expect("Failed to resume")
            });
    }

    #[test]
    fn single_stepping() {
        use fuel_asm::op;
        use fuel_tx::ConsensusParameters;

        let mut vm = Interpreter::<_, _, _>::with_memory_storage();

        let gas_limit = 1_000_000;
        let height = Default::default();
        let gas_price = 0;

        // Repeats the middle two instructions five times
        let script = [
            op::addi(0x10, RegId::ZERO, 5),
            op::addi(0x11, 0x11, 1),
            op::jnei(0x10, 0x11, 1),
            op::ret(0x10),
        ]
        .into_iter()
        .collect();

        let consensus_params = ConsensusParameters::standard();

        let tx = TransactionBuilder::script(script, vec![])
            .script_gas_limit(gas_limit)
            .add_fee_input()
            .finalize()
            .into_checked(height, &consensus_params)
            .expect("failed to generate checked tx")
            .into_ready(
                gas_price,
                consensus_params.gas_costs(),
                consensus_params.fee_params(),
            )
            .unwrap();

        vm.set_single_stepping(true);

        let mut state = vm
            .transact(tx)
            .map(ProgramState::from)
            .expect("Failed to execute script!");

        let mut stops = Vec::new();

        while let Some(debug) = state.debug_ref() {
            let b = debug
                .breakpoint()
                .expect("State without expected breakpoint");

            stops.push(b.pc());

            state = vm.resume().expect("Failed to resume");
        }

        assert_eq!(stops, vec![0, 4, 8, 4, 8, 4, 8, 4, 8, 4, 8, 12]);
    }

    #[test]
    fn resume_without_debug() {
        use fuel_asm::op;
        use fuel_tx::ConsensusParameters;

        let mut vm = Interpreter::<_, _, _>::with_memory_storage();
        vm.resume()
            .expect_err("Expected error when resuming without debug");

        let gas_limit = 1_000_000;
        let height = Default::default();
        let gas_price = 0;

        // Just returns
        let script: Vec<u8> = [op::ret(0x10)].into_iter().collect();

        let consensus_params = ConsensusParameters::standard();

        let tx = TransactionBuilder::script(script, vec![])
            .script_gas_limit(gas_limit)
            .add_fee_input()
            .finalize()
            .into_checked(height, &consensus_params)
            .expect("failed to generate checked tx")
            .into_ready(
                gas_price,
                consensus_params.gas_costs(),
                consensus_params.fee_params(),
            )
            .unwrap();

        let _ = vm
            .transact(tx)
            .map(ProgramState::from)
            .expect("Failed to execute script!");

        vm.resume()
            .expect_err("Expected error when resuming without debug");
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/gas.rs

Source
use super::Interpreter;
use crate::{
    constraints::reg_key::*,
    error::SimpleResult,
    prelude::{
        Bug,
        BugVariant,
    },
    profiler::Profiler,
};

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

#[cfg(test)]
mod tests;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal> {
    /// Global remaining gas amount
    pub fn remaining_gas(&self) -> Word {
        self.registers[RegId::GGAS]
    }

    /// Sets the amount of gas available for execution to both CGAS and GGAS.
    /// Only useful in contexts where CGAS and GGAS are the same,
    /// i.e. predicates and testing.
    pub(crate) fn set_gas(&mut self, gas: Word) {
        self.registers[RegId::GGAS] = gas;
        self.registers[RegId::CGAS] = gas;
    }

    pub(crate) fn dependent_gas_charge(
        &mut self,
        gas_cost: DependentCost,
        arg: Word,
    ) -> SimpleResult<()> {
        let current_contract = self.contract_id();
        let SystemRegisters {
            pc, ggas, cgas, is, ..
        } = split_registers(&mut self.registers).0;
        let profiler = ProfileGas {
            pc: pc.as_ref(),
            is: is.as_ref(),
            current_contract,
            profiler: &mut self.profiler,
        };
        dependent_gas_charge(cgas, ggas, profiler, gas_cost, arg)
    }

    pub(crate) fn dependent_gas_charge_without_base(
        &mut self,
        gas_cost: DependentCost,
        arg: Word,
    ) -> SimpleResult<()> {
        let current_contract = self.contract_id();
        let SystemRegisters {
            pc, ggas, cgas, is, ..
        } = split_registers(&mut self.registers).0;
        let profiler = ProfileGas {
            pc: pc.as_ref(),
            is: is.as_ref(),
            current_contract,
            profiler: &mut self.profiler,
        };
        dependent_gas_charge_without_base(cgas, ggas, profiler, gas_cost, arg)
    }

    /// Do a gas charge with the given amount, panicing when running out of gas.
    pub fn gas_charge(&mut self, gas: Word) -> SimpleResult<()> {
        let current_contract = self.contract_id();
        let SystemRegisters {
            pc, ggas, cgas, is, ..
        } = split_registers(&mut self.registers).0;

        let profiler = ProfileGas {
            pc: pc.as_ref(),
            is: is.as_ref(),
            current_contract,
            profiler: &mut self.profiler,
        };
        gas_charge(cgas, ggas, profiler, gas)
    }
}

pub(crate) fn dependent_gas_charge_without_base(
    mut cgas: RegMut<CGAS>,
    ggas: RegMut<GGAS>,
    mut profiler: ProfileGas<'_>,
    gas_cost: DependentCost,
    arg: Word,
) -> SimpleResult<()> {
    let cost = gas_cost.resolve_without_base(arg);
    profiler.profile(cgas.as_ref(), cost);
    gas_charge_inner(cgas.as_mut(), ggas, cost)
}

pub(crate) fn dependent_gas_charge(
    mut cgas: RegMut<CGAS>,
    ggas: RegMut<GGAS>,
    mut profiler: ProfileGas<'_>,
    gas_cost: DependentCost,
    arg: Word,
) -> SimpleResult<()> {
    let cost = gas_cost.resolve(arg);
    profiler.profile(cgas.as_ref(), cost);
    gas_charge_inner(cgas.as_mut(), ggas, cost)
}

pub(crate) fn gas_charge(
    cgas: RegMut<CGAS>,
    ggas: RegMut<GGAS>,
    mut profiler: ProfileGas<'_>,
    gas: Word,
) -> SimpleResult<()> {
    profiler.profile(cgas.as_ref(), gas);
    gas_charge_inner(cgas, ggas, gas)
}

fn gas_charge_inner(
    mut cgas: RegMut<CGAS>,
    mut ggas: RegMut<GGAS>,
    gas: Word,
) -> SimpleResult<()> {
    if *cgas > *ggas {
        Err(Bug::new(BugVariant::GlobalGasLessThanContext).into())
    } else if gas > *cgas {
        *ggas = (*ggas)
            .checked_sub(*cgas)
            .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;
        *cgas = 0;

        Err(PanicReason::OutOfGas.into())
    } else {
        *cgas = (*cgas)
            .checked_sub(gas)
            .ok_or_else(|| Bug::new(BugVariant::ContextGasUnderflow))?;
        *ggas = (*ggas)
            .checked_sub(gas)
            .ok_or_else(|| Bug::new(BugVariant::GlobalGasUnderflow))?;

        Ok(())
    }
}

#[allow(dead_code)]
pub(crate) struct ProfileGas<'a> {
    pub pc: Reg<'a, PC>,
    pub is: Reg<'a, IS>,
    pub current_contract: Option<ContractId>,
    pub profiler: &'a mut Profiler,
}

impl<'a> ProfileGas<'a> {
    #[allow(unused_variables)]
    pub(crate) fn profile(&mut self, cgas: Reg<CGAS>, gas: Word) {
        #[cfg(feature = "profile-coverage")]
        {
            let location =
                super::current_location(self.current_contract, self.pc, self.is);
            self.profiler.set_coverage(location);
        }

        #[cfg(feature = "profile-gas")]
        {
            let gas_use = gas.min(*cgas);
            let location =
                super::current_location(self.current_contract, self.pc, self.is);
            self.profiler.add_gas(location, gas_use);
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/contract.rs

Source
//! This module contains logic on contract management.

use super::{
    gas::{
        gas_charge,
        ProfileGas,
    },
    internal::{
        external_asset_id_balance_sub,
        inc_pc,
        internal_contract,
        set_variable_output,
    },
    ExecutableTransaction,
    Interpreter,
    Memory,
    MemoryInstance,
    RuntimeBalances,
};
use crate::{
    constraints::reg_key::*,
    consts::*,
    context::Context,
    convert,
    error::{
        IoResult,
        RuntimeError,
    },
    interpreter::{
        receipts::ReceiptsCtx,
        InputContracts,
    },
    prelude::Profiler,
    storage::{
        ContractsAssetsStorage,
        ContractsRawCode,
        InterpreterStorage,
    },
};
use fuel_asm::{
    PanicReason,
    RegisterId,
    Word,
};
use fuel_storage::StorageSize;
use fuel_tx::{
    Contract,
    Output,
    Receipt,
};
use fuel_types::{
    Address,
    AssetId,
    Bytes32,
    ContractId,
};

use alloc::borrow::Cow;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
{
    pub(crate) fn contract_balance(
        &mut self,
        ra: RegisterId,
        b: Word,
        c: Word,
    ) -> Result<(), RuntimeError<S::DataError>> {
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        let input = ContractBalanceCtx {
            storage: &self.storage,
            memory: self.memory.as_mut(),
            pc,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
        };
        input.contract_balance(result, b, c)?;
        Ok(())
    }

    pub(crate) fn transfer(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
    ) -> IoResult<(), S::DataError> {
        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte();
        let tx_offset = self.tx_offset();
        let (
            SystemRegisters {
                cgas,
                ggas,
                fp,
                is,
                pc,
                ..
            },
            _,
        ) = split_registers(&mut self.registers);
        let input = TransferCtx {
            storage: &mut self.storage,
            memory: self.memory.as_mut(),
            context: &self.context,
            balances: &mut self.balances,
            receipts: &mut self.receipts,
            profiler: &mut self.profiler,
            new_storage_gas_per_byte,
            tx: &mut self.tx,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            tx_offset,
            cgas,
            ggas,
            fp: fp.as_ref(),
            is: is.as_ref(),
            pc,
        };
        input.transfer(a, b, c)
    }

    pub(crate) fn transfer_output(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
        d: Word,
    ) -> IoResult<(), S::DataError> {
        let tx_offset = self.tx_offset();
        let new_storage_gas_per_byte = self.gas_costs().new_storage_per_byte();
        let (
            SystemRegisters {
                cgas,
                ggas,
                fp,
                is,
                pc,
                ..
            },
            _,
        ) = split_registers(&mut self.registers);
        let input = TransferCtx {
            storage: &mut self.storage,
            memory: self.memory.as_mut(),
            context: &self.context,
            balances: &mut self.balances,
            receipts: &mut self.receipts,
            profiler: &mut self.profiler,
            new_storage_gas_per_byte,
            tx: &mut self.tx,
            input_contracts: InputContracts::new(
                &self.input_contracts,
                &mut self.panic_context,
            ),
            tx_offset,
            cgas,
            ggas,
            fp: fp.as_ref(),
            is: is.as_ref(),
            pc,
        };
        input.transfer_output(a, b, c, d)
    }

    pub(crate) fn check_contract_exists(
        &self,
        contract: &ContractId,
    ) -> IoResult<bool, S::DataError> {
        self.storage
            .storage_contract_exists(contract)
            .map_err(RuntimeError::Storage)
    }
}

pub(crate) fn contract<'s, S>(
    storage: &'s S,
    contract: &ContractId,
) -> IoResult<Cow<'s, Contract>, S::DataError>
where
    S: InterpreterStorage,
{
    storage
        .storage_contract(contract)
        .map_err(RuntimeError::Storage)?
        .ok_or_else(|| PanicReason::ContractNotFound.into())
}

struct ContractBalanceCtx<'vm, S> {
    storage: &'vm S,
    memory: &'vm mut MemoryInstance,
    pc: RegMut<'vm, PC>,
    input_contracts: InputContracts<'vm>,
}

impl<'vm, S> ContractBalanceCtx<'vm, S> {
    pub(crate) fn contract_balance(
        mut self,
        result: &mut Word,
        b: Word,
        c: Word,
    ) -> IoResult<(), S::Error>
    where
        S: ContractsAssetsStorage,
    {
        let asset_id = AssetId::new(self.memory.read_bytes(b)?);
        let contract = ContractId::new(self.memory.read_bytes(c)?);

        self.input_contracts.check(&contract)?;

        let balance = balance(self.storage, &contract, &asset_id)?;

        *result = balance;

        Ok(inc_pc(self.pc)?)
    }
}
struct TransferCtx<'vm, S, Tx> {
    storage: &'vm mut S,
    memory: &'vm mut MemoryInstance,
    context: &'vm Context,
    balances: &'vm mut RuntimeBalances,
    receipts: &'vm mut ReceiptsCtx,
    profiler: &'vm mut Profiler,
    new_storage_gas_per_byte: Word,
    tx: &'vm mut Tx,
    input_contracts: InputContracts<'vm>,
    tx_offset: usize,
    cgas: RegMut<'vm, CGAS>,
    ggas: RegMut<'vm, GGAS>,
    fp: Reg<'vm, FP>,
    is: Reg<'vm, IS>,
    pc: RegMut<'vm, PC>,
}

impl<'vm, S, Tx> TransferCtx<'vm, S, Tx> {
    /// In Fuel specs:
    /// Transfer $rB coins with asset ID at $rC to contract with ID at $rA.
    /// $rA -> recipient_contract_id_offset
    /// $rB -> transfer_amount
    /// $rC -> asset_id_offset
    pub(crate) fn transfer(
        mut self,
        recipient_contract_id_offset: Word,
        transfer_amount: Word,
        asset_id_offset: Word,
    ) -> IoResult<(), S::Error>
    where
        Tx: ExecutableTransaction,
        S: ContractsAssetsStorage,
    {
        let amount = transfer_amount;
        let destination =
            ContractId::from(self.memory.read_bytes(recipient_contract_id_offset)?);
        let asset_id = AssetId::from(self.memory.read_bytes(asset_id_offset)?);

        self.input_contracts.check(&destination)?;

        if amount == 0 {
            return Err(PanicReason::TransferZeroCoins.into())
        }

        let internal_context = match internal_contract(self.context, self.fp, self.memory)
        {
            // optimistically attempt to load the internal contract id
            Ok(source_contract) => Some(source_contract),
            // revert to external context if no internal contract is set
            Err(PanicReason::ExpectedInternalContext) => None,
            // bubble up any other kind of errors
            Err(e) => return Err(e.into()),
        };

        if let Some(source_contract) = internal_context {
            // debit funding source (source contract balance)
            balance_decrease(self.storage, &source_contract, &asset_id, amount)?;
        } else {
            // debit external funding source (i.e. free balance)
            external_asset_id_balance_sub(self.balances, self.memory, &asset_id, amount)?;
        }
        // credit destination contract
        let (_, created_new_entry) =
            balance_increase(self.storage, &destination, &asset_id, amount)?;
        if created_new_entry {
            // If a new entry was created, we must charge gas for it
            let profiler = ProfileGas {
                pc: self.pc.as_ref(),
                is: self.is,
                current_contract: internal_context,
                profiler: self.profiler,
            };
            gas_charge(
                self.cgas,
                self.ggas,
                profiler,
                ((Bytes32::LEN + WORD_SIZE) as u64)
                    .saturating_mul(self.new_storage_gas_per_byte),
            )?;
        }

        let receipt = Receipt::transfer(
            internal_context.unwrap_or_default(),
            destination,
            amount,
            asset_id,
            *self.pc,
            *self.is,
        );

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }

    /// In Fuel specs:
    /// Transfer $rC coins with asset ID at $rD to address at $rA, with output $rB.
    /// $rA -> recipient_offset
    /// $rB -> output_index
    /// $rC -> transfer_amount
    /// $rD -> asset_id_offset
    pub(crate) fn transfer_output(
        self,
        recipient_offset: Word,
        output_index: Word,
        transfer_amount: Word,
        asset_id_offset: Word,
    ) -> IoResult<(), S::Error>
    where
        Tx: ExecutableTransaction,
        S: ContractsAssetsStorage,
    {
        let out_idx =
            convert::to_usize(output_index).ok_or(PanicReason::OutputNotFound)?;
        let to = Address::from(self.memory.read_bytes(recipient_offset)?);
        let asset_id = AssetId::from(self.memory.read_bytes(asset_id_offset)?);
        let amount = transfer_amount;

        if amount == 0 {
            return Err(PanicReason::TransferZeroCoins.into())
        }

        let internal_context = match internal_contract(self.context, self.fp, self.memory)
        {
            // optimistically attempt to load the internal contract id
            Ok(source_contract) => Some(source_contract),
            // revert to external context if no internal contract is set
            Err(PanicReason::ExpectedInternalContext) => None,
            // bubble up any other kind of errors
            Err(e) => return Err(e.into()),
        };

        if let Some(source_contract) = internal_context {
            // debit funding source (source contract balance)
            balance_decrease(self.storage, &source_contract, &asset_id, amount)?;
        } else {
            // debit external funding source (i.e. UTXOs)
            external_asset_id_balance_sub(self.balances, self.memory, &asset_id, amount)?;
        }

        // credit variable output
        let variable = Output::variable(to, amount, asset_id);

        set_variable_output(self.tx, self.memory, self.tx_offset, out_idx, variable)?;

        let receipt = Receipt::transfer_out(
            internal_context.unwrap_or_default(),
            to,
            amount,
            asset_id,
            *self.pc,
            *self.is,
        );

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }
}

pub(crate) fn contract_size<S>(
    storage: &S,
    contract: &ContractId,
) -> IoResult<u32, S::Error>
where
    S: StorageSize<ContractsRawCode> + ?Sized,
{
    let size = storage
        .size_of_value(contract)
        .map_err(RuntimeError::Storage)?
        .ok_or(PanicReason::ContractNotFound)?;
    Ok(u32::try_from(size).map_err(|_| PanicReason::MemoryOverflow)?)
}

pub(crate) fn balance<S>(
    storage: &S,
    contract: &ContractId,
    asset_id: &AssetId,
) -> IoResult<Word, S::Error>
where
    S: ContractsAssetsStorage + ?Sized,
{
    Ok(storage
        .contract_asset_id_balance(contract, asset_id)
        .map_err(RuntimeError::Storage)?
        .unwrap_or_default())
}

/// Increase the asset balance for a contract.
/// Returns new balance, and a boolean indicating if a new entry was created.
pub fn balance_increase<S>(
    storage: &mut S,
    contract: &ContractId,
    asset_id: &AssetId,
    amount: Word,
) -> IoResult<(Word, bool), S::Error>
where
    S: ContractsAssetsStorage + ?Sized,
{
    let balance = balance(storage, contract, asset_id)?;
    let balance = balance
        .checked_add(amount)
        .ok_or(PanicReason::BalanceOverflow)?;

    let old_value = storage
        .contract_asset_id_balance_replace(contract, asset_id, balance)
        .map_err(RuntimeError::Storage)?;

    Ok((balance, old_value.is_none()))
}

/// Decrease the asset balance for a contract.
pub fn balance_decrease<S>(
    storage: &mut S,
    contract: &ContractId,
    asset_id: &AssetId,
    amount: Word,
) -> IoResult<Word, S::Error>
where
    S: ContractsAssetsStorage + ?Sized,
{
    let balance = balance(storage, contract, asset_id)?;
    let balance = balance
        .checked_sub(amount)
        .ok_or(PanicReason::NotEnoughBalance)?;
    storage
        .contract_asset_id_balance_insert(contract, asset_id, balance)
        .map_err(RuntimeError::Storage)?;
    Ok(balance)
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/log.rs

Source
use super::{
    internal::{
        inc_pc,
        internal_contract,
    },
    receipts::ReceiptsCtx,
    ExecutableTransaction,
    Interpreter,
    Memory,
    MemoryInstance,
};
use crate::{
    constraints::reg_key::*,
    context::Context,
    error::SimpleResult,
};

use fuel_tx::Receipt;
use fuel_types::Word;

#[cfg(test)]
mod tests;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
{
    pub(crate) fn log(&mut self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
        let (SystemRegisters { fp, is, pc, .. }, _) =
            split_registers(&mut self.registers);
        let input = LogInput {
            memory: self.memory.as_mut(),
            context: &self.context,
            receipts: &mut self.receipts,
            fp: fp.as_ref(),
            is: is.as_ref(),
            pc,
        };
        input.log(a, b, c, d)
    }

    pub(crate) fn log_data(
        &mut self,
        a: Word,
        b: Word,
        c: Word,
        d: Word,
    ) -> SimpleResult<()> {
        let (SystemRegisters { fp, is, pc, .. }, _) =
            split_registers(&mut self.registers);
        let input = LogInput {
            memory: self.memory.as_mut(),
            context: &self.context,
            receipts: &mut self.receipts,
            fp: fp.as_ref(),
            is: is.as_ref(),
            pc,
        };
        input.log_data(a, b, c, d)
    }
}

struct LogInput<'vm> {
    memory: &'vm MemoryInstance,
    context: &'vm Context,
    receipts: &'vm mut ReceiptsCtx,
    fp: Reg<'vm, FP>,
    is: Reg<'vm, IS>,
    pc: RegMut<'vm, PC>,
}

impl LogInput<'_> {
    pub(crate) fn log(self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
        let receipt = Receipt::log(
            internal_contract(self.context, self.fp, self.memory).unwrap_or_default(),
            a,
            b,
            c,
            d,
            *self.pc,
            *self.is,
        );

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }

    pub(crate) fn log_data(self, a: Word, b: Word, c: Word, d: Word) -> SimpleResult<()> {
        let data = self.memory.read(c, d)?.to_vec();

        let receipt = Receipt::log_data(
            internal_contract(self.context, self.fp, self.memory).unwrap_or_default(),
            a,
            b,
            c,
            *self.pc,
            *self.is,
            data,
        );

        self.receipts.push(receipt)?;

        Ok(inc_pc(self.pc)?)
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/constructors.rs

Source
//! Exposed constructors API for the [`Interpreter`]
#![allow(clippy::default_constructed_unit_structs)] // need for ::default() depends on cfg

#[cfg(any(test, feature = "test-helpers"))]
use super::{
    ExecutableTransaction,
    MemoryInstance,
};
use super::{
    Interpreter,
    RuntimeBalances,
};
use crate::{
    consts::*,
    context::Context,
    interpreter::{
        InterpreterParams,
        PanicContext,
    },
    state::Debugger,
};

use alloc::vec;

#[cfg(feature = "profile-any")]
use crate::profiler::ProfileReceiver;

use crate::profiler::Profiler;

#[cfg(feature = "test-helpers")]
use crate::{
    interpreter::EcalHandler,
    storage::MemoryStorage,
};

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    Tx: Default,
    Ecal: Default,
{
    /// Create a new interpreter instance out of a storage implementation.
    ///
    /// If the provided storage implements
    /// [`crate::storage::InterpreterStorage`], the returned interpreter
    /// will provide full functionality.
    pub fn with_storage(
        memory: M,
        storage: S,
        interpreter_params: InterpreterParams,
    ) -> Self {
        Self::with_storage_and_ecal(memory, storage, interpreter_params, Ecal::default())
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    Tx: Default,
{
    /// Create a new interpreter instance out of a storage implementation.
    ///
    /// If the provided storage implements
    /// [`crate::storage::InterpreterStorage`], the returned interpreter
    /// will provide full functionality.
    pub fn with_storage_and_ecal(
        memory: M,
        storage: S,
        interpreter_params: InterpreterParams,
        ecal_state: Ecal,
    ) -> Self {
        Self {
            registers: [0; VM_REGISTER_COUNT],
            memory,
            frames: vec![],
            receipts: Default::default(),
            tx: Default::default(),
            input_contracts: Default::default(),
            input_contracts_index_to_output_index: Default::default(),
            initial_balances: Default::default(),
            storage,
            debugger: Debugger::default(),
            context: Context::default(),
            balances: RuntimeBalances::default(),
            profiler: Profiler::default(),
            interpreter_params,
            panic_context: PanicContext::None,
            ecal_state,
        }
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal> {
    /// Sets a profiler for the VM
    #[cfg(feature = "profile-any")]
    pub fn with_profiler<P>(&mut self, receiver: P) -> &mut Self
    where
        P: ProfileReceiver + Send + Sync + 'static,
    {
        self.profiler.set_receiver(alloc::boxed::Box::new(receiver));
        self
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl<S, Tx, Ecal> Default for Interpreter<MemoryInstance, S, Tx, Ecal>
where
    S: Default,
    Tx: ExecutableTransaction,
    Ecal: EcalHandler + Default,
{
    fn default() -> Self {
        Interpreter::<_, S, Tx, Ecal>::with_storage(
            MemoryInstance::new(),
            Default::default(),
            InterpreterParams::default(),
        )
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl<Tx, Ecal> Interpreter<MemoryInstance, (), Tx, Ecal>
where
    Tx: ExecutableTransaction,
    Ecal: EcalHandler + Default,
{
    /// Create a new interpreter without a storage backend.
    ///
    /// It will have restricted capabilities.
    pub fn without_storage() -> Self {
        Self::default()
    }
}

#[cfg(feature = "test-helpers")]
impl<Tx, Ecal> Interpreter<MemoryInstance, MemoryStorage, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    Ecal: EcalHandler + Default,
{
    /// Create a new storage with a provided in-memory storage.
    ///
    /// It will have full capabilities.
    pub fn with_memory_storage() -> Self {
        Self::default()
    }
}

#[cfg(feature = "test-helpers")]
impl<Tx, Ecal> Interpreter<MemoryInstance, MemoryStorage, Tx, Ecal>
where
    Tx: ExecutableTransaction,
    Ecal: EcalHandler,
{
    /// Create a new storage with a provided in-memory storage.
    ///
    /// It will have full capabilities.
    pub fn with_memory_storage_and_ecal(ecal: Ecal) -> Self {
        Interpreter::<_, MemoryStorage, Tx, Ecal>::with_storage_and_ecal(
            MemoryInstance::new(),
            Default::default(),
            InterpreterParams::default(),
            ecal,
        )
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/memory.rs

Source
#![cfg(feature = "alloc")]

use super::{
    internal::inc_pc,
    Interpreter,
};
use crate::{
    constraints::reg_key::*,
    consts::*,
    error::SimpleResult,
};

use fuel_asm::{
    Imm12,
    Imm24,
    PanicReason,
    RegId,
};
use fuel_types::{
    fmt_truncated_hex,
    RegisterId,
    Word,
};

use core::{
    fmt,
    ops::Range,
};

#[cfg(any(test, feature = "test-helpers"))]
use core::ops::{
    Index,
    IndexMut,
    RangeFrom,
    RangeTo,
};

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

#[cfg(test)]
mod tests;

#[cfg(test)]
mod impl_tests;

#[cfg(test)]
mod allocation_tests;

#[cfg(test)]
mod stack_tests;

/// The trait for the memory.
pub trait Memory: AsRef<MemoryInstance> + AsMut<MemoryInstance> {}

impl<M> Memory for M where M: AsRef<MemoryInstance> + AsMut<MemoryInstance> {}

/// The memory of the VM, represented as stack and heap.
#[derive(Clone, Eq)]
pub struct MemoryInstance {
    /// Stack. Grows upwards.
    stack: Vec<u8>,
    /// Heap. Grows downwards from MEM_SIZE.
    heap: Vec<u8>,
    /// Lowest allowed heap address, i.e. hp register value.
    /// This is needed since we can allocate extra heap for performance reasons.
    hp: usize,
}

impl Default for MemoryInstance {
    fn default() -> Self {
        Self::new()
    }
}

impl fmt::Debug for MemoryInstance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Memory {{ stack: ")?;
        fmt_truncated_hex::<16>(&self.stack, f)?;
        write!(f, ", heap: ")?;
        let off = self.hp.saturating_sub(self.heap_offset());
        fmt_truncated_hex::<16>(&self.heap[off..], f)?;
        write!(f, ", hp: {} }}", self.hp)
    }
}

impl PartialEq for MemoryInstance {
    /// Equality comparison of the accessible memory.
    #[allow(clippy::arithmetic_side_effects)] // Safety: hp is kept valid everywhere
    fn eq(&self, other: &Self) -> bool {
        self.stack == other.stack && self.hp == other.hp && {
            let self_hs = self.hp - self.heap_offset();
            let other_hs = other.hp - other.heap_offset();
            self.heap[self_hs..] == other.heap[other_hs..]
        }
    }
}

impl AsRef<MemoryInstance> for MemoryInstance {
    fn as_ref(&self) -> &MemoryInstance {
        self
    }
}
impl AsMut<MemoryInstance> for MemoryInstance {
    fn as_mut(&mut self) -> &mut MemoryInstance {
        self
    }
}

impl MemoryInstance {
    /// Create a new VM memory.
    pub fn new() -> Self {
        Self {
            stack: Vec::new(),
            heap: Vec::new(),
            hp: MEM_SIZE,
        }
    }

    /// Resets memory to initial state, keeping the original allocations.
    pub fn reset(&mut self) {
        self.stack.truncate(0);
        self.hp = MEM_SIZE;
    }

    /// Offset of the heap section
    fn heap_offset(&self) -> usize {
        MEM_SIZE.saturating_sub(self.heap.len())
    }

    /// Returns a linear memory representation where stack is at the beginning and heap is
    /// at the end.
    pub fn into_linear_memory(self) -> Vec<u8> {
        let uninit_memory_size = MEM_SIZE
            .saturating_sub(self.stack.len())
            .saturating_sub(self.heap.len());
        let uninit_memory = vec![0u8; uninit_memory_size];
        let mut memory = self.stack;
        memory.extend(uninit_memory);
        memory.extend(self.heap);
        memory
    }

    /// Grows the stack to be at least `new_sp` bytes.
    pub fn grow_stack(&mut self, new_sp: Word) -> Result<(), PanicReason> {
        if new_sp > VM_MAX_RAM {
            return Err(PanicReason::MemoryOverflow);
        }
        #[allow(clippy::cast_possible_truncation)] // Safety: VM_MAX_RAM is usize
        let new_sp = new_sp as usize;

        if new_sp > self.stack.len() {
            if new_sp > self.hp {
                return Err(PanicReason::MemoryGrowthOverlap)
            }

            self.stack.resize(new_sp, 0);
        }
        Ok(())
    }

    /// Grows the heap by `amount` bytes. Updates hp register.
    pub fn grow_heap_by(
        &mut self,
        sp_reg: Reg<SP>,
        mut hp_reg: RegMut<HP>,
        amount: Word,
    ) -> Result<(), PanicReason> {
        debug_assert_eq!(
            self.hp as Word, *hp_reg,
            "HP register changed without memory update"
        );

        let amount = usize::try_from(amount).map_err(|_| PanicReason::MemoryOverflow)?;
        let new_hp = self
            .hp
            .checked_sub(amount)
            .ok_or(PanicReason::MemoryOverflow)?;

        if (new_hp as Word) < *sp_reg {
            return Err(PanicReason::MemoryGrowthOverlap)
        }

        #[allow(clippy::arithmetic_side_effects)] // Safety: self.hp is in heap
        let new_len = MEM_SIZE - new_hp;

        #[allow(clippy::arithmetic_side_effects)] // Safety: self.hp is in heap
        if self.heap.len() >= new_len {
            // No need to reallocate, but we need to zero the new space
            // in case it was used before a memory reset.
            let start = new_hp - self.heap_offset();
            let end = self.hp - self.heap_offset();
            self.heap[start..end].fill(0);
        } else {
            // Reallocation is needed.
            // To reduce frequent reallocations, allocate at least 256 bytes at once.
            // After that, double the allocation every time.
            let cap = new_len.next_power_of_two().clamp(256, MEM_SIZE);
            let old_len = self.heap.len();
            let prefix_zeroes = cap - old_len;
            self.heap.resize(cap, 0);
            self.heap.copy_within(..old_len, prefix_zeroes);
            self.heap[..prefix_zeroes].fill(0);
        }

        self.hp = new_hp;
        *hp_reg = new_hp as Word;

        // If heap enters region where stack has been, truncate the stack
        self.stack.truncate(new_hp);

        Ok(())
    }

    /// Verify that the memory range is accessble and return it as a range.
    pub fn verify<A: ToAddr, B: ToAddr>(
        &self,
        addr: A,
        count: B,
    ) -> Result<MemoryRange, PanicReason> {
        let start = addr.to_addr()?;
        let len = count.to_addr()?;
        let end = start.saturating_add(len);
        if end > MEM_SIZE {
            return Err(PanicReason::MemoryOverflow)
        }

        if end <= self.stack.len() || start >= self.hp {
            Ok(MemoryRange(start..end))
        } else {
            Err(PanicReason::UninitalizedMemoryAccess)
        }
    }

    /// Verify a constant-sized memory range.
    pub fn verify_const<A: ToAddr, const C: usize>(
        &self,
        addr: A,
    ) -> Result<MemoryRange, PanicReason> {
        self.verify(addr, C)
    }

    /// Returns a reference to memory for reading, if possible.
    #[allow(clippy::arithmetic_side_effects)] // Safety: subtractions are checked
    pub fn read<A: ToAddr, C: ToAddr>(
        &self,
        addr: A,
        count: C,
    ) -> Result<&[u8], PanicReason> {
        let range = self.verify(addr, count)?;

        if range.end() <= self.stack.len() {
            Ok(&self.stack[range.usizes()])
        } else if range.start() >= self.heap_offset() {
            let start = range.start() - self.heap_offset();
            let end = range.end() - self.heap_offset();
            Ok(&self.heap[start..end])
        } else {
            unreachable!("Range was verified to be valid")
        }
    }

    /// Reads a constant-sized byte array from memory, if possible.
    pub fn read_bytes<A: ToAddr, const C: usize>(
        &self,
        at: A,
    ) -> Result<[u8; C], PanicReason> {
        let mut result = [0; C];
        result.copy_from_slice(self.read(at, C)?);
        Ok(result)
    }

    /// Gets write access to memory, if possible.
    /// Doesn't perform any ownership checks.
    #[allow(clippy::arithmetic_side_effects)] // Safety: subtractions are checked
    pub fn write_noownerchecks<A: ToAddr, B: ToAddr>(
        &mut self,
        addr: A,
        len: B,
    ) -> Result<&mut [u8], PanicReason> {
        let range = self.verify(addr, len)?;
        if range.end() <= self.stack.len() {
            Ok(&mut self.stack[range.usizes()])
        } else if range.start() >= self.heap_offset() {
            let start = range.start() - self.heap_offset();
            let end = range.end() - self.heap_offset();
            Ok(&mut self.heap[start..end])
        } else {
            unreachable!("Range was verified to be valid")
        }
    }

    /// Writes a constant-sized byte array to memory, if possible.
    /// Doesn't perform any ownership checks.
    pub fn write_bytes_noownerchecks<A: ToAddr, const C: usize>(
        &mut self,
        addr: A,
        data: [u8; C],
    ) -> Result<(), PanicReason> {
        self.write_noownerchecks(addr, C)?.copy_from_slice(&data);
        Ok(())
    }

    /// Checks that memory is writable and returns a mutable slice to it.
    pub fn write<A: ToAddr, C: ToAddr>(
        &mut self,
        owner: OwnershipRegisters,
        addr: A,
        len: C,
    ) -> Result<&mut [u8], PanicReason> {
        let range = self.verify(addr, len)?;
        owner.verify_ownership(&range)?;
        self.write_noownerchecks(range.start(), range.len())
    }

    /// Writes a constant-sized byte array to memory, checking for ownership.
    pub fn write_bytes<A: ToAddr, const C: usize>(
        &mut self,
        owner: OwnershipRegisters,
        addr: A,
        data: [u8; C],
    ) -> Result<(), PanicReason> {
        self.write(owner, addr, data.len())?.copy_from_slice(&data);
        Ok(())
    }

    /// Copies the memory from `src` to `dst` verifying ownership.
    #[inline]
    #[track_caller]
    pub fn memcopy(
        &mut self,
        dst: Word,
        src: Word,
        length: Word,
        owner: OwnershipRegisters,
    ) -> Result<(), PanicReason> {
        let dst_range = self.verify(dst, length)?;
        let src_range = self.verify(src, length)?;

        if dst_range.start() <= src_range.start() && src_range.start() < dst_range.end()
            || src_range.start() <= dst_range.start()
                && dst_range.start() < src_range.end()
            || dst_range.start() < src_range.end() && src_range.end() <= dst_range.end()
            || src_range.start() < dst_range.end() && dst_range.end() <= src_range.end()
        {
            return Err(PanicReason::MemoryWriteOverlap)
        }

        owner.verify_ownership(&dst_range)?;

        if src_range.end() <= self.stack.len() {
            if dst_range.end() <= self.stack.len() {
                self.stack
                    .copy_within(src_range.usizes(), dst_range.start());
            } else if dst_range.start() >= self.heap_offset() {
                #[allow(clippy::arithmetic_side_effects)]
                // Safety: subtractions are checked above
                let dst_start = dst_range.start() - self.heap_offset();
                #[allow(clippy::arithmetic_side_effects)]
                // Safety: subtractions are checked above
                let dst_end = dst_range.end() - self.heap_offset();

                let src_array = &self.stack[src_range.usizes()];
                let dst_array = &mut self.heap[dst_start..dst_end];
                dst_array.copy_from_slice(src_array);
            } else {
                unreachable!("Range was verified to be valid")
            }
        } else if src_range.start() >= self.heap_offset() {
            #[allow(clippy::arithmetic_side_effects)]
            // Safety: subtractions are checked above
            let src_start = src_range.start() - self.heap_offset();
            #[allow(clippy::arithmetic_side_effects)]
            // Safety: subtractions are checked above
            let src_end = src_range.end() - self.heap_offset();

            if dst_range.end() <= self.stack.len() {
                let src_array = &self.heap[src_start..src_end];

                let dst_array = &mut self.stack[dst_range.usizes()];
                dst_array.copy_from_slice(src_array);
            } else if dst_range.start() >= self.heap_offset() {
                #[allow(clippy::arithmetic_side_effects)]
                // Safety: subtractions are checked above
                let dst_start = dst_range.start() - self.heap_offset();

                self.heap.copy_within(src_start..src_end, dst_start);
            } else {
                unreachable!("Range was verified to be valid")
            }
        } else {
            unreachable!("Range was verified to be valid")
        }

        Ok(())
    }

    /// Memory access to the raw stack buffer.
    /// Note that for efficiency reasons this might not match sp value.
    #[cfg(any(test, feature = "test-helpers"))]
    pub fn stack_raw(&self) -> &[u8] {
        &self.stack
    }

    /// Memory access to the raw heap buffer.
    /// Note that for efficiency reasons this might not match hp value.
    #[cfg(any(test, feature = "test-helpers"))]
    pub fn heap_raw(&self) -> &[u8] {
        &self.heap
    }
}

#[cfg(feature = "test-helpers")]
impl From<Vec<u8>> for MemoryInstance {
    fn from(stack: Vec<u8>) -> Self {
        Self {
            stack,
            ..Self::new()
        }
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl Index<Range<usize>> for MemoryInstance {
    type Output = [u8];

    fn index(&self, index: Range<usize>) -> &Self::Output {
        self.read(index.start, index.len())
            .expect("Memory range out of bounds")
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl Index<RangeFrom<usize>> for MemoryInstance {
    type Output = [u8];

    fn index(&self, index: RangeFrom<usize>) -> &Self::Output {
        &self[index.start..MEM_SIZE]
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl Index<RangeTo<usize>> for MemoryInstance {
    type Output = [u8];

    fn index(&self, index: RangeTo<usize>) -> &Self::Output {
        &self[0..index.end]
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl IndexMut<Range<usize>> for MemoryInstance {
    fn index_mut(&mut self, index: Range<usize>) -> &mut Self::Output {
        self.write_noownerchecks(index.start, index.len())
            .expect("Memory range out of bounds")
    }
}

/// Used to handle `Word` to `usize` conversions for memory addresses,
/// as well as checking that the resulting value is withing the VM ram boundaries.
pub trait ToAddr {
    /// Converts a value to `usize` used for memory addresses.
    /// Returns `Err` with `MemoryOverflow` if the resulting value does't fit in the VM
    /// memory. This can be used for both addresses and offsets.
    fn to_addr(self) -> Result<usize, PanicReason>;
}

impl ToAddr for usize {
    fn to_addr(self) -> Result<usize, PanicReason> {
        if self > MEM_SIZE {
            return Err(PanicReason::MemoryOverflow)
        }
        Ok(self)
    }
}

impl ToAddr for Word {
    fn to_addr(self) -> Result<usize, PanicReason> {
        let value = usize::try_from(self).map_err(|_| PanicReason::MemoryOverflow)?;
        value.to_addr()
    }
}

#[cfg(feature = "test-helpers")]
/// Implemented for `i32` to allow integer literals. Panics on negative values.
impl ToAddr for i32 {
    fn to_addr(self) -> Result<usize, PanicReason> {
        if self < 0 {
            panic!("Negative memory address");
        }
        let value = usize::try_from(self).map_err(|_| PanicReason::MemoryOverflow)?;
        value.to_addr()
    }
}

/// A range of memory. No guarantees are made about validity of access.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MemoryRange(Range<usize>);

impl MemoryRange {
    /// Create a new memory range. Cannot panic, but the range may be invalid.
    pub const fn new(start: usize, len: usize) -> Self {
        Self(start..start.saturating_add(len))
    }

    /// Start of the range.
    pub fn start(&self) -> usize {
        self.0.start
    }

    /// End of the range. One past the last byte.
    pub fn end(&self) -> usize {
        self.0.end
    }

    /// Is the range empty?
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Length of the range.
    pub fn len(&self) -> usize {
        self.0.len()
    }

    /// Returns the range as a `usize` range.
    pub fn usizes(&self) -> Range<usize> {
        self.0.clone()
    }

    /// Returns the range as a `Word` range.
    pub fn words(&self) -> Range<Word> {
        self.0.start as Word..self.0.end as Word
    }

    /// Splits range at given relative offset. Panics if offset > range length.
    pub fn split_at_offset(self, at: usize) -> (Self, Self) {
        let mid = self.0.start.saturating_add(at);
        assert!(mid <= self.0.end);
        (Self(self.0.start..mid), Self(mid..self.0.end))
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
{
    /// Return the registers used to determine ownership.
    pub(crate) fn ownership_registers(&self) -> OwnershipRegisters {
        OwnershipRegisters::new(self)
    }

    pub(crate) fn stack_pointer_overflow<F>(&mut self, f: F, v: Word) -> SimpleResult<()>
    where
        F: FnOnce(Word, Word) -> (Word, bool),
    {
        let (
            SystemRegisters {
                sp, ssp, hp, pc, ..
            },
            _,
        ) = split_registers(&mut self.registers);
        stack_pointer_overflow(
            sp,
            ssp.as_ref(),
            hp.as_ref(),
            pc,
            f,
            v,
            self.memory.as_mut(),
        )
    }

    pub(crate) fn push_selected_registers(
        &mut self,
        segment: ProgramRegistersSegment,
        bitmask: Imm24,
    ) -> SimpleResult<()> {
        let (
            SystemRegisters {
                sp, ssp, hp, pc, ..
            },
            program_regs,
        ) = split_registers(&mut self.registers);
        push_selected_registers(
            self.memory.as_mut(),
            sp,
            ssp.as_ref(),
            hp.as_ref(),
            pc,
            &program_regs,
            segment,
            bitmask,
        )
    }

    pub(crate) fn pop_selected_registers(
        &mut self,
        segment: ProgramRegistersSegment,
        bitmask: Imm24,
    ) -> SimpleResult<()> {
        let (
            SystemRegisters {
                sp, ssp, hp, pc, ..
            },
            mut program_regs,
        ) = split_registers(&mut self.registers);
        pop_selected_registers(
            self.memory.as_mut(),
            sp,
            ssp.as_ref(),
            hp.as_ref(),
            pc,
            &mut program_regs,
            segment,
            bitmask,
        )
    }

    pub(crate) fn load_byte(
        &mut self,
        ra: RegisterId,
        b: Word,
        c: Word,
    ) -> SimpleResult<()> {
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        load_byte(self.memory.as_ref(), pc, result, b, c)
    }

    pub(crate) fn load_word(
        &mut self,
        ra: RegisterId,
        b: Word,
        c: Imm12,
    ) -> SimpleResult<()> {
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        load_word(self.memory.as_ref(), pc, result, b, c)
    }

    pub(crate) fn store_byte(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        store_byte(
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
            b,
            c,
        )
    }

    pub(crate) fn store_word(&mut self, a: Word, b: Word, c: Imm12) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        store_word(
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
            b,
            c,
        )
    }

    /// Expand heap by `amount` bytes.
    pub fn allocate(&mut self, amount: Word) -> SimpleResult<()> {
        let (SystemRegisters { hp, sp, .. }, _) = split_registers(&mut self.registers);
        self.memory.as_mut().grow_heap_by(sp.as_ref(), hp, amount)?;
        Ok(())
    }

    pub(crate) fn malloc(&mut self, a: Word) -> SimpleResult<()> {
        let (SystemRegisters { hp, sp, pc, .. }, _) =
            split_registers(&mut self.registers);
        malloc(hp, sp.as_ref(), pc, a, self.memory.as_mut())
    }

    pub(crate) fn memclear(&mut self, a: Word, b: Word) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        memclear(self.memory.as_mut(), owner, self.registers.pc_mut(), a, b)
    }

    pub(crate) fn memcopy(&mut self, a: Word, b: Word, c: Word) -> SimpleResult<()> {
        let owner = self.ownership_registers();
        memcopy(
            self.memory.as_mut(),
            owner,
            self.registers.pc_mut(),
            a,
            b,
            c,
        )
    }

    pub(crate) fn memeq(
        &mut self,
        ra: RegisterId,
        b: Word,
        c: Word,
        d: Word,
    ) -> SimpleResult<()> {
        let (SystemRegisters { pc, .. }, mut w) = split_registers(&mut self.registers);
        let result = &mut w[WriteRegKey::try_from(ra)?];
        memeq(self.memory.as_mut(), result, pc, b, c, d)
    }
}

/// Update stack pointer, checking for validity first.
pub(crate) fn try_update_stack_pointer(
    mut sp: RegMut<SP>,
    ssp: Reg<SSP>,
    hp: Reg<HP>,
    new_sp: Word,
    memory: &mut MemoryInstance,
) -> SimpleResult<()> {
    if new_sp < *ssp {
        Err(PanicReason::MemoryOverflow.into())
    } else if new_sp > *hp {
        Err(PanicReason::MemoryGrowthOverlap.into())
    } else {
        *sp = new_sp;
        memory.grow_stack(new_sp)?;
        Ok(())
    }
}

pub(crate) fn stack_pointer_overflow<F>(
    sp: RegMut<SP>,
    ssp: Reg<SSP>,
    hp: Reg<HP>,
    pc: RegMut<PC>,
    f: F,
    v: Word,
    memory: &mut MemoryInstance,
) -> SimpleResult<()>
where
    F: FnOnce(Word, Word) -> (Word, bool),
{
    let (new_sp, overflow) = f(*sp, v);

    if overflow {
        return Err(PanicReason::MemoryOverflow.into())
    }

    try_update_stack_pointer(sp, ssp, hp, new_sp, memory)?;
    Ok(inc_pc(pc)?)
}

#[allow(clippy::too_many_arguments)]
pub(crate) fn push_selected_registers(
    memory: &mut MemoryInstance,
    sp: RegMut<SP>,
    ssp: Reg<SSP>,
    hp: Reg<HP>,
    pc: RegMut<PC>,
    program_regs: &ProgramRegisters,
    segment: ProgramRegistersSegment,
    bitmask: Imm24,
) -> SimpleResult<()> {
    let bitmask = bitmask.to_u32();

    // First update the new stack pointer, as that's the only error condition
    let count: u64 = bitmask.count_ones().into();
    let write_size = count
        .checked_mul(WORD_SIZE as u64)
        .expect("Bitmask size times 8 can never oveflow");
    let write_at = *sp;
    // If this would overflow, the stack pointer update below will fail
    let new_sp = write_at.saturating_add(write_size);
    try_update_stack_pointer(sp, ssp, hp, new_sp, memory)?;

    // Write the registers to the stack
    let mut it = memory
        .write_noownerchecks(write_at, write_size)?
        .chunks_exact_mut(WORD_SIZE);
    for (i, reg) in program_regs.segment(segment).iter().enumerate() {
        if (bitmask & (1 << i)) != 0 {
            let item = it
                .next()
                .expect("Memory range mismatched with register count");
            item.copy_from_slice(&reg.to_be_bytes());
        }
    }

    Ok(inc_pc(pc)?)
}

#[allow(clippy::too_many_arguments)]
pub(crate) fn pop_selected_registers(
    memory: &mut MemoryInstance,
    sp: RegMut<SP>,
    ssp: Reg<SSP>,
    hp: Reg<HP>,
    pc: RegMut<PC>,
    program_regs: &mut ProgramRegisters,
    segment: ProgramRegistersSegment,
    bitmask: Imm24,
) -> SimpleResult<()> {
    let bitmask = bitmask.to_u32();

    // First update the stack pointer, as that's the only error condition
    let count: u64 = bitmask.count_ones().into();
    let size_in_stack = count
        .checked_mul(WORD_SIZE as u64)
        .expect("Bitmask size times 8 can never oveflow");
    let new_sp = sp
        .checked_sub(size_in_stack)
        .ok_or(PanicReason::MemoryOverflow)?;
    try_update_stack_pointer(sp, ssp, hp, new_sp, memory)?;

    // Restore registers from the stack
    let mut it = memory.read(new_sp, size_in_stack)?.chunks_exact(WORD_SIZE);
    for (i, reg) in program_regs.segment_mut(segment).iter_mut().enumerate() {
        if (bitmask & (1 << i)) != 0 {
            let mut buf = [0u8; WORD_SIZE];
            buf.copy_from_slice(it.next().expect("Count mismatch"));
            *reg = Word::from_be_bytes(buf);
        }
    }

    Ok(inc_pc(pc)?)
}

pub(crate) fn load_byte(
    memory: &MemoryInstance,
    pc: RegMut<PC>,
    result: &mut Word,
    b: Word,
    c: Word,
) -> SimpleResult<()> {
    let [b] = memory.read_bytes(b.saturating_add(c))?;
    *result = b as Word;
    Ok(inc_pc(pc)?)
}

pub(crate) fn load_word(
    memory: &MemoryInstance,
    pc: RegMut<PC>,
    result: &mut Word,
    b: Word,
    c: Imm12,
) -> SimpleResult<()> {
    let offset = u64::from(c)
        .checked_mul(WORD_SIZE as u64)
        .expect("u12 * 8 cannot overflow a Word");
    let addr = b.checked_add(offset).ok_or(PanicReason::MemoryOverflow)?;
    *result = Word::from_be_bytes(memory.read_bytes(addr)?);
    Ok(inc_pc(pc)?)
}

#[allow(clippy::cast_possible_truncation)]
pub(crate) fn store_byte(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Word,
) -> SimpleResult<()> {
    memory.write_bytes(owner, a.saturating_add(c), [b as u8])?;
    Ok(inc_pc(pc)?)
}

pub(crate) fn store_word(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
    c: Imm12,
) -> SimpleResult<()> {
    #[allow(clippy::arithmetic_side_effects)]
    let offset = u64::from(c)
        .checked_mul(WORD_SIZE as u64)
        .expect("12-bits number multiplied by 8 cannot overflow a Word");
    let addr = a.saturating_add(offset);
    memory.write_bytes(owner, addr, b.to_be_bytes())?;
    Ok(inc_pc(pc)?)
}

pub(crate) fn malloc(
    hp: RegMut<HP>,
    sp: Reg<SP>,
    pc: RegMut<PC>,
    amount: Word,
    memory: &mut MemoryInstance,
) -> SimpleResult<()> {
    memory.grow_heap_by(sp, hp, amount)?;
    Ok(inc_pc(pc)?)
}

pub(crate) fn memclear(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    a: Word,
    b: Word,
) -> SimpleResult<()> {
    memory.write(owner, a, b)?.fill(0);
    Ok(inc_pc(pc)?)
}

pub(crate) fn memcopy(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    pc: RegMut<PC>,
    dst: Word,
    src: Word,
    length: Word,
) -> SimpleResult<()> {
    memory.memcopy(dst, src, length, owner)?;

    Ok(inc_pc(pc)?)
}

pub(crate) fn memeq(
    memory: &mut MemoryInstance,
    result: &mut Word,
    pc: RegMut<PC>,
    b: Word,
    c: Word,
    d: Word,
) -> SimpleResult<()> {
    *result = (memory.read(b, d)? == memory.read(c, d)?) as Word;
    Ok(inc_pc(pc)?)
}

#[derive(Debug, Clone, Copy)]
pub struct OwnershipRegisters {
    pub(crate) sp: u64,
    pub(crate) ssp: u64,
    pub(crate) hp: u64,
    /// Previous heap pointer, used for external contexts.
    /// Otherwise, it's just memory size.
    pub(crate) prev_hp: u64,
}

impl OwnershipRegisters {
    pub(crate) fn new<M, S, Tx, Ecal>(vm: &Interpreter<M, S, Tx, Ecal>) -> Self {
        let prev_hp = vm
            .frames
            .last()
            .map(|frame| frame.registers()[RegId::HP])
            .unwrap_or(VM_MAX_RAM);

        OwnershipRegisters {
            sp: vm.registers[RegId::SP],
            ssp: vm.registers[RegId::SSP],
            hp: vm.registers[RegId::HP],
            prev_hp,
        }
    }

    /// Create an instance that only allows stack writes.
    pub(crate) fn only_allow_stack_write(sp: u64, ssp: u64, hp: u64) -> Self {
        debug_assert!(sp <= VM_MAX_RAM);
        debug_assert!(ssp <= VM_MAX_RAM);
        debug_assert!(hp <= VM_MAX_RAM);
        debug_assert!(ssp <= sp);
        debug_assert!(sp <= hp);
        OwnershipRegisters {
            sp,
            ssp,
            hp,
            prev_hp: hp,
        }
    }

    /// Allows all writes, whole memory is stack.allocated
    #[cfg(test)]
    pub(crate) fn test_full_stack() -> Self {
        OwnershipRegisters {
            sp: VM_MAX_RAM,
            ssp: 0,
            hp: VM_MAX_RAM,
            prev_hp: VM_MAX_RAM,
        }
    }

    pub(crate) fn verify_ownership(
        &self,
        range: &MemoryRange,
    ) -> Result<(), PanicReason> {
        if self.has_ownership_range(&range.words()) {
            Ok(())
        } else {
            Err(PanicReason::MemoryOwnership)
        }
    }

    pub fn has_ownership_range(&self, range: &Range<Word>) -> bool {
        self.has_ownership_stack(range) || self.has_ownership_heap(range)
    }

    /// Empty range is owned iff the range.start is owned
    pub(crate) fn has_ownership_stack(&self, range: &Range<Word>) -> bool {
        if range.is_empty() && range.start == self.ssp {
            return true
        }

        if !(self.ssp..self.sp).contains(&range.start) {
            return false
        }

        if range.end > VM_MAX_RAM {
            return false
        }

        (self.ssp..=self.sp).contains(&range.end)
    }

    /// Empty range is owned iff the range.start is owned
    pub(crate) fn has_ownership_heap(&self, range: &Range<Word>) -> bool {
        if range.is_empty() && range.start == self.hp {
            return true
        }

        if range.start < self.hp {
            return false
        }

        self.hp != self.prev_hp && range.end <= self.prev_hp
    }
}

/// Attempt copy from slice to memory, filling zero bytes when exceeding slice boundaries.
/// Performs overflow and memory range checks, but no ownership checks.
/// Note that if `src_offset` is larger than `src.len()`, the whole range will be
/// zero-filled.
pub(crate) fn copy_from_slice_zero_fill<A: ToAddr, B: ToAddr>(
    memory: &mut MemoryInstance,
    owner: OwnershipRegisters,
    src: &[u8],
    dst_addr: A,
    src_offset: Word,
    len: B,
) -> SimpleResult<()> {
    let range = memory.write(owner, dst_addr, len)?;

    // Special-case the ranges that are completely out of bounds,
    // to avoid platform-dependenct usize conversion.
    if src_offset >= src.len() as Word {
        range[..].fill(0);
    } else {
        // Safety: since we check above that this is not larger than `src.len()`,
        // which is `usize`, the cast never truncates.
        #[allow(clippy::cast_possible_truncation)]
        let src_offset = src_offset as usize;
        let src_end = src_offset.saturating_add(range.len()).min(src.len());
        let data = src.get(src_offset..src_end).unwrap_or(&[]);

        range[..data.len()].copy_from_slice(data);
        range[data.len()..].fill(0);
    }
    Ok(())
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/blob.rs

Source
use fuel_asm::{
    RegisterId,
    Word,
};
use fuel_storage::StorageSize;
use fuel_tx::PanicReason;
use fuel_types::BlobId;

use crate::{
    error::IoResult,
    prelude::*,
    storage::{
        BlobData,
        InterpreterStorage,
    },
};

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

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    <S as InterpreterStorage>::DataError: From<S::DataError>,
{
    pub(crate) fn blob_size(
        &mut self,
        dst: RegisterId,
        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 = <S as StorageSize<BlobData>>::size_of_value(&self.storage, &blob_id)
            .map_err(RuntimeError::Storage)?
            .ok_or(PanicReason::BlobNotFound)?;

        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;
        Ok(inc_pc(pc)?)
    }

    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 size = <S as StorageSize<BlobData>>::size_of_value(&self.storage, &blob_id)
            .map_err(RuntimeError::Storage)?
            .ok_or(PanicReason::BlobNotFound)?;
        self.dependent_gas_charge_without_base(gas_cost, len.max(size as Word))?;

        let blob = <S as StorageInspect<BlobData>>::get(&self.storage, &blob_id)
            .map_err(RuntimeError::Storage)?
            .ok_or(PanicReason::BlobNotFound)?;
        let blob = blob.as_ref().as_ref();

        copy_from_slice_zero_fill(
            self.memory.as_mut(),
            owner,
            blob,
            dst_ptr,
            blob_offset,
            len,
        )?;

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

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/diff.rs

Source
//! # VM State Differences
//! This module provides the ability to generate diffs between two VMs internal states.
//! The diff can then be used to invert a VM to the original state.
//! This module is experimental work in progress and currently only used in testing
//! although it could potentially stabilize to be used in production.

use alloc::{
    sync::Arc,
    vec::Vec,
};
use core::{
    any::Any,
    fmt::Debug,
    hash::Hash,
    ops::AddAssign,
};
use hashbrown::{
    HashMap,
    HashSet,
};

use fuel_asm::Word;
use fuel_storage::{
    Mappable,
    StorageInspect,
    StorageMutate,
};
use fuel_tx::{
    Contract,
    Receipt,
};
use fuel_types::AssetId;

use crate::{
    call::CallFrame,
    context::Context,
    storage::{
        ContractsAssets,
        ContractsRawCode,
        ContractsState,
    },
};

use super::{
    balances::Balance,
    receipts::ReceiptsCtx,
    ExecutableTransaction,
    Interpreter,
    Memory,
    PanicContext,
};
use storage::*;

mod storage;

#[cfg(test)]
mod tests;

#[derive(Debug, Clone)]
/// A diff of VM state.
///
/// By default this does not print out the
/// memory bytes but you can supply the `#` flag
/// to get them like:
/// ```ignore
/// println!("{:#}", diff);
/// ```
pub struct Diff<T: VmStateCapture + Clone> {
    changes: Vec<Change<T>>,
}

#[derive(Debug, Clone)]
enum Change<T: VmStateCapture + Clone> {
    /// Holds a snapshot of register state.
    Register(T::State<VecState<Word>>),
    /// Holds a snapshot of memory state.
    Memory(T::State<MemoryRegion>),
    /// Holds a snapshot of storage state.
    Storage(T::State<StorageState>),
    /// Holds a snapshot of the call stack.
    Frame(T::State<VecState<Option<CallFrame>>>),
    /// Holds a snapshot of receipt state.
    Receipt(T::State<VecState<Option<Receipt>>>),
    /// Holds a snapshot of balance state.
    Balance(T::State<MapState<AssetId, Option<Balance>>>),
    /// Holds a snapshot of context state.
    Context(T::State<Context>),
    /// Holds a snapshot of the panic context state.
    PanicContext(T::State<PanicContext>),
    /// Holds a snapshot of the transaction state.
    Txn(T::State<Arc<dyn AnyDebug>>),
}

/// A trait that combines the [`Debug`] and [`Any`] traits.
pub trait AnyDebug: Any + Debug {
    /// Returns a reference to the underlying type as `Any`.
    fn as_any_ref(&self) -> &dyn Any;
}

impl<T> AnyDebug for T
where
    T: Any + Debug,
{
    fn as_any_ref(&self) -> &dyn Any {
        self
    }
}

/// A mapping between the kind of state that is being capture
/// and the concrete data that is collected.
pub trait VmStateCapture {
    /// The actual type is defined by the implementations of
    /// the Capture trait.
    type State<S: core::fmt::Debug + Clone>: core::fmt::Debug + Clone;
}

#[derive(Debug, Clone)]
/// Family of state data that are implemented with the [`Delta`]
/// struct. Captures the difference between the current and previous
/// state of the VM.
pub struct Deltas;

impl VmStateCapture for Deltas {
    type State<S: core::fmt::Debug + Clone> = Delta<S>;
}

#[derive(Debug, Clone)]
/// The Delta struct represents the difference between two states of the VM.
pub struct Delta<S> {
    // Represents the state of the VM before a change.
    from: S,
    // Represents the state of the VM after a change.
    to: S,
}

#[derive(Debug, Clone)]
/// Family of state data that are implemented with the [`Previous`]
/// struct. Captures the initial state of the VM.
pub struct InitialVmState;

impl VmStateCapture for InitialVmState {
    type State<S: core::fmt::Debug + Clone> = Previous<S>;
}
#[derive(Debug, Clone)]
/// The State type when capturing the initial state of the VM.
pub struct Previous<S>(S);

#[derive(Debug, Clone)]
/// The state of a vector at an index.
struct VecState<T> {
    /// Index of the value.
    index: usize,
    /// Value at the index.
    value: T,
}

#[derive(Debug, Clone)]
/// The state of a map at a key.
struct MapState<K, V>
where
    K: Hash,
    V: PartialEq,
{
    /// Key of the value.
    key: K,
    /// Value at the key.
    value: V,
}

#[derive(Clone)]
/// The state of a memory region.
struct MemoryRegion {
    /// The start of the memory region.
    start: usize,
    /// The region of bytes.
    bytes: Vec<u8>,
}

impl Debug for MemoryRegion {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if f.alternate() {
            f.debug_struct("Memory")
                .field("start", &self.start)
                .field("bytes", &self.bytes)
                .finish()
        } else {
            f.debug_struct("Memory")
                .field("start", &self.start)
                .field("bytes", &self.bytes.len())
                .finish()
        }
    }
}

fn capture_buffer_state<'iter, I, T>(
    a: I,
    b: I,
    change: fn(Delta<VecState<T>>) -> Change<Deltas>,
) -> impl Iterator<Item = Change<Deltas>> + 'iter
where
    T: 'static + core::cmp::PartialEq + Clone,
    I: Iterator<Item = &'iter T> + 'iter,
{
    a.enumerate()
        .zip(b)
        .filter(|&(a, b)| (a.1 != b))
        .map(move |(a, b)| {
            change(Delta {
                from: VecState {
                    index: a.0,
                    value: a.1.clone(),
                },
                to: VecState {
                    index: a.0,
                    value: b.clone(),
                },
            })
        })
}

type ChangeDeltaVariant<S> = fn(Delta<S>) -> Change<Deltas>;

fn capture_map_state<'iter, K, V>(
    a: &'iter HashMap<K, V>,
    b: &'iter HashMap<K, V>,
    change: ChangeDeltaVariant<MapState<K, Option<V>>>,
) -> Vec<Change<Deltas>>
where
    K: 'static + PartialEq + Eq + Clone + Hash + Debug,
    V: 'static + core::cmp::PartialEq + Clone + Debug,
{
    let a_keys: HashSet<_> = a.keys().collect();
    let b_keys: HashSet<_> = b.keys().collect();
    capture_map_state_inner(a, &a_keys, b, &b_keys)
        .map(change)
        .collect()
}

fn capture_map_state_inner<'iter, K, V>(
    a: &'iter HashMap<K, V>,
    a_keys: &'iter HashSet<&K>,
    b: &'iter HashMap<K, V>,
    b_keys: &'iter HashSet<&K>,
) -> impl Iterator<Item = Delta<MapState<K, Option<V>>>> + 'iter
where
    K: 'static + PartialEq + Eq + Clone + Hash + Debug,
    V: 'static + core::cmp::PartialEq + Clone + Debug,
{
    let a_diff = a_keys.difference(b_keys).map(|k| Delta {
        from: MapState {
            key: (*k).clone(),
            value: Some(a[*k].clone()),
        },
        to: MapState {
            key: (*k).clone(),
            value: None,
        },
    });
    let b_diff = b_keys.difference(a_keys).map(|k| Delta {
        from: MapState {
            key: (*k).clone(),
            value: None,
        },
        to: MapState {
            key: (*k).clone(),
            value: Some(b[*k].clone()),
        },
    });
    let intersection = a_keys.intersection(b_keys).filter_map(|k| {
        let value_a = &a[*k];
        let value_b = &b[*k];
        (value_a != value_b).then(|| Delta {
            from: MapState {
                key: (*k).clone(),
                value: Some(value_a.clone()),
            },
            to: MapState {
                key: (*k).clone(),
                value: Some(value_b.clone()),
            },
        })
    });

    a_diff.chain(b_diff).chain(intersection)
}

fn capture_vec_state<'iter, I, T>(
    a: I,
    b: I,
    change: ChangeDeltaVariant<VecState<Option<T>>>,
) -> impl Iterator<Item = Change<Deltas>> + 'iter
where
    T: 'static + core::cmp::PartialEq + Clone,
    I: Iterator<Item = &'iter T> + 'iter,
{
    capture_vec_state_inner(a, b).map(move |(index, a, b)| {
        change(Delta {
            from: VecState { index, value: a },
            to: VecState { index, value: b },
        })
    })
}
fn capture_vec_state_inner<'iter, I, T>(
    a: I,
    b: I,
) -> impl Iterator<Item = (usize, Option<T>, Option<T>)> + 'iter
where
    T: 'static + core::cmp::PartialEq + Clone,
    I: Iterator<Item = &'iter T> + 'iter,
{
    a.map(Some)
        .chain(core::iter::repeat(None))
        .enumerate()
        .zip(b.map(Some).chain(core::iter::repeat(None)))
        .take_while(|((_, a), b)| a.is_some() || b.is_some())
        .filter(|((_, a), b)| b.map_or(true, |b| a.map_or(true, |a| a != b)))
        .map(|((index, a), b)| (index, a.cloned(), b.cloned()))
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
{
    /// The diff function generates a diff of VM state, represented by the Diff struct,
    /// between two VMs internal states.
    pub fn diff(&self, other: &Self) -> Diff<Deltas>
    where
        Tx: PartialEq + Clone + Debug + 'static,
    {
        let mut diff = Diff {
            changes: Vec::new(),
        };
        let registers = capture_buffer_state(
            self.registers.iter(),
            other.registers.iter(),
            Change::Register,
        );
        diff.changes.extend(registers);
        let frames =
            capture_vec_state(self.frames.iter(), other.frames.iter(), Change::Frame);
        diff.changes.extend(frames);
        let receipts = capture_vec_state(
            self.receipts.as_ref().iter(),
            other.receipts.as_ref().iter(),
            Change::Receipt,
        );
        diff.changes.extend(receipts);
        let balances = capture_map_state(
            self.balances.as_ref(),
            other.balances.as_ref(),
            Change::Balance,
        );
        diff.changes.extend(balances);

        let other_memory = other.memory().clone().into_linear_memory();
        let this_memory = self.memory().clone().into_linear_memory();

        let mut memory = this_memory.iter().enumerate().zip(other_memory.iter());

        while let Some(((start, s_from), s_to)) = memory
            .by_ref()
            .find(|((_, a), b)| a != b)
            .map(|((n, a), b)| ((n, *a), *b))
        {
            let (mut from, mut to): (Vec<_>, Vec<_>) = memory
                .by_ref()
                .take_while(|((_, a), b)| a != b)
                .map(|((_, a), b)| (*a, *b))
                .unzip();
            from.splice(..0, core::iter::once(s_from)).next();
            to.splice(..0, core::iter::once(s_to)).next();
            diff.changes.push(Change::Memory(Delta {
                from: MemoryRegion { start, bytes: from },
                to: MemoryRegion { start, bytes: to },
            }));
        }

        if self.context != other.context {
            diff.changes.push(Change::Context(Delta {
                from: self.context.clone(),
                to: other.context.clone(),
            }))
        }

        if self.panic_context != other.panic_context {
            diff.changes.push(Change::PanicContext(Delta {
                from: self.panic_context.clone(),
                to: other.panic_context.clone(),
            }))
        }

        if self.tx != other.tx {
            let from: Arc<dyn AnyDebug> = Arc::new(self.tx.clone());
            let to: Arc<dyn AnyDebug> = Arc::new(other.tx.clone());
            diff.changes.push(Change::Txn(Delta { from, to }))
        }

        diff
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
{
    fn inverse_inner(&mut self, change: &Change<InitialVmState>)
    where
        Tx: Clone + 'static,
    {
        match change {
            Change::Register(Previous(VecState { index, value })) => {
                self.registers[*index] = *value
            }
            Change::Frame(Previous(value)) => invert_vec(&mut self.frames, value),
            Change::Receipt(Previous(value)) => {
                invert_receipts_ctx(&mut self.receipts, value)
            }
            Change::Balance(Previous(value)) => invert_map(self.balances.as_mut(), value),
            Change::Memory(Previous(MemoryRegion { start, bytes })) => self
                .memory_mut()
                .write_noownerchecks(*start, bytes.len())
                .expect("Memory must exist here")
                .copy_from_slice(&bytes[..]),
            Change::Context(Previous(value)) => self.context = value.clone(),
            Change::PanicContext(Previous(value)) => self.panic_context = value.clone(),
            Change::Txn(Previous(tx)) => {
                self.tx = AsRef::<dyn AnyDebug>::as_ref(tx)
                    .as_any_ref()
                    .downcast_ref::<Tx>()
                    .unwrap()
                    .clone();
            }
            Change::Storage(_) => (),
        }
    }
}

fn invert_vec<T: Clone>(vector: &mut Vec<T>, value: &VecState<Option<T>>) {
    use core::cmp::Ordering;
    match (&value, value.index.cmp(&vector.len())) {
        (
            VecState {
                index,
                value: Some(value),
            },
            Ordering::Equal | Ordering::Greater,
        ) => {
            vector.resize((*index).saturating_add(1), value.clone());
            vector[*index] = value.clone();
        }
        (
            VecState {
                index,
                value: Some(value),
            },
            Ordering::Less,
        ) => vector[*index] = value.clone(),
        (VecState { value: None, .. }, Ordering::Equal | Ordering::Greater) => (),
        (VecState { index, value: None }, Ordering::Less) => vector.truncate(*index),
    }
}

fn invert_map<K: Hash + PartialEq + Eq + Clone, V: Clone + PartialEq>(
    map: &mut HashMap<K, V>,
    value: &MapState<K, Option<V>>,
) {
    match value {
        MapState {
            key,
            value: Some(value),
        } => {
            map.insert(key.clone(), value.clone());
        }
        MapState { key, value: None } => {
            map.remove(key);
        }
    }
}

fn invert_receipts_ctx(ctx: &mut ReceiptsCtx, value: &VecState<Option<Receipt>>) {
    let mut ctx_mut = ctx.lock();
    invert_vec(ctx_mut.receipts_mut(), value);
}

impl<M, S, Tx, Ecal> PartialEq for Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: PartialEq,
{
    /// Does not compare storage, debugger or profiler
    fn eq(&self, other: &Self) -> bool {
        self.registers == other.registers
            && self.memory.as_ref() == other.memory.as_ref()
            && self.frames == other.frames
            && self.receipts == other.receipts
            && self.tx == other.tx
            && self.initial_balances == other.initial_balances
            && self.context == other.context
            && self.balances == other.balances
            && self.interpreter_params == other.interpreter_params
            && self.panic_context == other.panic_context
    }
}

impl From<Diff<Deltas>> for Diff<InitialVmState> {
    fn from(d: Diff<Deltas>) -> Self {
        Self {
            changes: d
                .changes
                .into_iter()
                .map(|c| match c {
                    Change::Register(v) => Change::Register(v.into()),
                    Change::Memory(v) => Change::Memory(v.into()),
                    Change::Storage(v) => Change::Storage(v.into()),
                    Change::Frame(v) => Change::Frame(v.into()),
                    Change::Receipt(v) => Change::Receipt(v.into()),
                    Change::Balance(v) => Change::Balance(v.into()),
                    Change::Context(v) => Change::Context(v.into()),
                    Change::PanicContext(v) => Change::PanicContext(v.into()),
                    Change::Txn(v) => Change::Txn(v.into()),
                })
                .collect(),
        }
    }
}

impl<T> From<Delta<T>> for Previous<T> {
    fn from(d: Delta<T>) -> Self {
        Self(d.from)
    }
}

impl<T: VmStateCapture + Clone> AddAssign for Diff<T> {
    fn add_assign(&mut self, rhs: Self) {
        self.changes.extend(rhs.changes);
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/diff/storage.rs

Source
use core::fmt::Debug;
use hashbrown::HashMap;

use fuel_storage::{
    StorageRead,
    StorageSize,
    StorageWrite,
};
use fuel_tx::ConsensusParameters;
use fuel_types::{
    BlobId,
    BlockHeight,
    Bytes32,
    ContractId,
};

use crate::storage::{
    BlobBytes,
    BlobData,
    ContractsAssetKey,
    ContractsAssetsStorage,
    ContractsStateData,
    ContractsStateKey,
    InterpreterStorage,
    UploadedBytecode,
    UploadedBytecodes,
};

use super::{
    ExecutableTransaction,
    Interpreter,
    *,
};

#[derive(Debug)]
/// The set of state changes that are recorded.
pub(super) enum StorageDelta {
    State(MappableDelta<ContractsStateKey, ContractsStateData>),
    Assets(MappableDelta<ContractsAssetKey, u64>),
    RawCode(MappableDelta<ContractId, Contract>),
    UploadedBytecode(MappableDelta<Bytes32, UploadedBytecode>),
    BlobData(MappableDelta<BlobId, BlobBytes>),
}

/// The set of states that are recorded.
#[derive(Debug, Clone)]
pub(super) enum StorageState {
    State(MappableState<ContractsStateKey, ContractsStateData>),
    Assets(MappableState<ContractsAssetKey, u64>),
    RawCode(MappableState<ContractId, Contract>),
    UploadedBytecode(MappableState<Bytes32, UploadedBytecode>),
    BlobData(MappableState<BlobId, BlobBytes>),
}

#[derive(Debug)]
/// A [`Mappable`] type that has changed.
pub(super) enum MappableDelta<Key, Value> {
    Replace(Key, Value, Option<Value>),
    Take(Key, Value),
}

/// The state of a [`Mappable`] type.
#[derive(Debug, Clone)]
pub(super) struct MappableState<Key, Value> {
    pub key: Key,
    pub value: Option<Value>,
}

/// Records state changes of any [`Mappable`] type.
pub(super) trait StorageType: Mappable {
    /// Records a replace state change.
    fn record_replace(
        key: &Self::Key,
        value: &Self::Value,
        existing: Option<Self::OwnedValue>,
    ) -> StorageDelta;

    /// Records a take state change.
    fn record_take(key: &Self::Key, value: Self::OwnedValue) -> StorageDelta;
}

#[derive(Debug)]
pub struct Record<S>(pub(super) S, pub(super) Vec<StorageDelta>)
where
    S: InterpreterStorage;

impl<M, S, Tx, Ecal> Interpreter<M, Record<S>, Tx, Ecal>
where
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
{
    /// Remove the [`Recording`] wrapper from the storage.
    /// Recording storage changes has an overhead so it's
    /// useful to be able to remove it once the diff is generated.
    pub fn remove_recording(self) -> Interpreter<M, S, Tx, Ecal> {
        Interpreter {
            registers: self.registers,
            memory: self.memory,
            frames: self.frames,
            receipts: self.receipts,
            tx: self.tx,
            initial_balances: self.initial_balances,
            input_contracts: self.input_contracts,
            input_contracts_index_to_output_index: self
                .input_contracts_index_to_output_index,
            storage: self.storage.0,
            debugger: self.debugger,
            context: self.context,
            balances: self.balances,
            panic_context: self.panic_context,
            profiler: self.profiler,
            interpreter_params: self.interpreter_params,
            ecal_state: self.ecal_state,
        }
    }

    /// Get the diff of changes to this VMs storage.
    pub fn storage_diff(&self) -> Diff<Deltas> {
        let mut diff = Diff {
            changes: Vec::new(),
        };
        let mut contracts_state = Delta {
            from: HashMap::new(),
            to: HashMap::new(),
        };
        let mut contracts_assets = Delta {
            from: HashMap::new(),
            to: HashMap::new(),
        };
        let mut contracts_raw_code = Delta {
            from: HashMap::new(),
            to: HashMap::new(),
        };
        let mut uploaded_bytecode: Delta<HashMap<Bytes32, &UploadedBytecode>> = Delta {
            from: HashMap::new(),
            to: HashMap::new(),
        };
        let mut blob_data = Delta {
            from: HashMap::new(),
            to: HashMap::new(),
        };

        for delta in self.storage.1.iter() {
            match delta {
                StorageDelta::State(delta) => {
                    mappable_delta_to_hashmap(&mut contracts_state, delta)
                }
                StorageDelta::Assets(delta) => {
                    mappable_delta_to_hashmap(&mut contracts_assets, delta)
                }
                StorageDelta::RawCode(delta) => {
                    mappable_delta_to_hashmap(&mut contracts_raw_code, delta)
                }
                StorageDelta::UploadedBytecode(delta) => {
                    mappable_delta_to_hashmap(&mut uploaded_bytecode, delta)
                }
                StorageDelta::BlobData(delta) => {
                    mappable_delta_to_hashmap(&mut blob_data, delta)
                }
            }
        }
        storage_state_to_changes(&mut diff, contracts_state, StorageState::State);
        storage_state_to_changes(&mut diff, contracts_assets, StorageState::Assets);
        storage_state_to_changes(&mut diff, contracts_raw_code, StorageState::RawCode);
        storage_state_to_changes(
            &mut diff,
            uploaded_bytecode,
            StorageState::UploadedBytecode,
        );
        storage_state_to_changes(&mut diff, blob_data, StorageState::BlobData);
        diff
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    Tx: ExecutableTransaction,
{
    /// Add a [`Recording`] wrapper around the storage to
    /// record any changes this VM makes to it's storage.
    /// Recording storage changes has an overhead so should
    /// be used in production.
    pub fn add_recording(self) -> Interpreter<M, Record<S>, Tx, Ecal> {
        Interpreter {
            registers: self.registers,
            memory: self.memory,
            frames: self.frames,
            receipts: self.receipts,
            tx: self.tx,
            initial_balances: self.initial_balances,
            input_contracts: self.input_contracts,
            input_contracts_index_to_output_index: self
                .input_contracts_index_to_output_index,
            storage: Record::new(self.storage),
            debugger: self.debugger,
            context: self.context,
            balances: self.balances,
            panic_context: self.panic_context,
            profiler: self.profiler,
            interpreter_params: self.interpreter_params,
            ecal_state: self.ecal_state,
        }
    }

    /// Change this VMs internal state to match the initial state from this diff.
    pub fn reset_vm_state(&mut self, diff: &Diff<InitialVmState>)
    where
        Tx: Clone + 'static,
    {
        for change in &diff.changes {
            self.inverse_inner(change);
            if let Change::Storage(Previous(from)) = change {
                match from {
                    StorageState::State(MappableState { key, value }) => {
                        if let Some(value) = value {
                            StorageMutate::<ContractsState>::insert(
                                &mut self.storage,
                                key,
                                value.as_ref(),
                            )
                            .unwrap();
                        }
                    }
                    StorageState::Assets(MappableState { key, value }) => {
                        if let Some(value) = value {
                            StorageMutate::<ContractsAssets>::insert(
                                &mut self.storage,
                                key,
                                value,
                            )
                            .unwrap();
                        }
                    }
                    StorageState::RawCode(MappableState { key, value }) => {
                        if let Some(value) = value {
                            StorageMutate::<ContractsRawCode>::insert(
                                &mut self.storage,
                                key,
                                value.as_ref(),
                            )
                            .unwrap();
                        }
                    }
                    StorageState::UploadedBytecode(MappableState { key, value }) => {
                        if let Some(value) = value {
                            StorageMutate::<UploadedBytecodes>::insert(
                                &mut self.storage,
                                key,
                                value,
                            )
                            .unwrap();
                        }
                    }
                    StorageState::BlobData(MappableState { key, value }) => {
                        if let Some(value) = value {
                            StorageMutate::<BlobData>::insert(
                                &mut self.storage,
                                key,
                                value.as_ref(),
                            )
                            .unwrap();
                        }
                    }
                }
            }
        }
    }
}

fn mappable_delta_to_hashmap<'value, K, V>(
    state: &mut Delta<HashMap<K, &'value V>>,
    delta: &'value MappableDelta<K, V>,
) where
    K: Copy + PartialEq + Eq + core::hash::Hash + 'static,
    V: Clone + 'static,
{
    match delta {
        MappableDelta::Replace(key, value, Some(existing)) => {
            state.from.entry(*key).or_insert(existing);
            state.to.insert(*key, value);
        }
        MappableDelta::Replace(key, value, None) => {
            state.to.insert(*key, value);
        }
        MappableDelta::Take(key, existing) => {
            state.from.entry(*key).or_insert(existing);
            state.to.remove(key);
        }
    }
}

fn storage_state_to_changes<K, V>(
    diff: &mut Diff<Deltas>,
    state: Delta<HashMap<K, &V>>,
    f: fn(MappableState<K, V>) -> StorageState,
) where
    K: Copy + PartialEq + Eq + Hash + 'static,
    V: Clone + 'static,
{
    let Delta { mut from, to } = state;
    let iter = to.into_iter().map(|(k, v)| {
        Change::Storage(Delta {
            from: f(MappableState {
                key: k,
                value: from.remove(&k).cloned(),
            }),
            to: f(MappableState {
                key: k,
                value: Some(v.clone()),
            }),
        })
    });
    diff.changes.extend(iter);
    let iter = from.into_iter().map(|(k, v)| {
        Change::Storage(Delta {
            from: f(MappableState {
                key: k,
                value: Some(v.clone()),
            }),
            to: f(MappableState {
                key: k,
                value: None,
            }),
        })
    });
    diff.changes.extend(iter);
}

impl<Type: Mappable, S> StorageInspect<Type> for Record<S>
where
    S: StorageInspect<Type>,
    S: InterpreterStorage,
{
    type Error = <S as StorageInspect<Type>>::Error;

    fn get(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<alloc::borrow::Cow<<Type as Mappable>::OwnedValue>>, Self::Error>
    {
        <S as StorageInspect<Type>>::get(&self.0, key)
    }

    fn contains_key(&self, key: &<Type as Mappable>::Key) -> Result<bool, Self::Error> {
        <S as StorageInspect<Type>>::contains_key(&self.0, key)
    }
}

impl<Type: Mappable, S> StorageSize<Type> for Record<S>
where
    S: StorageSize<Type>,
    S: InterpreterStorage,
{
    fn size_of_value(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<usize>, Self::Error> {
        <S as StorageSize<Type>>::size_of_value(&self.0, key)
    }
}

impl<Type: Mappable, S> StorageRead<Type> for Record<S>
where
    S: StorageRead<Type>,
    S: InterpreterStorage,
{
    fn read(
        &self,
        key: &<Type as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        <S as StorageRead<Type>>::read(&self.0, key, buf)
    }

    fn read_alloc(
        &self,
        key: &<Type as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        <S as StorageRead<Type>>::read_alloc(&self.0, key)
    }
}

impl<Type: StorageType, S> StorageMutate<Type> for Record<S>
where
    S: StorageInspect<Type>,
    S: StorageMutate<Type>,
    S: InterpreterStorage,
{
    fn replace(
        &mut self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
        let existing = <S as StorageMutate<Type>>::replace(&mut self.0, key, value)?;
        self.1.push(<Type as StorageType>::record_replace(
            key,
            value,
            existing.clone(),
        ));
        Ok(existing)
    }

    fn take(&mut self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, Self::Error> {
        let existing = <S as StorageMutate<Type>>::take(&mut self.0, key)?;
        if let Some(existing) = &existing {
            self.1
                .push(<Type as StorageType>::record_take(key, existing.clone()));
        }
        Ok(existing)
    }
}

impl<Type: StorageType, S> StorageWrite<Type> for Record<S>
where
    S: StorageWrite<Type>,
    S: InterpreterStorage,
{
    fn write_bytes(&mut self, key: &Type::Key, buf: &[u8]) -> Result<usize, Self::Error> {
        <S as StorageWrite<Type>>::write_bytes(&mut self.0, key, buf)
    }

    fn replace_bytes(
        &mut self,
        key: &Type::Key,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error> {
        <S as StorageWrite<Type>>::replace_bytes(&mut self.0, key, buf)
    }

    fn take_bytes(&mut self, key: &Type::Key) -> Result<Option<Vec<u8>>, Self::Error> {
        <S as StorageWrite<Type>>::take_bytes(&mut self.0, key)
    }
}

impl<S: ContractsAssetsStorage + InterpreterStorage> ContractsAssetsStorage
    for Record<S>
{
}

impl<S> InterpreterStorage for Record<S>
where
    S: InterpreterStorage,
{
    type DataError = <S as InterpreterStorage>::DataError;

    fn block_height(&self) -> Result<BlockHeight, Self::DataError> {
        self.0.block_height()
    }

    fn consensus_parameters_version(&self) -> Result<u32, Self::DataError> {
        self.0.consensus_parameters_version()
    }

    fn state_transition_version(&self) -> Result<u32, Self::DataError> {
        self.0.state_transition_version()
    }

    fn timestamp(&self, height: BlockHeight) -> Result<Word, Self::DataError> {
        self.0.timestamp(height)
    }

    fn block_hash(&self, block_height: BlockHeight) -> Result<Bytes32, Self::DataError> {
        self.0.block_hash(block_height)
    }

    fn coinbase(&self) -> Result<fuel_types::ContractId, Self::DataError> {
        self.0.coinbase()
    }

    fn set_consensus_parameters(
        &mut self,
        version: u32,
        consensus_parameters: &ConsensusParameters,
    ) -> Result<Option<ConsensusParameters>, Self::DataError> {
        self.0
            .set_consensus_parameters(version, consensus_parameters)
    }

    fn set_state_transition_bytecode(
        &mut self,
        version: u32,
        hash: &Bytes32,
    ) -> Result<Option<Bytes32>, Self::DataError> {
        self.0.set_state_transition_bytecode(version, hash)
    }

    fn contract_state_range(
        &self,
        id: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Vec<Option<alloc::borrow::Cow<ContractsStateData>>>, Self::DataError>
    {
        self.0.contract_state_range(id, start_key, range)
    }

    fn contract_state_insert_range<'a, I>(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        values: I,
    ) -> Result<usize, Self::DataError>
    where
        I: Iterator<Item = &'a [u8]>,
    {
        self.0
            .contract_state_insert_range(contract, start_key, values)
    }

    fn contract_state_remove_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Option<()>, S::DataError> {
        self.0
            .contract_state_remove_range(contract, start_key, range)
    }
}

impl StorageType for ContractsState {
    fn record_replace(
        key: &Self::Key,
        value: &[u8],
        existing: Option<ContractsStateData>,
    ) -> StorageDelta {
        StorageDelta::State(MappableDelta::Replace(*key, value.into(), existing))
    }

    fn record_take(key: &Self::Key, value: ContractsStateData) -> StorageDelta {
        StorageDelta::State(MappableDelta::Take(*key, value))
    }
}

impl StorageType for ContractsAssets {
    fn record_replace(
        key: &Self::Key,
        value: &u64,
        existing: Option<u64>,
    ) -> StorageDelta {
        StorageDelta::Assets(MappableDelta::Replace(*key, *value, existing))
    }

    fn record_take(key: &Self::Key, value: u64) -> StorageDelta {
        StorageDelta::Assets(MappableDelta::Take(*key, value))
    }
}

impl StorageType for ContractsRawCode {
    fn record_replace(
        key: &ContractId,
        value: &[u8],
        existing: Option<Contract>,
    ) -> StorageDelta {
        StorageDelta::RawCode(MappableDelta::Replace(*key, value.into(), existing))
    }

    fn record_take(key: &ContractId, value: Contract) -> StorageDelta {
        StorageDelta::RawCode(MappableDelta::Take(*key, value))
    }
}

impl StorageType for UploadedBytecodes {
    fn record_replace(
        key: &Bytes32,
        value: &UploadedBytecode,
        existing: Option<UploadedBytecode>,
    ) -> StorageDelta {
        StorageDelta::UploadedBytecode(MappableDelta::Replace(
            *key,
            value.clone(),
            existing,
        ))
    }

    fn record_take(key: &Bytes32, value: UploadedBytecode) -> StorageDelta {
        StorageDelta::UploadedBytecode(MappableDelta::Take(*key, value))
    }
}

impl StorageType for BlobData {
    fn record_replace(
        key: &BlobId,
        value: &[u8],
        existing: Option<BlobBytes>,
    ) -> StorageDelta {
        StorageDelta::BlobData(MappableDelta::Replace(*key, value.into(), existing))
    }

    fn record_take(key: &BlobId, value: BlobBytes) -> StorageDelta {
        StorageDelta::BlobData(MappableDelta::Take(*key, value))
    }
}
impl<S> Record<S>
where
    S: InterpreterStorage,
{
    pub fn new(s: S) -> Self {
        Self(s, Vec::new())
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/alu/muldiv.rs

Source
use super::super::{
    internal::inc_pc,
    is_wrapping,
    ExecutableTransaction,
    Interpreter,
};
use crate::{
    constraints::reg_key::*,
    error::SimpleResult,
};

use fuel_asm::PanicReason;
use fuel_types::{
    RegisterId,
    Word,
};

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    Tx: ExecutableTransaction,
{
    /// Stores the overflowed wrapped value into RegId::OF
    pub(crate) fn alu_muldiv(
        &mut self,
        ra: RegisterId,
        lhs: Word,
        rhs: Word,
        divider: Word,
    ) -> SimpleResult<()> {
        let (
            SystemRegisters {
                flag,
                mut of,
                mut err,
                pc,
                ..
            },
            mut w,
        ) = split_registers(&mut self.registers);
        let dest = &mut w[ra.try_into()?];

        let (result, overflow) = muldiv(lhs, rhs, divider);

        if overflow != 0 && !is_wrapping(flag.into()) {
            return Err(PanicReason::ArithmeticOverflow.into())
        }

        *of = overflow;
        *err = 0;
        *dest = result;

        inc_pc(pc)?;
        Ok(())
    }
}

/// Fused multiply-divide with arbitrary precision intermediate result.
/// Returns `(result, overflow)`.
/// Divider 0 is treated as `1<<64`.
#[allow(clippy::cast_possible_truncation)]
pub(crate) fn muldiv(lhs: u64, rhs: u64, divider: u64) -> (u64, u64) {
    // Widen all inputs so we never overflow
    let lhs = lhs as u128;
    let rhs = rhs as u128;
    let divider = divider as u128;

    // Compute intermediate result
    let intermediate = lhs
        .checked_mul(rhs)
        .expect("Cannot overflow as we have enough bits");

    // Divide
    if let Some(result) = intermediate.checked_div(divider) {
        // We want to truncate the `result` here and return a non-empty `overflow`.
        (result as u64, (result >> 64) as u64)
    } else {
        ((intermediate >> 64) as u64, 0)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[rstest::rstest]
    #[case(0, 0, 0, 0, 0)]
    #[case(0, 0, 1, 0, 0)]
    #[case(0, 5, 1, 0, 0)]
    #[case(9, 9, 1, 81, 0)]
    #[case(9, 9, 2, 40, 0)]
    #[case(9, 9, 3, 27, 0)]
    #[case(9, 9, 4, 20, 0)]
    #[case(u64::MAX, 5, 10, u64::MAX / 2, 0)]
    #[case(u64::MAX, 2, 6, u64::MAX / 3, 0)]
    #[case(u64::MAX, u64::MAX, u64::MAX, u64::MAX, 0)]
    #[case(u64::MAX, 4, 2, 0xfffffffffffffffe, 1)]
    #[case(u64::MAX, 3, 2, 0x7ffffffffffffffe, 1)]
    fn fused_muldiv(
        #[case] lhs: u64,
        #[case] rhs: u64,
        #[case] divisor: u64,
        #[case] expected: u64,
        #[case] expected_overflow: u64,
    ) {
        let (result, overflow) = muldiv(lhs, rhs, divisor);
        assert_eq!(result, expected);
        assert_eq!(overflow, expected_overflow);
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/alu/wideint.rs

Source
use ethnum::U256;

use fuel_asm::{
    wideint::*,
    PanicReason,
};
use fuel_types::{
    RegisterId,
    Word,
};

use super::super::{
    internal::inc_pc,
    is_unsafe_math,
    is_wrapping,
    ExecutableTransaction,
    Interpreter,
};
use crate::{
    constraints::reg_key::*,
    error::SimpleResult,
    interpreter::Memory,
};

// This macro is used to duplicate the implementation for both 128-bit and 256-bit
// versions. It takes two type parameters: the current type and type that has double-width
// of it. The appropriate type is chosen based on benchmarks for each operation.
// Currently, `primitive_types` is used for anything requiring division, modulo or 512-bit
// precision. Otherwise, `ethnum` is used for 256-bit operations, and the builtin `u128`
// for 128-bit operations.
macro_rules! wideint_ops {
    ($t:ident, $wider_t:ident) => {
        paste::paste! {
            // Conversion helpers

            /// Converts to `primitive_types` version of the current type
            fn [<to_prim_ $t:lower>](value: $t) -> primitive_types::[<$t:upper>] {
                let mut buffer = [0u8; core::mem::size_of::<$t>()];
                buffer[..].copy_from_slice(&value.to_le_bytes());
                primitive_types::[<$t:upper>]::from_little_endian(&buffer)
            }

            /// Converts to `primitive_types` version that has double the size of the current type
            fn [<to_wider_prim_ $t:lower>](value: $t) -> primitive_types::[<$wider_t:upper>] {
                let mut buffer = [0u8; 2 * core::mem::size_of::<$t>()];
                buffer[..core::mem::size_of::<$t>()].copy_from_slice(&value.to_le_bytes());
                primitive_types::[<$wider_t:upper>]::from_little_endian(&buffer)
            }

            /// Converts to `u128` or `ethnum::U256`
            fn [<from_prim_ $t:lower>](value: primitive_types::[<$t:upper>]) -> $t {
                let mut buffer = [0u8; ::core::mem::size_of::<$t>()];
                value.to_little_endian(&mut buffer);
                $t::from_le_bytes(buffer)
            }

            /// Drops higher half of the value and converts to `u128` or `ethnum::U256`
            fn [<truncate_from_prim_ $t:lower>](value: primitive_types::[<$wider_t:upper>]) -> $t {
                const S: usize = ::core::mem::size_of::<$t>();
                let mut buffer = [0u8; 2 * S];
                value.to_little_endian(&mut buffer);
                let truncated: [u8; S] = buffer[..S].try_into().unwrap_or_else(|_| unreachable!());
                $t::from_le_bytes(truncated)
            }

            impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
            where
                M: Memory,
                Tx: ExecutableTransaction,
            {
                pub(crate) fn [<alu_wideint_cmp_ $t:lower>](
                    &mut self,
                    ra: RegisterId,
                    b: Word,
                    c: Word,
                    args: CompareArgs,
                ) -> SimpleResult<()> {

                    let (SystemRegisters { mut of, mut err, pc, .. }, mut w) = split_registers(&mut self.registers);
                    let dest: &mut Word = &mut w[ra.try_into()?];

                    // LHS argument is always indirect, load it
                    let lhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?);

                    // RHS is only indirect if the flag is set
                    let rhs: $t = if args.indirect_rhs {
                        $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?)
                    } else {
                        c.into()
                    };

                    *dest = [<cmp_ $t:lower>](lhs, rhs, args.mode);
                    *of = 0;
                    *err = 0;

                    inc_pc(pc)?;
                    Ok(())
                }

                pub(crate) fn [<alu_wideint_op_ $t:lower>](
                    &mut self,
                    dest_addr: Word,
                    b: Word,
                    c: Word,
                    args: MathArgs,
                ) -> SimpleResult<()> {
                    let owner_regs = self.ownership_registers();
                    let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);

                    // LHS argument is always indirect, load it
                    let lhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?);

                    // RHS is only indirect if the flag is set
                    let rhs: $t = if args.indirect_rhs {
                        $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?)
                    } else {
                        c.into()
                    };

                    let (wrapped, overflow) = [<op_overflowing_ $t:lower>](lhs, rhs, args);

                    if overflow && !is_wrapping(flag.into()) {
                        return Err(PanicReason::ArithmeticOverflow.into());
                    }

                    *of = overflow as Word;
                    *err = 0;

                    self.memory.as_mut().write_bytes(owner_regs, dest_addr, wrapped.to_be_bytes())?;

                    Ok(inc_pc(pc)?)
                }

                pub(crate) fn [<alu_wideint_mul_ $t:lower>](
                    &mut self,
                    dest_addr: Word,
                    b: Word,
                    c: Word,
                    args: MulArgs,
                ) -> SimpleResult<()> {
                    let owner_regs = self.ownership_registers();
                    let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);

                    // LHS is only indirect if the flag is set
                    let lhs: $t = if args.indirect_lhs {
                        $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?)
                    } else {
                        b.into()
                    };
                    // RHS is only indirect if the flag is set
                    let rhs: $t = if args.indirect_rhs {
                        $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?)
                    } else {
                        c.into()
                    };

                    let (wrapped, overflow) = $t::overflowing_mul(lhs, rhs);

                    if overflow && !is_wrapping(flag.into()) {
                        return Err(PanicReason::ArithmeticOverflow.into());
                    }

                    *of = overflow as Word;
                    *err = 0;

                    self.memory.as_mut().write_bytes(owner_regs, dest_addr, wrapped.to_be_bytes())?;

                    Ok(inc_pc(pc)?)
                }

                pub(crate) fn [<alu_wideint_div_ $t:lower>](
                    &mut self,
                    dest_addr: Word,
                    b: Word,
                    c: Word,
                    args: DivArgs,
                ) -> SimpleResult<()> {
                    let owner_regs = self.ownership_registers();
                    let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);

                    // LHS is always indirect
                    let lhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?);

                    // RHS is only indirect if the flag is set
                    let rhs: $t = if args.indirect_rhs {
                        $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?)
                    } else {
                        c.into()
                    };

                    let lhs = [<to_prim_ $t:lower>](lhs);
                    let rhs = [<to_prim_ $t:lower>](rhs);

                    let result = match lhs.checked_div(rhs) {
                        Some(d) => {
                            *err = 0;
                            [<from_prim_ $t:lower>](d)
                        },
                        None => {
                            if is_unsafe_math(flag.into()) {
                                *err = 1;
                                $t::default() // Zero
                            } else {
                                return Err(PanicReason::ArithmeticError.into());
                            }
                        }
                    };

                    *of = 0;

                    self.memory.as_mut().write_bytes(owner_regs, dest_addr, result.to_be_bytes())?;

                    Ok(inc_pc(pc)?)
                }

                pub(crate) fn [<alu_wideint_addmod_ $t:lower>](
                    &mut self,
                    dest_addr: Word,
                    b: Word,
                    c: Word,
                    d: Word,
                ) -> SimpleResult<()> {
                    let owner_regs = self.ownership_registers();
                    let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);

                    let lhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?);
                    let rhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?);
                    let modulus: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(d)?);

                    // Use wider types to avoid overflow
                    let lhs = [<to_wider_prim_ $t:lower>](lhs);
                    let rhs = [<to_wider_prim_ $t:lower>](rhs);
                    let modulus = [<to_wider_prim_ $t:lower>](modulus);

                    let pre_mod = lhs.checked_add(rhs)
                    .expect("Cannot overflow as we're using wider types");
                    let result: $t = match pre_mod.checked_rem(modulus) {
                        Some(result) => {
                            *err = 0;
                            // Truncate never loses data as modulus is still in domain of the original type
                            [<truncate_from_prim_ $t:lower>](result)
                        },
                        None => {
                            if is_unsafe_math(flag.into()) {
                                *err = 1;
                                $t::default() // Zero
                            } else {
                                return Err(PanicReason::ArithmeticError.into());
                            }
                        }
                    };

                    *of = 0;

                    self.memory.as_mut().write_bytes(owner_regs, dest_addr, result.to_be_bytes())?;

                    Ok(inc_pc(pc)?)
                }

                pub(crate) fn [<alu_wideint_mulmod_ $t:lower>](
                    &mut self,
                    dest_addr: Word,
                    b: Word,
                    c: Word,
                    d: Word,
                ) -> SimpleResult<()> {
                    let owner_regs = self.ownership_registers();
                    let (SystemRegisters { flag, mut of, mut err, pc, .. }, _) = split_registers(&mut self.registers);

                    let lhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?);
                    let rhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?);
                    let modulus: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(d)?);

                    let lhs = [<to_prim_ $t:lower>](lhs);
                    let rhs = [<to_prim_ $t:lower>](rhs);
                    let modulus = [<to_wider_prim_ $t:lower>](modulus);

                    let result = match lhs.full_mul(rhs).checked_rem(modulus) {
                        None => {
                            if is_unsafe_math(flag.into()) {
                                *err = 1;
                                $t::default() // Zero
                            } else {
                                return Err(PanicReason::ArithmeticError.into());
                            }
                        },
                        Some(result) => {
                            *err = 0;
                            // This never loses data, since the modulus type has same width as the result
                            [<truncate_from_prim_ $t:lower>](result)
                        }

                    };

                    *of = 0;

                    self.memory.as_mut().write_bytes(owner_regs, dest_addr, result.to_be_bytes())?;

                    Ok(inc_pc(pc)?)
                }

                pub(crate) fn [<alu_wideint_muldiv_ $t:lower>](
                    &mut self,
                    dest_addr: Word,
                    b: Word,
                    c: Word,
                    d: Word,
                ) -> SimpleResult<()> {
                    let owner_regs = self.ownership_registers();
                    let (SystemRegisters { mut of, mut err, pc, flag, .. }, _) = split_registers(&mut self.registers);

                    let lhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(b)?);
                    let rhs: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(c)?);
                    let divider: $t = $t::from_be_bytes(self.memory.as_ref().read_bytes(d)?);

                    const S: usize = core::mem::size_of::<$t>();

                    let lhs = [<to_prim_ $t:lower>](lhs);
                    let rhs = [<to_prim_ $t:lower>](rhs);

                    let product = lhs.full_mul(rhs);
                    #[allow(clippy::arithmetic_side_effects)] // Safety: the shift has less bits than the product
                    let product_div_max = product >> (S * 8);
                    let result = product.checked_div([<to_wider_prim_ $t:lower>](divider)).unwrap_or(product_div_max);

                    let mut buffer = [0u8; 2 * S];
                    result.to_little_endian(&mut buffer);
                    let lower_half: [u8; S] = buffer[..S].try_into().unwrap_or_else(|_| unreachable!());
                    let higher_half: [u8; S] = buffer[S..].try_into().unwrap_or_else(|_| unreachable!());
                    let result = $t::from_le_bytes(lower_half);

                    let overflows = higher_half != [0u8; S];
                    if overflows && !is_wrapping(flag.into()) {
                        return Err(PanicReason::ArithmeticOverflow.into());
                    }
                    *of = overflows as Word;
                    *err = 0;

                    self.memory.as_mut().write_bytes(owner_regs, dest_addr, result.to_be_bytes())?;

                    Ok(inc_pc(pc)?)
                }
            }

            pub(crate) fn [<cmp_ $t:lower>](
                lhs: $t,
                rhs: $t,
                mode: CompareMode,
            ) -> Word {
                match mode {
                    CompareMode::EQ => (lhs == rhs) as Word,
                    CompareMode::NE => (lhs != rhs) as Word,
                    CompareMode::GT => (lhs > rhs) as Word,
                    CompareMode::LT => (lhs < rhs) as Word,
                    CompareMode::GTE => (lhs >= rhs) as Word,
                    CompareMode::LTE => (lhs <= rhs) as Word,
                    CompareMode::LZC => lhs.leading_zeros() as Word,
                }
            }

            /// Returns (wrapped, overflow) just like overflowing_* operations of Rust integers
            pub(crate) fn [<op_overflowing_ $t:lower>] (
                lhs: $t,
                rhs: $t,
                args: MathArgs,
            ) -> ($t, bool) {
                match args.op {
                    MathOp::ADD => { $t::overflowing_add(lhs, rhs) }
                    MathOp::SUB => { $t::overflowing_sub(lhs, rhs) }
                    MathOp::OR => { (lhs | rhs, false) }
                    MathOp::XOR => { (lhs ^ rhs, false) }
                    MathOp::AND => {(lhs & rhs, false) }
                    MathOp::NOT => { (!lhs, false) }
                    MathOp::SHL => {
                        if let Ok(rhs) = rhs.try_into() {
                            ($t::checked_shl(lhs, rhs).unwrap_or_default(), false)
                        } else {
                            ($t::default(), false) // Zero
                        }
                    }
                    MathOp::SHR => {
                        if let Ok(rhs) = rhs.try_into() {
                            ($t::checked_shr(lhs, rhs).unwrap_or_default(), false)
                        } else {
                            ($t::default(), false) // Zero
                        }
                    }
                }
            }
        }
    };
}

wideint_ops!(u128, U256);
wideint_ops!(U256, U512);

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/initialization.rs

Source
use super::{
    ExecutableTransaction,
    InitialBalances,
    Interpreter,
    Memory,
    RuntimeBalances,
};
use crate::{
    checked_transaction::{
        IntoChecked,
        Ready,
    },
    consts::*,
    context::Context,
    error::InterpreterError,
    prelude::RuntimeError,
    storage::InterpreterStorage,
};
use fuel_asm::RegId;
use fuel_tx::{
    field::{
        Script,
        ScriptGasLimit,
    },
    Input,
    Output,
};
use fuel_types::Word;

use crate::interpreter::CheckedMetadata;

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    /// Initialize the VM with a given transaction
    fn init_inner(
        &mut self,
        mut tx: Tx,
        initial_balances: InitialBalances,
        runtime_balances: RuntimeBalances,
        gas_limit: Word,
    ) -> Result<(), RuntimeError<S::DataError>> {
        tx.prepare_sign();
        self.tx = tx;
        self.input_contracts = self
            .tx
            .inputs()
            .iter()
            .filter_map(|i| match i {
                Input::Contract(contract) => Some(contract.contract_id),
                _ => None,
            })
            .collect();

        self.input_contracts_index_to_output_index = self
            .tx
            .outputs()
            .iter()
            .enumerate()
            .filter_map(|(output_idx, o)| match o {
                Output::Contract(fuel_tx::output::contract::Contract {
                    input_index,
                    ..
                }) => Some((
                    *input_index,
                    u16::try_from(output_idx)
                        .expect("The maximum number of outputs is `u16::MAX`"),
                )),
                _ => None,
            })
            .collect();

        self.initial_balances = initial_balances.clone();

        self.frames.clear();
        self.receipts.clear();
        self.memory_mut().reset();

        // Optimized for memset
        self.registers.iter_mut().for_each(|r| *r = 0);

        self.registers[RegId::ONE] = 1;

        // Set heap area
        self.registers[RegId::HP] = VM_MAX_RAM;

        // Initialize stack
        macro_rules! push_stack {
            ($v:expr) => {{
                let data = $v;
                let old_ssp = self.registers[RegId::SSP];
                let new_ssp = old_ssp
                    .checked_add(data.len() as Word)
                    .expect("VM initialization data must fit into the stack");
                self.memory_mut().grow_stack(new_ssp)?;
                self.registers[RegId::SSP] = new_ssp;
                self.memory_mut()
                    .write_noownerchecks(old_ssp, data.len())
                    .expect("VM initialization data must fit into the stack")
                    .copy_from_slice(data);
            }};
        }

        push_stack!(&*self.transaction().id(&self.chain_id()));

        let base_asset_id = self.interpreter_params.base_asset_id;
        push_stack!(&*base_asset_id);

        runtime_balances.to_vm(self);

        let tx_size = self.transaction().size() as Word;
        self.set_gas(gas_limit);

        push_stack!(&tx_size.to_be_bytes());

        let tx_bytes = self.tx.to_bytes();
        push_stack!(tx_bytes.as_slice());

        self.registers[RegId::SP] = self.registers[RegId::SSP];

        Ok(())
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    Tx: ExecutableTransaction,
    S: InterpreterStorage,
{
    /// Initialize the VM for a predicate context
    pub fn init_predicate(
        &mut self,
        context: Context,
        tx: Tx,
        gas_limit: Word,
    ) -> Result<(), InterpreterError<S::DataError>> {
        self.context = context;
        let initial_balances: InitialBalances = Default::default();
        let runtime_balances = initial_balances.clone().try_into()?;

        let range = self
            .context
            .predicate()
            .expect("The context is not predicate")
            .program()
            .words();

        self.init_inner(tx, initial_balances, runtime_balances, gas_limit)?;
        self.registers[RegId::PC] = range.start as fuel_asm::Word;
        self.registers[RegId::IS] = range.start as fuel_asm::Word;

        Ok(())
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal>
where
    M: Memory,
    S: InterpreterStorage,
    <S as InterpreterStorage>::DataError: From<S::DataError>,
    Tx: ExecutableTransaction,
    <Tx as IntoChecked>::Metadata: CheckedMetadata,
{
    /// Initialize the VM with a given transaction, backed by a storage provider that
    /// allows execution of contract opcodes.
    ///
    /// For predicate estimation and verification, check [`Self::init_predicate`]
    pub fn init_script(
        &mut self,
        ready_tx: Ready<Tx>,
    ) -> Result<(), InterpreterError<S::DataError>> {
        let block_height = self.storage.block_height().map_err(RuntimeError::Storage)?;

        self.context = Context::Script { block_height };

        let (_, checked) = ready_tx.decompose();
        let (tx, metadata): (Tx, Tx::Metadata) = checked.into();

        let gas_limit = tx
            .as_script()
            .map(|script| *script.script_gas_limit())
            .unwrap_or_default();

        let initial_balances = metadata.balances();
        let runtime_balances = initial_balances.try_into()?;
        self.init_inner(tx, metadata.balances(), runtime_balances, gas_limit)?;

        if let Some(script) = self.transaction().as_script() {
            let offset = self.tx_offset().saturating_add(script.script_offset()) as Word;

            debug_assert!(offset < VM_MAX_RAM);

            self.registers[RegId::PC] = offset;
            self.registers[RegId::IS] = offset;
        }

        Ok(())
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/post_execution.rs

Source
use crate::prelude::{
    Bug,
    BugVariant,
    ExecutableTransaction,
    Interpreter,
    InterpreterStorage,
    RuntimeError,
};

use crate::interpreter::{
    InitialBalances,
    RuntimeBalances,
};
use fuel_tx::{
    FeeParameters,
    GasCosts,
};
use fuel_types::{
    AssetId,
    Word,
};

impl<M, S, T, Ecal> Interpreter<M, S, T, Ecal>
where
    S: InterpreterStorage,
{
    /// Finalize outputs post-execution.
    ///
    /// For more information, check [`ExecutableTransaction::update_outputs`].
    ///
    /// # Panics
    ///
    /// This will panic if the transaction is malformed (e.g. it contains an output change
    /// with asset id that doesn't exist as balance).
    ///
    /// The transaction validation is expected to halt in such case. Since the VM only
    /// accepts checked transactions - hence, validated - this case should be
    /// unreachable.
    #[allow(clippy::too_many_arguments)]
    pub(crate) fn finalize_outputs<Tx>(
        tx: &mut Tx,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        base_asset_id: &AssetId,
        revert: bool,
        used_gas: Word,
        initial_balances: &InitialBalances,
        balances: &RuntimeBalances,
        gas_price: Word,
    ) -> Result<(), RuntimeError<S::DataError>>
    where
        Tx: ExecutableTransaction,
    {
        tx.update_outputs(
            revert,
            used_gas,
            initial_balances,
            balances,
            gas_costs,
            fee_params,
            base_asset_id,
            gas_price,
        )
        .map_err(|e| Bug::new(BugVariant::UncomputableRefund).with_message(e))?;

        Ok(())
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter/balances.rs

Source
use crate::{
    consts::*,
    error::SimpleResult,
    interpreter::{
        ExecutableTransaction,
        InitialBalances,
        Interpreter,
    },
};

use fuel_asm::{
    RegId,
    Word,
};
use fuel_tx::{
    consts::BALANCE_ENTRY_SIZE,
    ValidityError,
};
use fuel_types::AssetId;
use itertools::Itertools;

use alloc::collections::BTreeMap;
use core::ops::Index;
use hashbrown::HashMap;

use super::{
    Memory,
    MemoryInstance,
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct Balance {
    value: Word,
    offset: usize,
}

impl Balance {
    pub const fn new(value: Word, offset: usize) -> Self {
        Self { value, offset }
    }

    pub const fn offset(&self) -> usize {
        self.offset
    }

    pub const fn value(&self) -> Word {
        self.value
    }

    pub fn checked_add(&mut self, value: Word) -> Option<&mut Self> {
        self.value
            .checked_add(value)
            .map(|v| self.value = v)
            .map(|_| self)
    }

    pub fn checked_sub(&mut self, value: Word) -> Option<&mut Self> {
        self.value
            .checked_sub(value)
            .map(|v| self.value = v)
            .map(|_| self)
    }
}

/// Structure to encapsulate asset balances for VM runtime
#[derive(Debug, Default, Clone)]
pub struct RuntimeBalances {
    state: HashMap<AssetId, Balance>,
}

impl TryFrom<InitialBalances> for RuntimeBalances {
    type Error = ValidityError;

    fn try_from(initial_balances: InitialBalances) -> Result<Self, ValidityError> {
        let mut balances: BTreeMap<_, _> = initial_balances.non_retryable.into();
        if let Some(retryable_amount) = initial_balances.retryable {
            let entry = balances.entry(retryable_amount.base_asset_id).or_default();
            *entry = entry
                .checked_add(retryable_amount.amount)
                .ok_or(ValidityError::BalanceOverflow)?;
        }
        Self::try_from_iter(balances)
    }
}

impl RuntimeBalances {
    /// Attempt to create a set of runtime balances from an iterator of pairs.
    ///
    /// This will fail if, and only if, the provided asset/balance pair isn't consistent
    /// or a balance overflows.
    pub fn try_from_iter<T>(iter: T) -> Result<Self, ValidityError>
    where
        T: IntoIterator<Item = (AssetId, Word)>,
    {
        iter.into_iter()
            .sorted_by_key(|k| k.0)
            .enumerate()
            .try_fold(HashMap::new(), |mut state, (i, (asset, balance))| {
                let offset = VM_MEMORY_BALANCES_OFFSET
                    .saturating_add(i.saturating_mul(BALANCE_ENTRY_SIZE));

                state
                    .entry(asset)
                    .or_insert_with(|| Balance::new(0, offset))
                    .checked_add(balance)
                    .ok_or(ValidityError::BalanceOverflow)?;

                Ok(state)
            })
            .map(|state| Self { state })
    }

    /// Fetch the balance of a given Id, if set.
    pub fn balance(&self, asset: &AssetId) -> Option<Word> {
        self.state.get(asset).map(Balance::value)
    }

    fn set_memory_balance_inner(
        balance: &Balance,
        memory: &mut MemoryInstance,
    ) -> SimpleResult<Word> {
        let value = balance.value();
        let offset = balance.offset();

        let offset = offset.saturating_add(AssetId::LEN);
        memory.write_bytes_noownerchecks(offset, value.to_be_bytes())?;

        Ok(value)
    }

    #[cfg(test)]
    /// Attempt to add the balance of an asset, updating the VM memory in the appropriate
    /// offset
    ///
    /// Note: This will not append a new asset into the set since all the assets must be
    /// created during VM initialization and any additional asset would imply
    /// reordering the memory representation of the balances since they must always be
    /// ordered, as in the protocol.
    pub fn checked_balance_add(
        &mut self,
        memory: &mut MemoryInstance,
        asset: &AssetId,
        value: Word,
    ) -> Option<Word> {
        self.state
            .get_mut(asset)
            .and_then(|b| b.checked_add(value))
            .map(|balance| Self::set_memory_balance_inner(balance, memory))
            .map_or((value == 0).then_some(0), |r| r.ok())
    }

    /// Attempt to subtract the balance of an asset, updating the VM memory in the
    /// appropriate offset
    pub fn checked_balance_sub(
        &mut self,
        memory: &mut MemoryInstance,
        asset: &AssetId,
        value: Word,
    ) -> Option<Word> {
        self.state
            .get_mut(asset)
            .and_then(|b| b.checked_sub(value))
            .map(|balance| Self::set_memory_balance_inner(balance, memory))
            .map_or((value == 0).then_some(0), |r| r.ok())
    }

    /// Write all assets into the start of VM stack, i.e. at $ssp.
    /// Panics if the assets cannot fit.
    pub fn to_vm<M, S, Tx, Ecal>(self, vm: &mut Interpreter<M, S, Tx, Ecal>)
    where
        M: Memory,
        Tx: ExecutableTransaction,
    {
        let len = (vm.max_inputs() as usize).saturating_mul(BALANCE_ENTRY_SIZE) as Word;

        let new_ssp = vm.registers[RegId::SSP].checked_add(len).expect(
            "Consensus parameters must not allow stack overflow during VM initialization",
        );
        vm.memory_mut().grow_stack(new_ssp).expect(
            "Consensus parameters must not allow stack overflow during VM initialization",
        );
        vm.registers[RegId::SSP] = new_ssp;

        self.state.iter().for_each(|(asset, balance)| {
            let value = balance.value();
            let ofs = balance.offset();

            vm.memory_mut()
                .write_bytes_noownerchecks(ofs, **asset)
                .expect("Checked above");
            vm.memory_mut()
                .write_bytes_noownerchecks(
                    ofs.saturating_add(AssetId::LEN),
                    value.to_be_bytes(),
                )
                .expect("Checked above");
        });

        vm.balances = self;
    }
}

impl Index<&AssetId> for RuntimeBalances {
    type Output = Word;

    fn index(&self, index: &AssetId) -> &Self::Output {
        &self.state[index].value
    }
}

impl AsMut<HashMap<AssetId, Balance>> for RuntimeBalances {
    fn as_mut(&mut self) -> &mut HashMap<AssetId, Balance> {
        &mut self.state
    }
}

impl AsRef<HashMap<AssetId, Balance>> for RuntimeBalances {
    fn as_ref(&self) -> &HashMap<AssetId, Balance> {
        &self.state
    }
}

impl PartialEq for RuntimeBalances {
    fn eq(&self, other: &Self) -> bool {
        self.state == other.state
    }
}

#[test]
fn writes_to_memory_correctly() {
    use crate::prelude::*;
    use alloc::vec;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    let rng = &mut StdRng::seed_from_u64(2322u64);
    let mut interpreter = Interpreter::<_, _, Script>::without_storage();

    let base = AssetId::zeroed();
    let base_balance = 950;
    let assets = vec![
        (rng.gen(), 10),
        (rng.gen(), 25),
        (rng.gen(), 50),
        (base, base_balance),
        (rng.gen(), 100),
    ];

    let mut assets_sorted = assets.clone();
    assets_sorted.as_mut_slice().sort_by(|a, b| a.0.cmp(&b.0));

    assert_ne!(assets_sorted, assets);

    let balances = assets.into_iter();

    interpreter.registers_mut()[RegId::HP] = VM_MAX_RAM;
    RuntimeBalances::try_from_iter(balances)
        .expect("failed to generate balances")
        .to_vm(&mut interpreter);

    let memory = interpreter.memory();
    assets_sorted
        .iter()
        .fold(VM_MEMORY_BALANCES_OFFSET, |ofs, (asset, value)| {
            assert_eq!(asset.as_ref(), &memory[ofs..ofs + AssetId::LEN]);
            assert_eq!(
                &value.to_be_bytes(),
                &memory[ofs + AssetId::LEN..ofs + BALANCE_ENTRY_SIZE]
            );

            ofs + BALANCE_ENTRY_SIZE
        });
}

#[test]
fn try_from_iter_wont_overflow() {
    use crate::prelude::*;
    use alloc::vec;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    let rng = &mut StdRng::seed_from_u64(2322u64);

    let a: AssetId = rng.gen();
    let b: AssetId = rng.gen();
    let c: AssetId = rng.gen();

    // Sanity check
    let balances = vec![(a, u64::MAX), (b, 15), (c, 0)];
    let runtime_balances = RuntimeBalances::try_from_iter(balances.clone())
        .expect("failed to create balance set");

    balances.iter().for_each(|(asset, val)| {
        let bal = runtime_balances
            .balance(asset)
            .expect("failed to fetch balance");

        assert_eq!(val, &bal);
    });

    // Aggregated sum check
    let balances = vec![(a, u64::MAX), (b, 15), (c, 0), (b, 1)];
    let balances_aggregated = [(a, u64::MAX), (b, 16), (c, 0)];
    let runtime_balances =
        RuntimeBalances::try_from_iter(balances).expect("failed to create balance set");

    balances_aggregated.iter().for_each(|(asset, val)| {
        let bal = runtime_balances
            .balance(asset)
            .expect("failed to fetch balance");

        assert_eq!(val, &bal);
    });

    // Overflow won't panic
    let balances = vec![(a, u64::MAX), (b, 15), (c, 0), (a, 1)];
    let err =
        RuntimeBalances::try_from_iter(balances).expect_err("overflow set should fail");

    assert_eq!(ValidityError::BalanceOverflow, err);
}

#[test]
fn checked_add_and_sub_works() {
    use crate::prelude::*;
    use alloc::vec;
    use rand::{
        rngs::StdRng,
        Rng,
        SeedableRng,
    };

    let rng = &mut StdRng::seed_from_u64(2322u64);

    let mut memory = vec![0u8; MEM_SIZE].into();

    let asset: AssetId = rng.gen();

    let balances = vec![(asset, 0)];
    let mut balances =
        RuntimeBalances::try_from_iter(balances).expect("failed to create set");

    // Sanity check
    let bal = balances.balance(&asset).expect("failed to fetch balance");
    assert_eq!(bal, 0);

    // Add zero balance not in the set should result in zero and not mutate the set
    let asset_b: AssetId = rng.gen();
    assert_ne!(asset, asset_b);

    let val = balances
        .checked_balance_add(&mut memory, &asset_b, 0)
        .expect("failed to add balance");

    assert_eq!(val, 0);
    assert!(balances.balance(&asset_b).is_none());

    // Normal add balance works
    let val = balances
        .checked_balance_add(&mut memory, &asset, 150)
        .expect("failed to add balance");
    let bal = balances.balance(&asset).expect("failed to fetch balance");

    assert_eq!(val, 150);
    assert_eq!(bal, 150);

    let val = balances
        .checked_balance_add(&mut memory, &asset, 75)
        .expect("failed to add balance");
    let bal = balances.balance(&asset).expect("failed to fetch balance");

    assert_eq!(val, 225);
    assert_eq!(bal, 225);

    // Normal sub balance works
    let val = balances
        .checked_balance_sub(&mut memory, &asset, 30)
        .expect("failed to sub balance");
    let bal = balances.balance(&asset).expect("failed to fetch balance");

    assert_eq!(val, 195);
    assert_eq!(bal, 195);

    let val = balances
        .checked_balance_sub(&mut memory, &asset, 120)
        .expect("failed to sub balance");
    let bal = balances.balance(&asset).expect("failed to fetch balance");

    assert_eq!(val, 75);
    assert_eq!(bal, 75);

    let val = balances
        .checked_balance_sub(&mut memory, &asset, 70)
        .expect("failed to sub balance");
    let bal = balances.balance(&asset).expect("failed to fetch balance");

    assert_eq!(val, 5);
    assert_eq!(bal, 5);

    // Balance won't panic underflow
    assert!(balances
        .checked_balance_sub(&mut memory, &asset, 10)
        .is_none());

    // Balance won't panic overflow
    let val = balances
        .checked_balance_add(&mut memory, &asset, u64::MAX - 5)
        .expect("failed to add balance");
    let bal = balances.balance(&asset).expect("failed to fetch balance");

    assert_eq!(val, u64::MAX);
    assert_eq!(bal, u64::MAX);

    assert!(balances
        .checked_balance_add(&mut memory, &asset, 1)
        .is_none());
}

/home/marten/fuel/fuel-vm/fuel-vm/src/call.rs

Source
//! Inter-contract call supporting structures

use fuel_asm::{
    PanicReason,
    RegId,
};
use fuel_types::{
    bytes::padded_len_usize,
    canonical::{
        Deserialize,
        Serialize,
    },
    AssetId,
    ContractId,
    Word,
};

use crate::consts::{
    WORD_SIZE,
    *,
};

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Deserialize, Serialize)]
/// Call structure representation, composed of a called contract `to` and two
/// word arguments.
///
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/instruction-set.md#call-call-contract>
pub struct Call {
    to: ContractId,
    a: Word,
    b: Word,
}

impl Call {
    /// The size of the call structures in memory representation.
    pub const LEN: usize = ContractId::LEN + 8 + 8;

    /// Create a new call structure representation.
    pub const fn new(to: ContractId, a: Word, b: Word) -> Self {
        Self { to, a, b }
    }

    /// Called contract.
    pub const fn to(&self) -> &ContractId {
        &self.to
    }

    /// `a` argument.
    pub const fn a(&self) -> Word {
        self.a
    }

    /// `b` argument.
    pub const fn b(&self) -> Word {
        self.b
    }

    /// Expose the internal attributes of the call description.
    pub const fn into_inner(self) -> (ContractId, Word, Word) {
        (self.to, self.a, self.b)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
/// Call frame representation in the VM stack.
///
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/fuel-vm/index.md#call-frames>
pub struct CallFrame {
    to: ContractId,
    asset_id: AssetId,
    registers: [Word; VM_REGISTER_COUNT],
    code_size_padded: usize,
    a: Word,
    b: Word,
}

#[cfg(test)]
impl Default for CallFrame {
    fn default() -> Self {
        Self {
            to: ContractId::default(),
            asset_id: AssetId::default(),
            registers: [0; VM_REGISTER_COUNT],
            code_size_padded: 0,
            a: 0,
            b: 0,
        }
    }
}

impl CallFrame {
    /// Create a new call frame.
    pub fn new(
        to: ContractId,
        asset_id: AssetId,
        registers: [Word; VM_REGISTER_COUNT],
        code_size: usize,
        a: Word,
        b: Word,
    ) -> Option<Self> {
        Some(Self {
            to,
            asset_id,
            registers,
            code_size_padded: padded_len_usize(code_size)?,
            a,
            b,
        })
    }

    /// Start of the contract id offset from the beginning of the call frame.
    pub const fn contract_id_offset() -> usize {
        0
    }

    /// Start of the asset id offset from the beginning of the call frame.
    pub const fn asset_id_offset() -> usize {
        Self::contract_id_offset().saturating_add(ContractId::LEN)
    }

    /// Start of the registers offset from the beginning of the call frame.
    pub const fn registers_offset() -> usize {
        Self::asset_id_offset().saturating_add(AssetId::LEN)
    }

    /// Start of the code size offset from the beginning of the call frame.
    pub const fn code_size_offset() -> usize {
        Self::registers_offset().saturating_add(WORD_SIZE * VM_REGISTER_COUNT)
    }

    /// Start of the `a` argument offset from the beginning of the call frame.
    pub const fn a_offset() -> usize {
        Self::code_size_offset().saturating_add(WORD_SIZE)
    }

    /// Start of the `b` argument offset from the beginning of the call frame.
    pub const fn b_offset() -> usize {
        Self::a_offset().saturating_add(WORD_SIZE)
    }

    /// Size of the call frame in bytes.
    pub const fn serialized_size() -> usize {
        Self::b_offset().saturating_add(WORD_SIZE)
    }

    /// Registers prior to the called execution.
    pub const fn registers(&self) -> &[Word] {
        &self.registers
    }

    /// Called contract id.
    pub const fn to(&self) -> &ContractId {
        &self.to
    }

    #[cfg(feature = "test-helpers")]
    /// Contract code length in bytes.
    pub fn code_size_padded(&self) -> usize {
        self.code_size_padded
    }

    /// `a` argument.
    pub const fn a(&self) -> Word {
        self.a
    }

    /// `b` argument.
    pub const fn b(&self) -> Word {
        self.b
    }

    /// Gas context prior to the called execution.
    pub fn context_gas(&self) -> Word {
        self.registers[RegId::CGAS]
    }

    /// Asset ID of forwarded coins.
    pub const fn asset_id(&self) -> &AssetId {
        &self.asset_id
    }

    /// Returns the mutable value of the context gas for this call frame.
    pub fn context_gas_mut(&mut self) -> &mut Word {
        &mut self.registers[RegId::CGAS]
    }

    /// Returns the mutable value of the global gas for this call frame.
    pub fn global_gas_mut(&mut self) -> &mut Word {
        &mut self.registers[RegId::GGAS]
    }
}

impl TryFrom<&[u8]> for Call {
    type Error = PanicReason;

    fn try_from(mut value: &[u8]) -> Result<Self, Self::Error> {
        Self::decode(&mut value).map_err(|_| PanicReason::MalformedCallStructure)
    }
}

#[cfg(test)]
impl From<Call> for alloc::vec::Vec<u8> {
    fn from(call: Call) -> Self {
        call.to_bytes()
    }
}

#[cfg(test)]
impl From<CallFrame> for alloc::vec::Vec<u8> {
    fn from(call: CallFrame) -> Self {
        call.to_bytes()
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/error.rs

Source
//! Runtime interpreter error implementation

use fuel_asm::{
    PanicInstruction,
    PanicReason,
    RawInstruction,
    Word,
};
use fuel_tx::ValidityError;

use crate::checked_transaction::CheckError;
use alloc::{
    format,
    string::{
        String,
        ToString,
    },
};
use core::{
    convert::Infallible,
    fmt,
};

use crate::storage::predicate;

/// Interpreter runtime error variants.
#[derive(Debug, derive_more::Display)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum InterpreterError<StorageError> {
    /// The instructions execution resulted in a well-formed panic, caused by an
    /// explicit instruction.
    #[display(fmt = "Execution error: {_0:?}")]
    PanicInstruction(PanicInstruction),
    /// The VM execution resulted in a well-formed panic. This panic wasn't
    /// caused by an instruction contained in the transaction or a called
    /// contract.
    #[display(fmt = "Execution error: {_0:?}")]
    Panic(PanicReason),
    /// Failed while checking the transaction.
    #[display(fmt = "Failed to check the transaction: {_0:?}")]
    CheckError(CheckError),
    /// No transaction was initialized in the interpreter. It cannot provide
    /// state transitions.
    #[display(fmt = "Execution error")]
    NoTransactionInitialized,
    #[display(fmt = "Execution error")]
    /// The debug state is not initialized; debug routines can't be called.
    DebugStateNotInitialized,
    /// Storage I/O error
    #[display(fmt = "Storage error: {}", _0)]
    Storage(StorageError),
    /// Encountered a bug
    #[display(fmt = "Bug: {_0}")]
    Bug(Bug),
    /// The `Ready` transaction provided to `Interpreter` doesn't have expected gas price
    #[display(
        fmt = "The transaction's gas price is wrong: expected {expected}, got {actual}"
    )]
    ReadyTransactionWrongGasPrice {
        /// Expected gas price
        expected: Word,
        /// Actual gas price
        actual: Word,
    },
}

impl<StorageError> InterpreterError<StorageError> {
    /// Describe the error as recoverable or halt.
    pub fn from_runtime(
        error: RuntimeError<StorageError>,
        instruction: RawInstruction,
    ) -> Self {
        match error {
            RuntimeError::Recoverable(reason) => {
                Self::PanicInstruction(PanicInstruction::error(reason, instruction))
            }
            _ => Self::from(error),
        }
    }

    /// Return the specified panic reason that caused this error, if applicable.
    pub const fn panic_reason(&self) -> Option<PanicReason> {
        match self {
            Self::PanicInstruction(result) => Some(*result.reason()),
            Self::Panic(reason) => Some(*reason),
            _ => None,
        }
    }

    /// Return the instruction that caused this error, if applicable.
    pub const fn instruction(&self) -> Option<&RawInstruction> {
        match self {
            Self::PanicInstruction(result) => Some(result.instruction()),
            _ => None,
        }
    }

    /// Return the underlying `InstructionResult` if this instance is
    /// `PanicInstruction`; returns `None` otherwise.
    pub fn instruction_result(&self) -> Option<PanicInstruction> {
        match self {
            Self::PanicInstruction(r) => Some(*r),
            _ => None,
        }
    }
}

impl<StorageError> InterpreterError<StorageError>
where
    StorageError: fmt::Debug,
{
    /// Make non-generic by converting the storage error to a string.
    pub fn erase_generics(&self) -> InterpreterError<String> {
        match self {
            Self::Storage(e) => InterpreterError::Storage(format!("{e:?}")),
            Self::PanicInstruction(e) => InterpreterError::PanicInstruction(*e),
            Self::Panic(e) => InterpreterError::Panic(*e),
            Self::NoTransactionInitialized => InterpreterError::NoTransactionInitialized,
            Self::DebugStateNotInitialized => InterpreterError::DebugStateNotInitialized,
            Self::Bug(e) => InterpreterError::Bug(e.clone()),
            Self::CheckError(e) => InterpreterError::CheckError(e.clone()),
            InterpreterError::ReadyTransactionWrongGasPrice { expected, actual } => {
                InterpreterError::ReadyTransactionWrongGasPrice {
                    expected: *expected,
                    actual: *actual,
                }
            }
        }
    }
}

impl<StorageError> From<RuntimeError<StorageError>> for InterpreterError<StorageError> {
    fn from(error: RuntimeError<StorageError>) -> Self {
        match error {
            RuntimeError::Recoverable(e) => Self::Panic(e),
            RuntimeError::Bug(e) => Self::Bug(e),
            RuntimeError::Storage(e) => Self::Storage(e),
        }
    }
}

impl<StorageError> PartialEq for InterpreterError<StorageError>
where
    StorageError: PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::PanicInstruction(s), Self::PanicInstruction(o)) => s == o,
            (Self::Panic(s), Self::Panic(o)) => s == o,
            (Self::NoTransactionInitialized, Self::NoTransactionInitialized) => true,
            (Self::Storage(a), Self::Storage(b)) => a == b,
            (Self::DebugStateNotInitialized, Self::DebugStateNotInitialized) => true,

            _ => false,
        }
    }
}

impl<StorageError> From<Bug> for InterpreterError<StorageError> {
    fn from(bug: Bug) -> Self {
        Self::Bug(bug)
    }
}

impl<StorageError> From<Infallible> for InterpreterError<StorageError> {
    fn from(_: Infallible) -> Self {
        unreachable!()
    }
}

impl<StorageError> From<ValidityError> for InterpreterError<StorageError> {
    fn from(err: ValidityError) -> Self {
        Self::CheckError(CheckError::Validity(err))
    }
}

/// Runtime error description that should either be specified in the protocol or
/// halt the execution.
#[derive(Debug)]
#[must_use]
pub enum RuntimeError<StorageError> {
    /// Specified error with well-formed fallback strategy, i.e. vm panics.
    Recoverable(PanicReason),
    /// Invalid interpreter state reached unexpectedly, this is a bug
    Bug(Bug),
    /// Storage io error
    Storage(StorageError),
}

impl<StorageError> RuntimeError<StorageError> {
    /// Flag whether the error is recoverable.
    pub const fn is_recoverable(&self) -> bool {
        matches!(self, Self::Recoverable(_))
    }

    /// Flag whether the error must halt the execution.
    pub const fn must_halt(&self) -> bool {
        !self.is_recoverable()
    }
}

impl<StorageError: PartialEq> PartialEq for RuntimeError<StorageError> {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (RuntimeError::Recoverable(a), RuntimeError::Recoverable(b)) => a == b,
            (RuntimeError::Bug(a), RuntimeError::Bug(b)) => a == b,
            (RuntimeError::Storage(a), RuntimeError::Storage(b)) => a == b,
            _ => false,
        }
    }
}

impl<StorageError: core::fmt::Debug> fmt::Display for RuntimeError<StorageError> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Recoverable(reason) => write!(f, "Recoverable error: {}", reason),
            Self::Bug(err) => write!(f, "Bug: {}", err),
            Self::Storage(err) => write!(f, "Unrecoverable storage error: {:?}", err),
        }
    }
}

impl<StorageError> From<PanicReason> for RuntimeError<StorageError> {
    fn from(value: PanicReason) -> Self {
        Self::Recoverable(value)
    }
}

impl<StorageError> From<core::array::TryFromSliceError> for RuntimeError<StorageError> {
    fn from(value: core::array::TryFromSliceError) -> Self {
        Self::Recoverable(value.into())
    }
}

impl<StorageError> From<Bug> for RuntimeError<StorageError> {
    fn from(bug: Bug) -> Self {
        Self::Bug(bug)
    }
}

impl<StorageError> From<Infallible> for RuntimeError<StorageError> {
    fn from(_: Infallible) -> Self {
        unreachable!()
    }
}

/// Predicates checking failed
#[derive(Debug, Clone, PartialEq, derive_more::Display)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PredicateVerificationFailed {
    /// The predicate did not use the amount of gas provided
    #[display(fmt = "Predicate used less than the required amount of gas")]
    GasMismatch,
    /// The transaction doesn't contain enough gas to evaluate the predicate
    #[display(fmt = "Insufficient gas available for single predicate")]
    OutOfGas,
    /// The predicate owner does not correspond to the predicate code
    #[display(fmt = "Predicate owner invalid, doesn't match code root")]
    InvalidOwner,
    /// The predicate wasn't successfully evaluated to true
    #[display(fmt = "Predicate failed to evaluate")]
    False,
    /// The predicate gas used was not specified before execution
    #[display(fmt = "Predicate failed to evaluate")]
    GasNotSpecified,
    /// The transaction's `max_gas` is greater than the global gas limit.
    #[display(fmt = "Transaction exceeds total gas allowance {_0:?}")]
    TransactionExceedsTotalGasAllowance(Word),
    /// The cumulative gas overflowed the u64 accumulator
    #[display(fmt = "Cumulative gas computation overflowed the u64 accumulator")]
    GasOverflow,
    /// Invalid interpreter state reached unexpectedly, this is a bug
    #[display(fmt = "Invalid interpreter state reached unexpectedly")]
    Bug(Bug),
    /// The VM execution resulted in a well-formed panic, caused by an instruction.
    #[display(fmt = "Execution error: {_0:?}")]
    PanicInstruction(PanicInstruction),
    /// The VM execution resulted in a well-formed panic not caused by an instruction.
    #[display(fmt = "Execution error: {_0:?}")]
    Panic(PanicReason),
    /// Predicate verification failed since it attempted to access storage
    #[display(
        fmt = "Predicate verification failed since it attempted to access storage"
    )]
    Storage,
}

impl From<InterpreterError<predicate::PredicateStorageError>>
    for PredicateVerificationFailed
{
    fn from(error: InterpreterError<predicate::PredicateStorageError>) -> Self {
        match error {
            error if error.panic_reason() == Some(PanicReason::OutOfGas) => {
                PredicateVerificationFailed::OutOfGas
            }
            InterpreterError::Panic(reason) => PredicateVerificationFailed::Panic(reason),
            InterpreterError::PanicInstruction(result) => {
                PredicateVerificationFailed::PanicInstruction(result)
            }
            InterpreterError::Bug(bug) => PredicateVerificationFailed::Bug(bug),
            InterpreterError::Storage(_) => PredicateVerificationFailed::Storage,
            _ => PredicateVerificationFailed::False,
        }
    }
}

impl From<Bug> for PredicateVerificationFailed {
    fn from(bug: Bug) -> Self {
        Self::Bug(bug)
    }
}

impl From<PanicReason> for PredicateVerificationFailed {
    fn from(reason: PanicReason) -> Self {
        Self::Panic(reason)
    }
}

impl From<PanicOrBug> for PredicateVerificationFailed {
    fn from(err: PanicOrBug) -> Self {
        match err {
            PanicOrBug::Panic(reason) => Self::from(reason),
            PanicOrBug::Bug(bug) => Self::Bug(bug),
        }
    }
}

/// Traceable bug variants
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, strum::EnumMessage)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BugVariant {
    /// Context gas increase has overflow
    #[strum(
        message = "The context gas cannot overflow since it was created by a valid transaction and the total gas does not increase - hence, it always fits a word."
    )]
    ContextGasOverflow,

    /// Context gas increase has underflow
    #[strum(
        message = "The context gas cannot underflow since any script should halt upon gas exhaustion."
    )]
    ContextGasUnderflow,

    /// Global gas subtraction has underflow
    #[strum(
        message = "The gas consumption cannot exceed the gas context since it is capped by the transaction gas limit."
    )]
    GlobalGasUnderflow,

    /// The global gas is less than the context gas.
    #[strum(message = "The global gas cannot ever be less than the context gas. ")]
    GlobalGasLessThanContext,

    /// The stack point has overflow
    #[strum(message = "The stack pointer cannot overflow under checked operations.")]
    StackPointerOverflow,

    /// Code size of a contract doesn't fit into a Word. This is prevented by tx size
    /// limit.
    #[strum(message = "Contract size doesn't fit into a word.")]
    CodeSizeOverflow,

    /// Refund cannot be computed in the current vm state.
    #[strum(message = "Refund cannot be computed in the current vm state.")]
    UncomputableRefund,

    /// Receipts context is full, but there's an attempt to add more receipts.
    #[strum(message = "Receipts context is full, cannot add new receipts.")]
    ReceiptsCtxFull,

    /// Witness index is out of bounds.
    #[strum(message = "Witness index is out of bounds.")]
    WitnessIndexOutOfBounds,

    /// The witness subsection index is higher than the total number of parts.
    #[strum(
        message = "The witness subsection index is higher than the total number of parts."
    )]
    NextSubsectionIndexIsHigherThanTotalNumberOfParts,
}

impl fmt::Display for BugVariant {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use strum::EnumMessage;
        if let Some(msg) = self.get_message() {
            write!(f, "{}", msg)
        } else {
            write!(f, "{:?}", self)
        }
    }
}

/// VM encountered unexpected state. This is a bug.
/// The execution must terminate since the VM is in an invalid state.
///
/// The bug it self is identified by the caller location.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[must_use]
pub struct Bug {
    /// Source code location of the bug, in `path/to/file.rs:line:column` notation
    location: String,

    /// Type of bug
    variant: BugVariant,

    /// Additional error message for the bug, if it's caused by a runtime error
    inner_message: Option<String>,

    /// Optionally include a backtrace for the instruction triggering this bug.
    /// This is only available when the `backtrace` feature is enabled.
    #[cfg(feature = "backtrace")]
    bt: backtrace::Backtrace,
}

impl Bug {
    /// Construct a new bug with the specified variant, using caller location for
    /// idenitfying the bug.
    #[track_caller]
    pub fn new(variant: BugVariant) -> Self {
        let caller = core::panic::Location::caller();
        let location = format!("{}:{}:{}", caller.file(), caller.line(), caller.column());
        Self {
            location,
            variant,
            inner_message: None,
            #[cfg(feature = "backtrace")]
            bt: backtrace::Backtrace::new(),
        }
    }

    /// Set an additional error message.
    pub fn with_message<E: ToString>(mut self, error: E) -> Self {
        self.inner_message = Some(error.to_string());
        self
    }
}

impl PartialEq for Bug {
    fn eq(&self, other: &Self) -> bool {
        self.location == other.location
    }
}

#[cfg(feature = "backtrace")]
mod bt {
    use super::*;
    use backtrace::Backtrace;

    impl Bug {
        /// Backtrace data
        pub const fn bt(&self) -> &Backtrace {
            &self.bt
        }
    }
}

impl fmt::Display for Bug {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use percent_encoding::{
            utf8_percent_encode,
            NON_ALPHANUMERIC,
        };

        let issue_title = format!("Bug report: {:?} in {}", self.variant, self.location);

        let issue_body = format!(
            "Error: {:?} {}\nLocation: {}\nVersion: {} {}\n",
            self.variant,
            self.inner_message
                .as_ref()
                .map(|msg| format!("({msg})"))
                .unwrap_or_default(),
            self.location,
            env!("CARGO_PKG_NAME"),
            env!("CARGO_PKG_VERSION")
        );

        write!(
            f,
            concat!(
                "Encountered a bug! Please report this using the following link: ",
                "https://github.com/FuelLabs/fuel-vm/issues/new",
                "?title={}",
                "&body={}",
                "\n\n",
                "{:?} error in {}: {} {}\n",
            ),
            utf8_percent_encode(&issue_title, NON_ALPHANUMERIC),
            utf8_percent_encode(&issue_body, NON_ALPHANUMERIC),
            self.variant,
            self.location,
            self.variant,
            self.inner_message
                .as_ref()
                .map(|msg| format!("({msg})"))
                .unwrap_or_default(),
        )?;

        #[cfg(feature = "backtrace")]
        {
            write!(f, "\nBacktrace:\n{:?}\n", self.bt)?;
        }

        Ok(())
    }
}

/// Runtime error description that should either be specified in the protocol or
/// halt the execution.
#[derive(Debug, Clone, PartialEq)]
#[must_use]
pub enum PanicOrBug {
    /// VM panic
    Panic(PanicReason),
    /// Invalid interpreter state reached unexpectedly, this is a bug
    Bug(Bug),
}

impl From<PanicReason> for PanicOrBug {
    fn from(panic: PanicReason) -> Self {
        Self::Panic(panic)
    }
}

impl From<Bug> for PanicOrBug {
    fn from(bug: Bug) -> Self {
        Self::Bug(bug)
    }
}

impl<StorageError> From<PanicOrBug> for RuntimeError<StorageError> {
    fn from(value: PanicOrBug) -> Self {
        match value {
            PanicOrBug::Panic(reason) => Self::Recoverable(reason),
            PanicOrBug::Bug(bug) => Self::Bug(bug),
        }
    }
}

impl<StorageError> From<PanicOrBug> for InterpreterError<StorageError> {
    fn from(value: PanicOrBug) -> Self {
        match value {
            PanicOrBug::Panic(reason) => Self::Panic(reason),
            PanicOrBug::Bug(bug) => Self::Bug(bug),
        }
    }
}

/// Result of a operation that doesn't access storage
pub type SimpleResult<T> = Result<T, PanicOrBug>;

/// Result of a operation that accesses storage
pub type IoResult<T, S> = Result<T, RuntimeError<S>>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bug_report_message() {
        let bug = Bug::new(BugVariant::ContextGasOverflow).with_message("Test message");
        let text = format!("{}", bug);
        assert!(text.contains(file!()));
        assert!(text.contains("https://github.com/FuelLabs/fuel-vm/issues/new"));
        assert!(text.contains("ContextGasOverflow"));
        assert!(text.contains("Test message"));
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/context.rs

Source
//! VM runtime context definitions

use crate::predicate::RuntimePredicate;

use fuel_asm::Word;
use fuel_types::BlockHeight;

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// Runtime context description.
pub enum Context {
    /// Current context is a predicate estimation.
    PredicateEstimation {
        /// Predicate program to be executed
        program: RuntimePredicate,
    },
    /// Current context is a predicate verification.
    PredicateVerification {
        /// Predicate program to be executed
        program: RuntimePredicate,
    },
    /// Current context is a script execution.
    Script {
        /// Block height of the context
        block_height: BlockHeight,
    },
    /// Current context is under a `CALL` scope
    Call {
        /// Block height of the context
        block_height: BlockHeight,
    },
    /// No transaction initialized/invalid context.
    NotInitialized,
}

impl Default for Context {
    fn default() -> Self {
        Self::NotInitialized
    }
}

impl Context {
    /// Check if the context is predicate
    pub const fn is_predicate(&self) -> bool {
        matches!(
            self,
            Self::PredicateEstimation { .. } | Self::PredicateVerification { .. }
        )
    }

    /// Return `true` if the context is external; `false` otherwise.
    pub const fn is_external(&self) -> bool {
        matches!(
            self,
            Self::PredicateEstimation { .. }
                | Self::PredicateVerification { .. }
                | Self::Script { .. }
        )
    }

    /// Return `true` if the context is internal; `false` otherwise.
    pub const fn is_internal(&self) -> bool {
        !self.is_external()
    }

    /// Return the program to be executed, if its a predicate
    pub const fn predicate(&self) -> Option<&RuntimePredicate> {
        match self {
            Context::PredicateEstimation { program } => Some(program),
            Context::PredicateVerification { program } => Some(program),
            _ => None,
        }
    }

    /// Return the block height from the context, if either script or call
    pub const fn block_height(&self) -> Option<BlockHeight> {
        match self {
            Context::Script { block_height } | Context::Call { block_height } => {
                Some(*block_height)
            }
            _ => None,
        }
    }

    /// Update the context according to the provided frame pointer
    pub fn update_from_frame_pointer(&mut self, fp: Word) {
        match self {
            Context::Script { block_height } if fp != 0 => {
                *self = Self::Call {
                    block_height: *block_height,
                }
            }

            Context::Call { block_height } if fp == 0 => {
                *self = Self::Script {
                    block_height: *block_height,
                }
            }
            _ => (),
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/state.rs

Source
//! Runtime state representation for the VM

use alloc::vec::Vec;

use fuel_tx::Receipt;
use fuel_types::{
    Bytes32,
    Word,
};

mod debug;

mod debugger;

pub use debug::{
    Breakpoint,
    DebugEval,
};

pub use debugger::Debugger;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
/// Resulting state of an instruction set execution.
pub enum ExecuteState {
    /// The VM should proceed normally with the execution.
    Proceed,
    /// The current context returned a [`Word`].
    Return(Word),
    /// The current context returned some data represented as its digest.
    ReturnData(Bytes32),
    /// The set execution resulted in a `RVRT` instruction.
    Revert(Word),

    /// A debug event was reached.
    DebugEvent(DebugEval),
}

impl ExecuteState {
    /// Return true if the VM execution should continue.
    pub const fn should_continue(&self) -> bool {
        matches!(self, Self::Proceed | Self::DebugEvent(DebugEval::Continue))
    }
}

impl Default for ExecuteState {
    fn default() -> Self {
        Self::Proceed
    }
}

impl From<DebugEval> for ExecuteState {
    fn from(d: DebugEval) -> Self {
        Self::DebugEvent(d)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// Resulting state of a transaction/program execution.
pub enum ProgramState {
    /// The transaction returned a [`Word`].
    Return(Word),
    /// The transaction returned some data represented as its digest.
    ReturnData(Bytes32),
    /// The transaction execution resulted in a `RVRT` instruction.
    Revert(Word),

    /// A debug event was reached for the transaction. The VM is suspended.
    RunProgram(DebugEval),

    /// A debug event was reached for a predicate verification. The VM is
    /// suspended.
    VerifyPredicate(DebugEval),
}

impl PartialEq<Breakpoint> for ProgramState {
    fn eq(&self, other: &Breakpoint) -> bool {
        match self.debug_ref() {
            Some(&DebugEval::Breakpoint(b)) => &b == other,
            _ => false,
        }
    }
}

impl ProgramState {
    /// Debug event representation.
    ///
    /// Will return `None` if no debug event was reached.
    pub const fn debug_ref(&self) -> Option<&DebugEval> {
        match self {
            Self::RunProgram(d) | Self::VerifyPredicate(d) => Some(d),
            _ => None,
        }
    }

    /// Return `true` if a debug event was reached.
    pub const fn is_debug(&self) -> bool {
        self.debug_ref().is_some()
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
/// Representation of the result of a transaction execution.
pub struct StateTransition<Tx> {
    state: ProgramState,
    tx: Tx,
    receipts: Vec<Receipt>,
}

impl<Tx> StateTransition<Tx> {
    /// Create a new state transition representation.
    pub const fn new(state: ProgramState, tx: Tx, receipts: Vec<Receipt>) -> Self {
        Self {
            state,
            tx,
            receipts,
        }
    }

    /// Program state representation.
    pub const fn state(&self) -> &ProgramState {
        &self.state
    }

    /// Resulting mutated transaction after VM execution.
    pub const fn tx(&self) -> &Tx {
        &self.tx
    }

    /// Flag whether the client should revert after execution.
    pub fn should_revert(&self) -> bool {
        self.receipts
            .iter()
            .any(|r| matches!(r, Receipt::Revert { .. } | Receipt::Panic { .. }))
    }

    /// Transaction receipts representing the state transition.
    pub fn receipts(&self) -> &[Receipt] {
        self.receipts.as_slice()
    }

    /// Convert this instance into its internal attributes.
    pub fn into_inner(self) -> (ProgramState, Tx, Vec<Receipt>) {
        (self.state, self.tx, self.receipts)
    }
}

impl<Tx> From<StateTransition<Tx>> for ProgramState {
    fn from(t: StateTransition<Tx>) -> ProgramState {
        t.state
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
/// Zero-copy Representation of the result of a transaction execution bound to
/// the lifetime of the VM.
pub struct StateTransitionRef<'a, Tx> {
    state: ProgramState,
    tx: &'a Tx,
    receipts: &'a [Receipt],
}

impl<'a, Tx> StateTransitionRef<'a, Tx> {
    /// Create a new by reference state transition representation.
    pub const fn new(state: ProgramState, tx: &'a Tx, receipts: &'a [Receipt]) -> Self {
        Self {
            state,
            tx,
            receipts,
        }
    }

    /// Program state representation.
    pub const fn state(&self) -> &ProgramState {
        &self.state
    }

    /// Resulting mutated transaction after VM execution.
    pub const fn tx(&self) -> &Tx {
        self.tx
    }

    /// Transaction receipts representing the state transition.
    pub const fn receipts(&self) -> &[Receipt] {
        self.receipts
    }

    /// Flag whether the client should revert after execution.
    pub fn should_revert(&self) -> bool {
        self.receipts
            .iter()
            .any(|r| matches!(r, Receipt::Revert { .. } | Receipt::Panic { .. }))
    }
}

impl<'a, Tx> From<&'a StateTransition<Tx>> for StateTransitionRef<'a, Tx> {
    fn from(t: &'a StateTransition<Tx>) -> StateTransitionRef<'a, Tx> {
        Self {
            state: *t.state(),
            tx: t.tx(),
            receipts: t.receipts(),
        }
    }
}

impl<'a, Tx: Clone> From<StateTransitionRef<'a, Tx>> for StateTransition<Tx> {
    fn from(t: StateTransitionRef<Tx>) -> StateTransition<Tx> {
        StateTransition {
            state: *t.state(),
            tx: t.tx().clone(),
            receipts: t.receipts().to_vec(),
        }
    }
}

impl<'a, Tx: Clone> From<StateTransitionRef<'a, Tx>> for ProgramState {
    fn from(t: StateTransitionRef<'a, Tx>) -> ProgramState {
        t.state
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/state/debug.rs

Source
use fuel_asm::Instruction;
use fuel_types::{
    ContractId,
    Word,
};

use crate::consts::VM_MAX_RAM;

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// Breakpoint description that binds a tuple `(contract, $pc)` to a debugger
/// implementation.
///
/// Breakpoints should be context-sensitive; hence, should target contract Ids.
///
/// For script/predicate verification, the contract id should be zero.
pub struct Breakpoint {
    contract: ContractId,
    pc: Word,
}

impl Breakpoint {
    pub(crate) const fn raw(contract: ContractId, pc: Word) -> Self {
        Self { contract, pc }
    }

    /// Create a new contract breakpoint
    ///
    /// The `$pc` is provided in op count and internally is multiplied by the op
    /// size. Also, the op count is always relative to `$is` so it should
    /// consider only the bytecode of the contract.
    ///
    /// Panics if the `pc` cannot ever fit into the VM memory.
    pub const fn new(contract: ContractId, pc: Word) -> Self {
        let pc = pc.saturating_mul(Instruction::SIZE as Word);
        assert!(pc <= VM_MAX_RAM, "Breakpoint cannot fit into vm memory");
        Self::raw(contract, pc)
    }

    /// Create a new script breakpoint
    ///
    /// The `$pc` is provided in op count and internally is multiplied by the op
    /// size
    pub fn script(pc: Word) -> Self {
        let contract = Default::default();

        Self::new(contract, pc)
    }

    /// Contract that will trigger the breakpoint.
    pub const fn contract(&self) -> &ContractId {
        &self.contract
    }

    /// Program counter that will trigger the breakpoint.
    pub const fn pc(&self) -> Word {
        self.pc
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
/// State evaluation of the interpreter that will describe if a program should
/// break or continue.
pub enum DebugEval {
    /// This evaluation should break the program in the location described in
    /// `Breakpoint`.
    Breakpoint(Breakpoint),
    /// This evaluation should not break the program.
    Continue,
}

impl Default for DebugEval {
    fn default() -> Self {
        Self::Continue
    }
}

impl From<Breakpoint> for DebugEval {
    fn from(b: Breakpoint) -> Self {
        Self::Breakpoint(b)
    }
}

impl DebugEval {
    /// Flag whether the program execution should break.
    pub const fn should_continue(&self) -> bool {
        matches!(self, Self::Continue)
    }

    /// Return a breakpoint description if the current evaluation should break;
    /// return `None` otherwise.
    pub const fn breakpoint(&self) -> Option<&Breakpoint> {
        match self {
            Self::Breakpoint(b) => Some(b),
            _ => None,
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/state/debugger.rs

Source
use crate::state::{
    Breakpoint,
    DebugEval,
    ProgramState,
};

use fuel_types::{
    ContractId,
    Word,
};

use hashbrown::{
    HashMap,
    HashSet,
};

/// Debugger implementation for the VM.
#[derive(Debug, Default, Clone)]
pub struct Debugger {
    /// Debugger is active and used.
    is_active: bool,
    /// Single-stepping mode triggers a breakpoint after each instruction
    single_stepping: bool,
    breakpoints: HashMap<ContractId, HashSet<Word>>,
    last_state: Option<ProgramState>,
}

impl Debugger {
    /// Returns `true` if the `Debugger` is active and used.
    pub const fn is_active(&self) -> bool {
        self.is_active
    }

    /// Get single-stepping mode
    pub const fn single_stepping(&self) -> bool {
        self.single_stepping
    }

    /// Set single-stepping mode
    pub fn set_single_stepping(&mut self, single_stepping: bool) {
        self.is_active = true;
        self.single_stepping = single_stepping;
    }

    /// Set a new breakpoint in the provided location.
    pub fn clear_breakpoints(&mut self) {
        self.breakpoints.clear();
    }

    /// Set a new breakpoint in the provided location.
    pub fn set_breakpoint(&mut self, breakpoint: Breakpoint) {
        self.is_active = true;
        let contract = *breakpoint.contract();
        let pc = breakpoint.pc();

        self.breakpoints
            .get_mut(&contract)
            .map(|set| set.insert(pc))
            .map(|_| ())
            .unwrap_or_else(|| {
                let mut set = HashSet::new();

                set.insert(pc);

                self.breakpoints.insert(contract, set);
            });
    }

    /// Remove a breakpoint, if existent.
    pub fn remove_breakpoint(&mut self, breakpoint: &Breakpoint) {
        self.is_active = true;
        self.breakpoints
            .get_mut(breakpoint.contract())
            .map(|set| set.remove(&breakpoint.pc()));
    }

    /// Evaluate the current state of the interpreter whether or not a
    /// breakpoint was reached.
    pub fn eval_state(&mut self, contract: Option<&ContractId>, pc: Word) -> DebugEval {
        // Default contract address maps to unset contract target
        let contract = contract.copied().unwrap_or_default();
        let last_state = self.last_state.take();

        let current = Breakpoint::raw(contract, pc);

        if self.single_stepping {
            return match last_state {
                Some(s) if s == current => DebugEval::Continue,
                _ => current.into(),
            }
        }

        self.breakpoints
            .get(&contract)
            .and_then(|set| set.get(&pc))
            .map(|_| match last_state {
                Some(s) if s == current => DebugEval::Continue,
                _ => current.into(),
            })
            .unwrap_or_default()
    }

    /// Overwrite the last known state of the VM.
    pub fn set_last_state(&mut self, state: ProgramState) {
        self.is_active = true;
        self.last_state.replace(state);
    }

    /// Retried the last state of execution; return `None` if the VM was never
    /// executed.
    pub const fn last_state(&self) -> &Option<ProgramState> {
        &self.last_state
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/memory_client.rs

Source
//! In-memory client implementation

use crate::{
    backtrace::Backtrace,
    checked_transaction::Checked,
    error::InterpreterError,
    interpreter::{
        EcalHandler,
        InterpreterParams,
        Memory,
        NotSupportedEcal,
    },
    state::StateTransitionRef,
    storage::MemoryStorage,
    transactor::Transactor,
};
use core::convert::Infallible;
use fuel_tx::{
    Blob,
    Create,
    FeeParameters,
    GasCosts,
    Receipt,
    Script,
    Upgrade,
    Upload,
};

#[cfg(any(test, feature = "test-helpers"))]
use crate::interpreter::MemoryInstance;

#[derive(Debug)]
/// Client implementation with in-memory storage backend.
pub struct MemoryClient<M, Ecal = NotSupportedEcal> {
    transactor: Transactor<M, MemoryStorage, Script, Ecal>,
}

#[cfg(any(test, feature = "test-helpers"))]
impl Default for MemoryClient<MemoryInstance> {
    fn default() -> Self {
        Self::from_txtor(Transactor::new(
            MemoryInstance::new(),
            MemoryStorage::default(),
            InterpreterParams::default(),
        ))
    }
}

impl<M, Ecal: EcalHandler> AsRef<MemoryStorage> for MemoryClient<M, Ecal> {
    fn as_ref(&self) -> &MemoryStorage {
        self.transactor.as_ref()
    }
}

impl<M, Ecal: EcalHandler> AsMut<MemoryStorage> for MemoryClient<M, Ecal> {
    fn as_mut(&mut self) -> &mut MemoryStorage {
        self.transactor.as_mut()
    }
}

impl<M, Ecal: EcalHandler + Default> MemoryClient<M, Ecal> {
    /// Create a new instance of the memory client out of a provided storage.
    pub fn new(
        memory: M,
        storage: MemoryStorage,
        interpreter_params: InterpreterParams,
    ) -> Self {
        Self {
            transactor: Transactor::new(memory, storage, interpreter_params),
        }
    }
}

impl<M, Ecal: EcalHandler> MemoryClient<M, Ecal> {
    /// Create a new instance of the memory client out of a provided storage.
    pub fn from_txtor(transactor: Transactor<M, MemoryStorage, Script, Ecal>) -> Self {
        Self { transactor }
    }
}

impl<M, Ecal: EcalHandler> MemoryClient<M, Ecal>
where
    M: Memory,
{
    /// If a transaction was executed and produced a VM panic, returns the
    /// backtrace; return `None` otherwise.
    pub fn backtrace(&self) -> Option<Backtrace> {
        self.transactor.backtrace()
    }

    /// If a transaction was successfully executed, returns the produced
    /// receipts; return `None` otherwise.
    pub fn receipts(&self) -> Option<&[Receipt]> {
        self.transactor.receipts()
    }

    /// State transition representation after the execution of a transaction.
    pub fn state_transition(&self) -> Option<StateTransitionRef<'_, Script>> {
        self.transactor.state_transition()
    }

    /// Deploys a `Create` transaction.
    pub fn deploy(
        &mut self,
        tx: Checked<Create>,
    ) -> Result<Create, InterpreterError<Infallible>> {
        self.transactor.deploy(tx)
    }

    /// Executes `Upgrade` transaction.
    pub fn upgrade(
        &mut self,
        tx: Checked<Upgrade>,
    ) -> Result<Upgrade, InterpreterError<Infallible>> {
        self.transactor.upgrade(tx)
    }

    /// Executes `Upload` transaction.
    pub fn upload(&mut self, tx: Checked<Upload>) -> Option<Upload> {
        self.transactor.upload(tx).ok()
    }

    /// Executes `Blob` transaction.
    pub fn blob(&mut self, tx: Checked<Blob>) -> Option<Blob> {
        self.transactor.blob(tx).ok()
    }

    /// Execute a transaction.
    ///
    /// Since the memory storage is `Infallible`, associatively, the memory
    /// client should also be.
    pub fn transact(&mut self, tx: Checked<Script>) -> &[Receipt] {
        self.transactor.transact(tx);

        // TODO `Transactor::result` should accept error as generic so compile-time
        // constraints can be applied.
        //
        // In this case, we should expect `Infallible` error.
        if let Ok(state) = self.transactor.result() {
            if state.should_revert() {
                self.transactor.as_mut().revert();
            } else {
                self.transactor.as_mut().commit();
            }
        } else {
            // if vm failed to execute, revert storage just in case
            self.transactor.as_mut().revert();
        }

        self.transactor.receipts().unwrap_or_default()
    }

    /// Persist the changes caused by [`Self::transact`].
    pub fn persist(&mut self) {
        self.as_mut().persist();
    }

    /// Tx memory offset
    pub fn tx_offset(&self) -> usize {
        self.transactor.tx_offset()
    }

    /// Gas costs for opcodes
    pub fn gas_costs(&self) -> &GasCosts {
        self.transactor.gas_costs()
    }

    /// Fee parameters
    pub fn fee_params(&self) -> &FeeParameters {
        self.transactor.fee_params()
    }

    #[cfg(feature = "test-helpers")]
    /// Sets the gas price of the `Interpreter`
    pub fn set_gas_price(&mut self, gas_price: u64) {
        self.transactor.set_gas_price(gas_price);
    }
}

impl<M, Ecal: EcalHandler> From<MemoryClient<M, Ecal>>
    for Transactor<M, MemoryStorage, Script, Ecal>
{
    fn from(client: MemoryClient<M, Ecal>) -> Self {
        client.transactor
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/interpreter.rs

Source
//! [`Interpreter`] implementation

use crate::{
    call::CallFrame,
    checked_transaction::{
        BlobCheckedMetadata,
        CheckPredicateParams,
    },
    constraints::reg_key::*,
    consts::*,
    context::Context,
    error::SimpleResult,
    state::Debugger,
};
use alloc::vec::Vec;
use core::{
    mem,
    ops::Index,
};

use fuel_asm::{
    Flags,
    PanicReason,
};
use fuel_tx::{
    field,
    Blob,
    Chargeable,
    Create,
    Executable,
    FeeParameters,
    GasCosts,
    Output,
    PrepareSign,
    Receipt,
    Script,
    Transaction,
    TransactionRepr,
    UniqueIdentifier,
    Upgrade,
    Upload,
    ValidityError,
};
use fuel_types::{
    AssetId,
    Bytes32,
    ChainId,
    ContractId,
    Word,
};

mod alu;
mod balances;
mod blob;
mod blockchain;
mod constructors;
pub mod contract;
mod crypto;
pub mod diff;
mod executors;
mod flow;
mod gas;
mod initialization;
mod internal;
mod log;
mod memory;
mod metadata;
mod post_execution;
mod receipts;

mod debug;
mod ecal;

use crate::profiler::Profiler;

#[cfg(feature = "profile-gas")]
use crate::profiler::InstructionLocation;

pub use balances::RuntimeBalances;
pub use ecal::{
    EcalHandler,
    PredicateErrorEcal,
};
pub use executors::predicates;
pub use memory::{
    Memory,
    MemoryInstance,
    MemoryRange,
};

use crate::checked_transaction::{
    CreateCheckedMetadata,
    EstimatePredicates,
    IntoChecked,
    NonRetryableFreeBalances,
    RetryableAmount,
    ScriptCheckedMetadata,
    UpgradeCheckedMetadata,
    UploadCheckedMetadata,
};

#[cfg(feature = "test-helpers")]
pub use self::receipts::ReceiptsCtx;

#[cfg(not(feature = "test-helpers"))]
use self::receipts::ReceiptsCtx;

/// ECAL opcode is not supported and return an error if you try to call.
#[derive(Debug, Copy, Clone, Default)]
pub struct NotSupportedEcal;

/// VM interpreter.
///
/// The internal state of the VM isn't expose because the intended usage is to
/// either inspect the resulting receipts after a transaction execution, or the
/// resulting mutated transaction.
///
/// These can be obtained with the help of a [`crate::transactor::Transactor`]
/// or a client implementation.
#[derive(Debug, Clone)]
pub struct Interpreter<M, S, Tx = (), Ecal = NotSupportedEcal> {
    registers: [Word; VM_REGISTER_COUNT],
    memory: M,
    frames: Vec<CallFrame>,
    receipts: ReceiptsCtx,
    tx: Tx,
    initial_balances: InitialBalances,
    input_contracts: alloc::collections::BTreeSet<ContractId>,
    input_contracts_index_to_output_index: alloc::collections::BTreeMap<u16, u16>,
    storage: S,
    debugger: Debugger,
    context: Context,
    balances: RuntimeBalances,
    profiler: Profiler,
    interpreter_params: InterpreterParams,
    /// `PanicContext` after the latest execution. It is consumed by
    /// `append_panic_receipt` and is `PanicContext::None` after consumption.
    panic_context: PanicContext,
    ecal_state: Ecal,
}

/// Interpreter parameters
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct InterpreterParams {
    /// Gas Price
    pub gas_price: Word,
    /// Gas costs
    pub gas_costs: GasCosts,
    /// Maximum number of inputs
    pub max_inputs: u16,
    /// Maximum size of the contract in bytes
    pub contract_max_size: u64,
    /// Offset of the transaction data in the memory
    pub tx_offset: usize,
    /// Maximum length of the message data
    pub max_message_data_length: u64,
    /// Chain ID
    pub chain_id: ChainId,
    /// Fee parameters
    pub fee_params: FeeParameters,
    /// Base Asset ID
    pub base_asset_id: AssetId,
}

#[cfg(feature = "test-helpers")]
impl Default for InterpreterParams {
    fn default() -> Self {
        Self {
            gas_price: 0,
            gas_costs: Default::default(),
            max_inputs: fuel_tx::TxParameters::DEFAULT.max_inputs(),
            contract_max_size: fuel_tx::ContractParameters::DEFAULT.contract_max_size(),
            tx_offset: fuel_tx::TxParameters::DEFAULT.tx_offset(),
            max_message_data_length: fuel_tx::PredicateParameters::DEFAULT
                .max_message_data_length(),
            chain_id: ChainId::default(),
            fee_params: FeeParameters::default(),
            base_asset_id: Default::default(),
        }
    }
}

impl InterpreterParams {
    /// Constructor for `InterpreterParams`
    pub fn new<T: Into<CheckPredicateParams>>(gas_price: Word, params: T) -> Self {
        let params: CheckPredicateParams = params.into();
        Self {
            gas_price,
            gas_costs: params.gas_costs,
            max_inputs: params.max_inputs,
            contract_max_size: params.contract_max_size,
            tx_offset: params.tx_offset,
            max_message_data_length: params.max_message_data_length,
            chain_id: params.chain_id,
            fee_params: params.fee_params,
            base_asset_id: params.base_asset_id,
        }
    }
}

/// Sometimes it is possible to add some additional context information
/// regarding panic reasons to simplify debugging.
// TODO: Move this enum into `fuel-tx` and use it inside of the `Receipt::Panic` as meta
//  information. Maybe better to have `Vec<PanicContext>` to provide more information.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum PanicContext {
    /// No additional information.
    None,
    /// `ContractId` retrieved during instruction execution.
    ContractId(ContractId),
}

impl<M: Memory, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal> {
    /// Returns the current state of the VM memory
    pub fn memory(&self) -> &MemoryInstance {
        self.memory.as_ref()
    }
}

impl<M: AsMut<MemoryInstance>, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal> {
    /// Returns mutable access to the vm memory
    pub fn memory_mut(&mut self) -> &mut MemoryInstance {
        self.memory.as_mut()
    }
}

impl<M, S, Tx, Ecal> Interpreter<M, S, Tx, Ecal> {
    /// Returns the current state of the registers
    pub const fn registers(&self) -> &[Word] {
        &self.registers
    }

    /// Returns mutable access to the registers
    pub fn registers_mut(&mut self) -> &mut [Word] {
        &mut self.registers
    }

    pub(crate) fn call_stack(&self) -> &[CallFrame] {
        self.frames.as_slice()
    }

    /// Debug handler
    pub const fn debugger(&self) -> &Debugger {
        &self.debugger
    }

    /// The current transaction.
    pub fn transaction(&self) -> &Tx {
        &self.tx
    }

    /// The initial balances.
    pub fn initial_balances(&self) -> &InitialBalances {
        &self.initial_balances
    }

    /// Get max_inputs value
    pub fn max_inputs(&self) -> u16 {
        self.interpreter_params.max_inputs
    }

    /// Gas price for current block
    pub fn gas_price(&self) -> Word {
        self.interpreter_params.gas_price
    }

    #[cfg(feature = "test-helpers")]
    /// Sets the gas price of the `Interpreter`
    pub fn set_gas_price(&mut self, gas_price: u64) {
        self.interpreter_params.gas_price = gas_price;
    }

    /// Gas costs for opcodes
    pub fn gas_costs(&self) -> &GasCosts {
        &self.interpreter_params.gas_costs
    }

    /// Get the Fee Parameters
    pub fn fee_params(&self) -> &FeeParameters {
        &self.interpreter_params.fee_params
    }

    /// Get the base Asset ID
    pub fn base_asset_id(&self) -> &AssetId {
        &self.interpreter_params.base_asset_id
    }

    /// Get contract_max_size value
    pub fn contract_max_size(&self) -> u64 {
        self.interpreter_params.contract_max_size
    }

    /// Get tx_offset value
    pub fn tx_offset(&self) -> usize {
        self.interpreter_params.tx_offset
    }

    /// Get max_message_data_length value
    pub fn max_message_data_length(&self) -> u64 {
        self.interpreter_params.max_message_data_length
    }

    /// Get the chain id
    pub fn chain_id(&self) -> ChainId {
        self.interpreter_params.chain_id
    }

    /// Receipts generated by a transaction execution.
    pub fn receipts(&self) -> &[Receipt] {
        self.receipts.as_ref().as_slice()
    }

    /// Compute current receipts root
    pub fn compute_receipts_root(&self) -> Bytes32 {
        self.receipts.root()
    }

    /// Mutable access to receipts for testing purposes.
    #[cfg(any(test, feature = "test-helpers"))]
    pub fn receipts_mut(&mut self) -> &mut ReceiptsCtx {
        &mut self.receipts
    }

    pub(crate) fn contract_id(&self) -> Option<ContractId> {
        self.frames.last().map(|frame| *frame.to())
    }

    /// Reference to the underlying profiler
    #[cfg(feature = "profile-any")]
    pub const fn profiler(&self) -> &Profiler {
        &self.profiler
    }
}

pub(crate) fn flags(flag: Reg<FLAG>) -> Flags {
    Flags::from_bits_truncate(*flag)
}

pub(crate) fn is_wrapping(flag: Reg<FLAG>) -> bool {
    flags(flag).contains(Flags::WRAPPING)
}

pub(crate) fn is_unsafe_math(flag: Reg<FLAG>) -> bool {
    flags(flag).contains(Flags::UNSAFEMATH)
}

#[cfg(feature = "profile-gas")]
fn current_location(
    current_contract: Option<ContractId>,
    pc: crate::constraints::reg_key::Reg<{ crate::constraints::reg_key::PC }>,
    is: crate::constraints::reg_key::Reg<{ crate::constraints::reg_key::IS }>,
) -> InstructionLocation {
    // Safety: pc should always be above is, but fallback to zero here for weird cases,
    //         as the profiling code should be robust against regards cases like this.
    let offset = (*pc).saturating_sub(*is);
    InstructionLocation::new(current_contract, offset)
}

impl<M, S, Tx, Ecal> AsRef<S> for Interpreter<M, S, Tx, Ecal> {
    fn as_ref(&self) -> &S {
        &self.storage
    }
}

impl<M, S, Tx, Ecal> AsMut<S> for Interpreter<M, S, Tx, Ecal> {
    fn as_mut(&mut self) -> &mut S {
        &mut self.storage
    }
}

/// The definition of the executable transaction supported by the `Interpreter`.
pub trait ExecutableTransaction:
    Default
    + Clone
    + Chargeable
    + Executable
    + IntoChecked
    + EstimatePredicates
    + UniqueIdentifier
    + field::Outputs
    + field::Witnesses
    + Into<Transaction>
    + PrepareSign
    + fuel_types::canonical::Serialize
{
    /// Casts the `Self` transaction into `&Script` if any.
    fn as_script(&self) -> Option<&Script> {
        None
    }

    /// Casts the `Self` transaction into `&mut Script` if any.
    fn as_script_mut(&mut self) -> Option<&mut Script> {
        None
    }

    /// Casts the `Self` transaction into `&Create` if any.
    fn as_create(&self) -> Option<&Create> {
        None
    }

    /// Casts the `Self` transaction into `&mut Create` if any.
    fn as_create_mut(&mut self) -> Option<&mut Create> {
        None
    }

    /// Casts the `Self` transaction into `&Upgrade` if any.
    fn as_upgrade(&self) -> Option<&Upgrade> {
        None
    }

    /// Casts the `Self` transaction into `&mut Upgrade` if any.
    fn as_upgrade_mut(&mut self) -> Option<&mut Upgrade> {
        None
    }

    /// Casts the `Self` transaction into `&Upload` if any.
    fn as_upload(&self) -> Option<&Upload> {
        None
    }

    /// Casts the `Self` transaction into `&mut Upload` if any.
    fn as_upload_mut(&mut self) -> Option<&mut Upload> {
        None
    }

    /// Casts the `Self` transaction into `&Blob` if any.
    fn as_blob(&self) -> Option<&Blob> {
        None
    }

    /// Casts the `Self` transaction into `&mut Blob` if any.
    fn as_blob_mut(&mut self) -> Option<&mut Blob> {
        None
    }

    /// Returns the type of the transaction like `Transaction::Create` or
    /// `Transaction::Script`.
    fn transaction_type() -> Word;

    /// Replaces the `Output::Variable` with the `output`(should be also
    /// `Output::Variable`) by the `idx` index.
    fn replace_variable_output(
        &mut self,
        idx: usize,
        output: Output,
    ) -> SimpleResult<()> {
        if !output.is_variable() {
            return Err(PanicReason::ExpectedOutputVariable.into());
        }

        // TODO increase the error granularity for this case - create a new variant of
        // panic reason
        self.outputs_mut()
            .get_mut(idx)
            .and_then(|o| match o {
                Output::Variable { amount, .. } if amount == &0 => Some(o),
                _ => None,
            })
            .map(|o| mem::replace(o, output))
            .ok_or(PanicReason::OutputNotFound)?;
        Ok(())
    }

    /// Update change and variable outputs.
    ///
    /// `revert` will signal if the execution was reverted. It will refund the unused gas
    /// cost to the base asset and reset output changes to their `initial_balances`.
    ///
    /// `remaining_gas` expects the raw content of `$ggas`
    ///
    /// `initial_balances` contains the initial state of the free balances
    ///
    /// `balances` will contain the current state of the free balances
    #[allow(clippy::too_many_arguments)]
    fn update_outputs<I>(
        &mut self,
        revert: bool,
        used_gas: Word,
        initial_balances: &InitialBalances,
        balances: &I,
        gas_costs: &GasCosts,
        fee_params: &FeeParameters,
        base_asset_id: &AssetId,
        gas_price: Word,
    ) -> Result<(), ValidityError>
    where
        I: for<'a> Index<&'a AssetId, Output = Word>,
    {
        let gas_refund = self
            .refund_fee(gas_costs, fee_params, used_gas, gas_price)
            .ok_or(ValidityError::GasCostsCoinsOverflow)?;

        self.outputs_mut().iter_mut().try_for_each(|o| match o {
            // If revert, set base asset to initial balance and refund unused gas
            //
            // Note: the initial balance deducts the gas limit from base asset
            Output::Change {
                asset_id, amount, ..
            } if revert && asset_id == base_asset_id => initial_balances.non_retryable
                [base_asset_id]
                .checked_add(gas_refund)
                .map(|v| *amount = v)
                .ok_or(ValidityError::BalanceOverflow),

            // If revert, reset any non-base asset to its initial balance
            Output::Change {
                asset_id, amount, ..
            } if revert => {
                *amount = initial_balances.non_retryable[asset_id];
                Ok(())
            }

            // The change for the base asset will be the available balance + unused gas
            Output::Change {
                asset_id, amount, ..
            } if asset_id == base_asset_id => balances[asset_id]
                .checked_add(gas_refund)
                .map(|v| *amount = v)
                .ok_or(ValidityError::BalanceOverflow),

            // Set changes to the remainder provided balances
            Output::Change {
                asset_id, amount, ..
            } => {
                *amount = balances[asset_id];
                Ok(())
            }

            // If revert, zeroes all variable output values
            Output::Variable { amount, .. } if revert => {
                *amount = 0;
                Ok(())
            }

            // Other outputs are unaffected
            _ => Ok(()),
        })
    }
}

impl ExecutableTransaction for Create {
    fn as_create(&self) -> Option<&Create> {
        Some(self)
    }

    fn as_create_mut(&mut self) -> Option<&mut Create> {
        Some(self)
    }

    fn transaction_type() -> Word {
        TransactionRepr::Create as Word
    }
}

impl ExecutableTransaction for Script {
    fn as_script(&self) -> Option<&Script> {
        Some(self)
    }

    fn as_script_mut(&mut self) -> Option<&mut Script> {
        Some(self)
    }

    fn transaction_type() -> Word {
        TransactionRepr::Script as Word
    }
}

impl ExecutableTransaction for Upgrade {
    fn as_upgrade(&self) -> Option<&Upgrade> {
        Some(self)
    }

    fn as_upgrade_mut(&mut self) -> Option<&mut Upgrade> {
        Some(self)
    }

    fn transaction_type() -> Word {
        TransactionRepr::Upgrade as Word
    }
}

impl ExecutableTransaction for Upload {
    fn as_upload(&self) -> Option<&Upload> {
        Some(self)
    }

    fn as_upload_mut(&mut self) -> Option<&mut Upload> {
        Some(self)
    }

    fn transaction_type() -> Word {
        TransactionRepr::Upload as Word
    }
}

impl ExecutableTransaction for Blob {
    fn as_blob(&self) -> Option<&Blob> {
        Some(self)
    }

    fn as_blob_mut(&mut self) -> Option<&mut Blob> {
        Some(self)
    }

    fn transaction_type() -> Word {
        TransactionRepr::Blob as Word
    }
}

/// The initial balances of the transaction.
#[derive(Default, Debug, Clone, Eq, PartialEq, Hash)]
pub struct InitialBalances {
    /// See [`NonRetryableFreeBalances`].
    pub non_retryable: NonRetryableFreeBalances,
    /// See [`RetryableAmount`].
    pub retryable: Option<RetryableAmount>,
}

/// Methods that should be implemented by the checked metadata of supported transactions.
pub trait CheckedMetadata {
    /// Returns the initial balances from the checked metadata of the transaction.
    fn balances(&self) -> InitialBalances;
}

impl CheckedMetadata for ScriptCheckedMetadata {
    fn balances(&self) -> InitialBalances {
        InitialBalances {
            non_retryable: self.non_retryable_balances.clone(),
            retryable: Some(self.retryable_balance),
        }
    }
}

impl CheckedMetadata for CreateCheckedMetadata {
    fn balances(&self) -> InitialBalances {
        InitialBalances {
            non_retryable: self.free_balances.clone(),
            retryable: None,
        }
    }
}

impl CheckedMetadata for UpgradeCheckedMetadata {
    fn balances(&self) -> InitialBalances {
        InitialBalances {
            non_retryable: self.free_balances.clone(),
            retryable: None,
        }
    }
}

impl CheckedMetadata for UploadCheckedMetadata {
    fn balances(&self) -> InitialBalances {
        InitialBalances {
            non_retryable: self.free_balances.clone(),
            retryable: None,
        }
    }
}

impl CheckedMetadata for BlobCheckedMetadata {
    fn balances(&self) -> InitialBalances {
        InitialBalances {
            non_retryable: self.free_balances.clone(),
            retryable: None,
        }
    }
}

pub(crate) struct InputContracts<'vm> {
    input_contracts: &'vm alloc::collections::BTreeSet<ContractId>,
    panic_context: &'vm mut PanicContext,
}

impl<'vm> InputContracts<'vm> {
    pub fn new(
        input_contracts: &'vm alloc::collections::BTreeSet<ContractId>,
        panic_context: &'vm mut PanicContext,
    ) -> Self {
        Self {
            input_contracts,
            panic_context,
        }
    }

    /// Checks that the contract is declared in the transaction inputs.
    pub fn check(&mut self, contract: &ContractId) -> SimpleResult<()> {
        if !self.input_contracts.contains(contract) {
            *self.panic_context = PanicContext::ContractId(*contract);
            Err(PanicReason::ContractNotInInputs.into())
        } else {
            Ok(())
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/checked_transaction/builder.rs

Source
//! Extension trait for [`fuel_tx::TransactionBuilder`]

use super::{
    Checked,
    IntoChecked,
};
use crate::{
    checked_transaction::CheckPredicates,
    prelude::*,
    storage::predicate::PredicateStorageRequirements,
};
use fuel_tx::{
    Finalizable,
    TransactionBuilder,
};
use fuel_types::BlockHeight;

/// Extension trait for [`fuel_tx::TransactionBuilder`] adding finalization methods
pub trait TransactionBuilderExt<Tx>
where
    Tx: IntoChecked,
{
    /// Finalize the builder into a [`Checked<Tx>`] of the correct type
    fn finalize_checked(&self, height: BlockHeight) -> Checked<Tx>;

    /// Finalize the builder into a [`Checked<Tx>`] of the correct type
    /// using the storage during verification.
    fn finalize_checked_with_storage(
        &self,
        height: BlockHeight,
        storage: &impl PredicateStorageRequirements,
    ) -> Checked<Tx>;

    /// Finalize the builder into a [`Checked<Tx>`] of the correct type, with basic checks
    /// only
    fn finalize_checked_basic(&self, height: BlockHeight) -> Checked<Tx>;
}

impl<Tx: ExecutableTransaction> TransactionBuilderExt<Tx> for TransactionBuilder<Tx>
where
    Self: Finalizable<Tx>,
    Checked<Tx>: CheckPredicates,
{
    fn finalize_checked(&self, height: BlockHeight) -> Checked<Tx> {
        self.finalize()
            .into_checked(height, self.get_params())
            .expect("failed to check tx")
    }

    fn finalize_checked_with_storage(
        &self,
        height: BlockHeight,
        storage: &impl PredicateStorageRequirements,
    ) -> Checked<Tx> {
        self.finalize()
            .into_checked_reusable_memory(
                height,
                self.get_params(),
                MemoryInstance::new(),
                storage,
            )
            .expect("failed to check tx")
    }

    fn finalize_checked_basic(&self, height: BlockHeight) -> Checked<Tx> {
        self.finalize()
            .into_checked_basic(height, self.get_params())
            .expect("failed to check tx")
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/checked_transaction/types.rs

Source
//! Implementation for different transaction types, groupd in submodules.

pub use self::{
    blob::CheckedMetadata as BlobCheckedMetadata,
    create::CheckedMetadata as CreateCheckedMetadata,
    script::CheckedMetadata as ScriptCheckedMetadata,
    upgrade::CheckedMetadata as UpgradeCheckedMetadata,
    upload::CheckedMetadata as UploadCheckedMetadata,
};
use alloc::collections::BTreeMap;
use fuel_types::{
    AssetId,
    Word,
};

/// The spendable unrestricted initial assets.
/// More information about it in the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/tx-validity.md#sufficient-balance>
#[derive(Default, Debug, Clone, Eq, PartialEq, Hash)]
pub struct NonRetryableFreeBalances(pub(crate) BTreeMap<AssetId, Word>);

impl From<NonRetryableFreeBalances> for BTreeMap<AssetId, Word> {
    fn from(value: NonRetryableFreeBalances) -> Self {
        value.0
    }
}

impl core::ops::Deref for NonRetryableFreeBalances {
    type Target = BTreeMap<AssetId, Word>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// The spendable only during execution [`AssetId::BASE`] asset.
/// More information about it in the specification:
/// <https://github.com/FuelLabs/fuel-specs/blob/master/src/protocol/tx-validity.md#sufficient-balance>
#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct RetryableAmount {
    pub(crate) amount: Word,
    pub(crate) base_asset_id: AssetId,
}

impl From<RetryableAmount> for Word {
    fn from(value: RetryableAmount) -> Self {
        value.amount
    }
}

impl core::ops::Deref for RetryableAmount {
    type Target = Word;

    fn deref(&self) -> &Self::Target {
        &self.amount
    }
}

/// For [`fuel_tx::Create`]
pub mod create {
    use super::super::{
        balances::{
            initial_free_balances,
            AvailableBalances,
        },
        Checked,
        IntoChecked,
    };
    use crate::checked_transaction::{
        CheckError,
        NonRetryableFreeBalances,
    };
    use fuel_tx::{
        Cacheable,
        Chargeable,
        ConsensusParameters,
        Create,
        FormatValidityChecks,
    };
    use fuel_types::{
        AssetId,
        BlockHeight,
    };

    /// Metadata produced by checking [`fuel_tx::Create`].
    #[derive(Debug, Clone, Eq, PartialEq, Hash)]
    pub struct CheckedMetadata {
        /// The base asset id.
        pub base_asset_id: AssetId,
        /// See [`NonRetryableFreeBalances`].
        pub free_balances: NonRetryableFreeBalances,
        /// The block height this tx was verified with
        pub block_height: BlockHeight,
        /// The minimum gas required for this transaction.
        pub min_gas: u64,
        /// The maximum gas required for this transaction.
        pub max_gas: u64,
    }

    impl IntoChecked for Create {
        type Metadata = CheckedMetadata;

        fn into_checked_basic(
            mut self,
            block_height: BlockHeight,
            consensus_params: &ConsensusParameters,
        ) -> Result<Checked<Self>, CheckError> {
            let chain_id = consensus_params.chain_id();
            self.precompute(&chain_id)?;
            self.check_without_signatures(block_height, consensus_params)?;

            // validate fees and compute free balances
            let AvailableBalances {
                non_retryable_balances,
                retryable_balance,
            } = initial_free_balances(&self, consensus_params.base_asset_id())?;
            debug_assert_eq!(
                retryable_balance, 0,
                "The `check_without_signatures` should return `TransactionInputContainsMessageData` above"
            );

            let metadata = CheckedMetadata {
                base_asset_id: *consensus_params.base_asset_id(),
                free_balances: NonRetryableFreeBalances(non_retryable_balances),
                block_height,
                min_gas: self
                    .min_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
                max_gas: self
                    .max_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
            };

            Ok(Checked::basic(self, metadata))
        }
    }
}

/// For [`fuel_tx::Mint`]
pub mod mint {
    use super::super::{
        Checked,
        IntoChecked,
    };
    use crate::checked_transaction::CheckError;
    use fuel_tx::{
        Cacheable,
        ConsensusParameters,
        FormatValidityChecks,
        Mint,
    };
    use fuel_types::BlockHeight;

    impl IntoChecked for Mint {
        type Metadata = ();

        fn into_checked_basic(
            mut self,
            block_height: BlockHeight,
            consensus_params: &ConsensusParameters,
        ) -> Result<Checked<Self>, CheckError> {
            let chain_id = consensus_params.chain_id();
            self.precompute(&chain_id)?;
            self.check_without_signatures(block_height, consensus_params)?;

            Ok(Checked::basic(self, ()))
        }
    }
}

/// For [`fuel_tx::Script`]
pub mod script {
    use super::super::{
        balances::{
            initial_free_balances,
            AvailableBalances,
        },
        Checked,
        IntoChecked,
    };
    use crate::checked_transaction::{
        CheckError,
        NonRetryableFreeBalances,
        RetryableAmount,
    };
    use fuel_tx::{
        Cacheable,
        Chargeable,
        ConsensusParameters,
        FormatValidityChecks,
        Script,
    };
    use fuel_types::{
        AssetId,
        BlockHeight,
    };

    /// Metadata produced by checking [`fuel_tx::Script`].
    #[derive(Debug, Clone, Eq, PartialEq, Hash)]
    pub struct CheckedMetadata {
        /// The base asset id.
        pub base_asset_id: AssetId,
        /// See [`NonRetryableFreeBalances`].
        pub non_retryable_balances: NonRetryableFreeBalances,
        /// See [`RetryableAmount`].
        pub retryable_balance: RetryableAmount,
        /// The block height this tx was verified with
        pub block_height: BlockHeight,
        /// The minimum gas required for this transaction.
        pub min_gas: u64,
        /// The maximum gas required for this transaction.
        pub max_gas: u64,
    }

    impl IntoChecked for Script {
        type Metadata = CheckedMetadata;

        fn into_checked_basic(
            mut self,
            block_height: BlockHeight,
            consensus_params: &ConsensusParameters,
        ) -> Result<Checked<Self>, CheckError> {
            let chain_id = consensus_params.chain_id();
            self.precompute(&chain_id)?;
            self.check_without_signatures(block_height, consensus_params)?;

            // validate fees and compute free balances
            let AvailableBalances {
                non_retryable_balances,
                retryable_balance,
            } = initial_free_balances(&self, consensus_params.base_asset_id())?;

            let metadata = CheckedMetadata {
                base_asset_id: *consensus_params.base_asset_id(),
                non_retryable_balances: NonRetryableFreeBalances(non_retryable_balances),
                retryable_balance: RetryableAmount {
                    amount: retryable_balance,
                    base_asset_id: *consensus_params.base_asset_id(),
                },
                block_height,
                min_gas: self
                    .min_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
                max_gas: self
                    .max_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
            };

            Ok(Checked::basic(self, metadata))
        }
    }
}

/// For [`fuel_tx::Upgrade`]
pub mod upgrade {
    use super::super::{
        balances::{
            initial_free_balances,
            AvailableBalances,
        },
        Checked,
        IntoChecked,
    };
    use crate::checked_transaction::{
        CheckError,
        NonRetryableFreeBalances,
    };
    use fuel_tx::{
        Cacheable,
        Chargeable,
        ConsensusParameters,
        FormatValidityChecks,
        Upgrade,
    };
    use fuel_types::{
        AssetId,
        BlockHeight,
    };

    /// Metadata produced by checking [`fuel_tx::Upgrade`].
    #[derive(Debug, Clone, Eq, PartialEq, Hash)]
    pub struct CheckedMetadata {
        /// The base asset id.
        pub base_asset_id: AssetId,
        /// See [`NonRetryableFreeBalances`].
        pub free_balances: NonRetryableFreeBalances,
        /// The block height this tx was verified with
        pub block_height: BlockHeight,
        /// The minimum gas required for this transaction.
        pub min_gas: u64,
        /// The maximum gas required for this transaction.
        pub max_gas: u64,
    }

    impl IntoChecked for Upgrade {
        type Metadata = CheckedMetadata;

        fn into_checked_basic(
            mut self,
            block_height: BlockHeight,
            consensus_params: &ConsensusParameters,
        ) -> Result<Checked<Self>, CheckError> {
            let chain_id = consensus_params.chain_id();
            self.precompute(&chain_id)?;
            self.check_without_signatures(block_height, consensus_params)?;

            // validate fees and compute free balances
            let AvailableBalances {
                non_retryable_balances,
                retryable_balance,
            } = initial_free_balances(&self, consensus_params.base_asset_id())?;
            debug_assert_eq!(
                retryable_balance, 0,
                "The `check_without_signatures` should return `TransactionInputContainsMessageData` above"
            );

            let metadata = CheckedMetadata {
                base_asset_id: *consensus_params.base_asset_id(),
                free_balances: NonRetryableFreeBalances(non_retryable_balances),
                block_height,
                min_gas: self
                    .min_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
                max_gas: self
                    .max_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
            };

            Ok(Checked::basic(self, metadata))
        }
    }
}

/// For [`fuel_tx::Upload`]
pub mod upload {
    use super::super::{
        balances::{
            initial_free_balances,
            AvailableBalances,
        },
        Checked,
        IntoChecked,
    };
    use crate::checked_transaction::{
        CheckError,
        NonRetryableFreeBalances,
    };
    use fuel_tx::{
        Cacheable,
        Chargeable,
        ConsensusParameters,
        FormatValidityChecks,
        Upload,
    };
    use fuel_types::{
        AssetId,
        BlockHeight,
    };

    /// Metadata produced by checking [`fuel_tx::Upload`].
    #[derive(Debug, Clone, Eq, PartialEq, Hash)]
    pub struct CheckedMetadata {
        /// The base asset id.
        pub base_asset_id: AssetId,
        /// See [`NonRetryableFreeBalances`].
        pub free_balances: NonRetryableFreeBalances,
        /// The block height this tx was verified with
        pub block_height: BlockHeight,
        /// The minimum gas required for this transaction.
        pub min_gas: u64,
        /// The maximum gas required for this transaction.
        pub max_gas: u64,
    }

    impl IntoChecked for Upload {
        type Metadata = CheckedMetadata;

        fn into_checked_basic(
            mut self,
            block_height: BlockHeight,
            consensus_params: &ConsensusParameters,
        ) -> Result<Checked<Self>, CheckError> {
            let chain_id = consensus_params.chain_id();
            self.precompute(&chain_id)?;
            self.check_without_signatures(block_height, consensus_params)?;

            // validate fees and compute free balances
            let AvailableBalances {
                non_retryable_balances,
                retryable_balance,
            } = initial_free_balances(&self, consensus_params.base_asset_id())?;
            debug_assert_eq!(
                retryable_balance, 0,
                "The `check_without_signatures` should return `TransactionInputContainsMessageData` above"
            );

            let metadata = CheckedMetadata {
                base_asset_id: *consensus_params.base_asset_id(),
                free_balances: NonRetryableFreeBalances(non_retryable_balances),
                block_height,
                min_gas: self
                    .min_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
                max_gas: self
                    .max_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
            };

            Ok(Checked::basic(self, metadata))
        }
    }
}

/// For [`fuel_tx::Blob`]
pub mod blob {
    use super::super::{
        balances::{
            initial_free_balances,
            AvailableBalances,
        },
        Checked,
        IntoChecked,
    };
    use crate::checked_transaction::{
        CheckError,
        NonRetryableFreeBalances,
    };
    use fuel_tx::{
        AssetId,
        Blob,
        Cacheable,
        Chargeable,
        ConsensusParameters,
        FormatValidityChecks,
    };
    use fuel_types::BlockHeight;

    /// Metadata produced by checking [`fuel_tx::Blob`].
    #[derive(Debug, Clone, Eq, PartialEq, Hash)]
    pub struct CheckedMetadata {
        /// The base asset id.
        pub base_asset_id: AssetId,
        /// See [`NonRetryableFreeBalances`].
        pub free_balances: NonRetryableFreeBalances,
        /// The block height this tx was verified with
        pub block_height: BlockHeight,
        /// The minimum gas required for this transaction.
        pub min_gas: u64,
        /// The maximum gas required for this transaction.
        pub max_gas: u64,
    }

    impl IntoChecked for Blob {
        type Metadata = CheckedMetadata;

        fn into_checked_basic(
            mut self,
            block_height: BlockHeight,
            consensus_params: &ConsensusParameters,
        ) -> Result<Checked<Self>, CheckError> {
            let chain_id = consensus_params.chain_id();
            self.precompute(&chain_id)?;
            self.check_without_signatures(block_height, consensus_params)?;

            // validate fees and compute free balances
            let AvailableBalances {
                non_retryable_balances,
                retryable_balance,
            } = initial_free_balances(&self, consensus_params.base_asset_id())?;
            debug_assert_eq!(
                retryable_balance, 0,
                "The `check_without_signatures` should return `TransactionInputContainsMessageData` above"
            );

            let metadata = CheckedMetadata {
                base_asset_id: *consensus_params.base_asset_id(),
                free_balances: NonRetryableFreeBalances(non_retryable_balances),
                block_height,
                min_gas: self
                    .min_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
                max_gas: self
                    .max_gas(consensus_params.gas_costs(), consensus_params.fee_params()),
            };

            Ok(Checked::basic(self, metadata))
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/checked_transaction/balances.rs

Source
use fuel_tx::{
    field,
    input::{
        coin::{
            CoinPredicate,
            CoinSigned,
        },
        message::{
            MessageCoinPredicate,
            MessageCoinSigned,
            MessageDataPredicate,
            MessageDataSigned,
        },
    },
    Chargeable,
    Input,
    Output,
    ValidityError,
};
use fuel_types::{
    AssetId,
    Word,
};

use alloc::collections::BTreeMap;
use fuel_tx::policies::PolicyType;

pub(crate) fn initial_free_balances<T>(
    tx: &T,
    base_asset_id: &AssetId,
) -> Result<AvailableBalances, ValidityError>
where
    T: Chargeable + field::Inputs + field::Outputs,
{
    let (mut non_retryable_balances, retryable_balance) =
        add_up_input_balances(tx, base_asset_id).ok_or(ValidityError::BalanceOverflow)?;

    let max_fee = tx
        .policies()
        .get(PolicyType::MaxFee)
        .ok_or(ValidityError::TransactionMaxFeeNotSet)?;
    deduct_max_fee_from_base_asset(&mut non_retryable_balances, base_asset_id, max_fee)?;

    reduce_free_balances_by_coin_outputs(&mut non_retryable_balances, tx)?;

    Ok(AvailableBalances {
        non_retryable_balances,
        retryable_balance,
    })
}

/// Returns None if any of the balances would overflow.
fn add_up_input_balances<T: field::Inputs>(
    transaction: &T,
    base_asset_id: &AssetId,
) -> Option<(BTreeMap<AssetId, Word>, Word)> {
    let mut non_retryable_balances = BTreeMap::<AssetId, Word>::new();
    // The sum of [`AssetId::Base`] from metadata messages.
    let mut retryable_balance: Word = 0;

    // Add up all the inputs for each asset ID
    for input in transaction.inputs().iter() {
        match input {
            // Sum coin inputs
            Input::CoinPredicate(CoinPredicate {
                asset_id, amount, ..
            })
            | Input::CoinSigned(CoinSigned {
                asset_id, amount, ..
            }) => {
                let balance = non_retryable_balances.entry(*asset_id).or_default();
                *balance = (*balance).checked_add(*amount)?;
            }
            // Sum message coin inputs
            Input::MessageCoinSigned(MessageCoinSigned { amount, .. })
            | Input::MessageCoinPredicate(MessageCoinPredicate { amount, .. }) => {
                let balance = non_retryable_balances.entry(*base_asset_id).or_default();
                *balance = (*balance).checked_add(*amount)?;
            }
            // Sum data messages
            Input::MessageDataSigned(MessageDataSigned { amount, .. })
            | Input::MessageDataPredicate(MessageDataPredicate { amount, .. }) => {
                retryable_balance = retryable_balance.checked_add(*amount)?;
            }
            Input::Contract(_) => {}
        }
    }

    Some((non_retryable_balances, retryable_balance))
}

fn deduct_max_fee_from_base_asset(
    non_retryable_balances: &mut BTreeMap<AssetId, Word>,
    base_asset_id: &AssetId,
    max_fee: Word,
) -> Result<(), ValidityError> {
    let base_asset_balance = non_retryable_balances.entry(*base_asset_id).or_default();
    *base_asset_balance = base_asset_balance.checked_sub(max_fee).ok_or(
        ValidityError::InsufficientFeeAmount {
            expected: max_fee,
            provided: *base_asset_balance,
        },
    )?;

    Ok(())
}

fn reduce_free_balances_by_coin_outputs(
    non_retryable_balances: &mut BTreeMap<AssetId, Word>,
    transaction: &impl field::Outputs,
) -> Result<(), ValidityError> {
    // reduce free balances by coin outputs
    for (asset_id, amount) in
        transaction
            .outputs()
            .iter()
            .filter_map(|output| match output {
                Output::Coin {
                    asset_id, amount, ..
                } => Some((asset_id, amount)),
                _ => None,
            })
    {
        let balance = non_retryable_balances.get_mut(asset_id).ok_or(
            ValidityError::TransactionOutputCoinAssetIdNotFound(*asset_id),
        )?;
        *balance = balance.checked_sub(*amount).ok_or(
            ValidityError::InsufficientInputAmount {
                asset: *asset_id,
                expected: *amount,
                provided: *balance,
            },
        )?;
    }

    Ok(())
}

pub(crate) struct AvailableBalances {
    pub(crate) non_retryable_balances: BTreeMap<AssetId, Word>,
    pub(crate) retryable_balance: Word,
}

/home/marten/fuel/fuel-vm/fuel-vm/src/storage/predicate.rs

Source
//! The module contains storage requirements for the predicate execution.

use crate::{
    prelude::{
        InterpreterError,
        RuntimeError,
    },
    storage::InterpreterStorage,
};
use alloc::{
    borrow::Cow,
    string::String,
    vec::Vec,
};
use core::fmt::Debug;

use fuel_asm::Word;
use fuel_storage::{
    Mappable,
    StorageInspect,
    StorageMutate,
    StorageRead,
    StorageSize,
    StorageWrite,
};
use fuel_tx::ConsensusParameters;
use fuel_types::{
    BlobId,
    BlockHeight,
    Bytes32,
    ContractId,
};

use super::{
    interpreter::ContractsAssetsStorage,
    BlobData,
    ContractsAssets,
    ContractsRawCode,
    ContractsState,
    ContractsStateData,
    UploadedBytecodes,
};

/// Create an empty predicate storage.
pub fn empty_predicate_storage() -> PredicateStorage<EmptyStorage> {
    PredicateStorage::new(EmptyStorage)
}

/// No-op storage used for predicate operations.
///
/// The storage implementations are expected to provide KV-like operations for contract
/// operations. However, predicates, as defined in the protocol, cannot execute contract
/// opcodes. This means its storage backend for predicate execution shouldn't provide any
/// functionality. Unless the storage access is limited to immutable data and read-only.
#[derive(Debug, Default)]
pub struct PredicateStorage<D> {
    storage: D,
}

impl<D> PredicateStorage<D> {
    /// instantiate predicate storage with access to Blobs
    pub fn new(storage: D) -> Self {
        Self { storage }
    }
}

/// Errors that happen when using predicate storage
#[derive(Debug, Clone)]
pub enum PredicateStorageError {
    /// Storage operation is unavailable in predicate context.
    UnsupportedStorageOperation,
    /// An storage error occurred
    StorageError(String),
}

impl From<PredicateStorageError> for InterpreterError<PredicateStorageError> {
    fn from(val: PredicateStorageError) -> Self {
        let rt: RuntimeError<PredicateStorageError> = val.into();
        rt.into()
    }
}

impl From<PredicateStorageError> for RuntimeError<PredicateStorageError> {
    fn from(val: PredicateStorageError) -> Self {
        RuntimeError::Storage(val)
    }
}

/// Storage requirements for predicates.
pub trait PredicateStorageRequirements
where
    Self: StorageRead<BlobData>,
{
    /// Converts the storage error to a string.
    fn storage_error_to_string(error: Self::Error) -> String;
}

impl<D> PredicateStorageRequirements for &D
where
    D: PredicateStorageRequirements,
{
    fn storage_error_to_string(error: Self::Error) -> String {
        D::storage_error_to_string(error)
    }
}

/// The type that returns the predicate storage instance.
pub trait PredicateStorageProvider: Sync {
    /// The storage type.
    type Storage: PredicateStorageRequirements + Send + Sync + 'static;

    /// Returns the storage instance.
    fn storage(&self) -> Self::Storage;
}

/// Empty storage.
#[derive(Default, Debug, Clone, Copy)]
pub struct EmptyStorage;

impl StorageInspect<BlobData> for EmptyStorage {
    type Error = PredicateStorageError;

    fn get(
        &self,
        _: &BlobId,
    ) -> Result<Option<Cow<<BlobData as Mappable>::OwnedValue>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn contains_key(&self, _: &BlobId) -> Result<bool, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl StorageSize<BlobData> for EmptyStorage {
    fn size_of_value(&self, _: &BlobId) -> Result<Option<usize>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl StorageRead<BlobData> for EmptyStorage {
    fn read(&self, _: &BlobId, _: &mut [u8]) -> Result<Option<usize>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn read_alloc(&self, _: &BlobId) -> Result<Option<Vec<u8>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl PredicateStorageRequirements for EmptyStorage {
    fn storage_error_to_string(error: Self::Error) -> String {
        alloc::format!("{:?}", error)
    }
}

impl PredicateStorageProvider for EmptyStorage {
    type Storage = Self;

    fn storage(&self) -> Self::Storage {
        *self
    }
}

trait NoStorage {}

impl NoStorage for ContractsState {}
impl NoStorage for ContractsRawCode {}
impl NoStorage for ContractsAssets {}
impl NoStorage for UploadedBytecodes {}

impl<Type, D> StorageInspect<Type> for PredicateStorage<D>
where
    Type: Mappable + NoStorage,
{
    type Error = PredicateStorageError;

    fn get(
        &self,
        _key: &Type::Key,
    ) -> Result<Option<Cow<'_, Type::OwnedValue>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn contains_key(&self, _key: &Type::Key) -> Result<bool, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageInspect<BlobData> for PredicateStorage<D>
where
    D: PredicateStorageRequirements,
{
    type Error = PredicateStorageError;

    fn get(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<Cow<'_, <BlobData as Mappable>::OwnedValue>>, Self::Error> {
        <D as StorageInspect<BlobData>>::get(&self.storage, key)
            .map_err(|e| Self::Error::StorageError(D::storage_error_to_string(e)))
    }

    fn contains_key(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<bool, Self::Error> {
        <D as StorageInspect<BlobData>>::contains_key(&self.storage, key)
            .map_err(|e| Self::Error::StorageError(D::storage_error_to_string(e)))
    }
}

impl<Type, D> StorageMutate<Type> for PredicateStorage<D>
where
    Type: Mappable,
    Self: StorageInspect<Type, Error = PredicateStorageError>,
{
    fn replace(
        &mut self,
        _key: &Type::Key,
        _value: &Type::Value,
    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn take(
        &mut self,
        _key: &Type::Key,
    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageSize<ContractsRawCode> for PredicateStorage<D> {
    fn size_of_value(&self, _key: &ContractId) -> Result<Option<usize>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageRead<ContractsRawCode> for PredicateStorage<D> {
    fn read(
        &self,
        _key: &<ContractsRawCode as Mappable>::Key,
        _buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn read_alloc(
        &self,
        _key: &<ContractsRawCode as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageWrite<ContractsRawCode> for PredicateStorage<D> {
    fn write_bytes(
        &mut self,
        _key: &<ContractsRawCode as Mappable>::Key,
        _buf: &[u8],
    ) -> Result<usize, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn replace_bytes(
        &mut self,
        _key: &<ContractsRawCode as Mappable>::Key,
        _buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn take_bytes(
        &mut self,
        _key: &<ContractsRawCode as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageSize<ContractsState> for PredicateStorage<D> {
    fn size_of_value(
        &self,
        _key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<usize>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageRead<ContractsState> for PredicateStorage<D> {
    fn read(
        &self,
        _key: &<ContractsState as Mappable>::Key,
        _buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn read_alloc(
        &self,
        _key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageWrite<ContractsState> for PredicateStorage<D> {
    fn write_bytes(
        &mut self,
        _key: &<ContractsState as Mappable>::Key,
        _buf: &[u8],
    ) -> Result<usize, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn replace_bytes(
        &mut self,
        _key: &<ContractsState as Mappable>::Key,
        _buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn take_bytes(
        &mut self,
        _key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> StorageSize<BlobData> for PredicateStorage<D>
where
    D: PredicateStorageRequirements,
{
    fn size_of_value(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<usize>, Self::Error> {
        StorageSize::<BlobData>::size_of_value(&self.storage, key)
            .map_err(|e| Self::Error::StorageError(D::storage_error_to_string(e)))
    }
}

impl<D> StorageRead<BlobData> for PredicateStorage<D>
where
    D: PredicateStorageRequirements,
{
    fn read(
        &self,
        key: &<BlobData as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        StorageRead::<BlobData>::read(&self.storage, key, buf)
            .map_err(|e| Self::Error::StorageError(D::storage_error_to_string(e)))
    }

    fn read_alloc(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        StorageRead::<BlobData>::read_alloc(&self.storage, key)
            .map_err(|e| Self::Error::StorageError(D::storage_error_to_string(e)))
    }
}

impl<D> StorageWrite<BlobData> for PredicateStorage<D>
where
    D: PredicateStorageRequirements,
{
    fn write_bytes(
        &mut self,
        _key: &<BlobData as Mappable>::Key,
        _buf: &[u8],
    ) -> Result<usize, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn replace_bytes(
        &mut self,
        _key: &<BlobData as Mappable>::Key,
        _buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }

    fn take_bytes(
        &mut self,
        _key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Err(Self::Error::UnsupportedStorageOperation)
    }
}

impl<D> ContractsAssetsStorage for PredicateStorage<D> {}

impl<D> InterpreterStorage for PredicateStorage<D>
where
    D: PredicateStorageRequirements,
{
    type DataError = PredicateStorageError;

    fn block_height(&self) -> Result<BlockHeight, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn consensus_parameters_version(&self) -> Result<u32, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn state_transition_version(&self) -> Result<u32, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn timestamp(&self, _height: BlockHeight) -> Result<Word, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn block_hash(&self, _block_height: BlockHeight) -> Result<Bytes32, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn coinbase(&self) -> Result<ContractId, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn set_consensus_parameters(
        &mut self,
        _version: u32,
        _consensus_parameters: &ConsensusParameters,
    ) -> Result<Option<ConsensusParameters>, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn set_state_transition_bytecode(
        &mut self,
        _version: u32,
        _hash: &Bytes32,
    ) -> Result<Option<Bytes32>, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn contract_state_range(
        &self,
        _id: &ContractId,
        _start_key: &Bytes32,
        _range: usize,
    ) -> Result<Vec<Option<Cow<ContractsStateData>>>, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn contract_state_insert_range<'a, I>(
        &mut self,
        _: &ContractId,
        _: &Bytes32,
        _: I,
    ) -> Result<usize, Self::DataError>
    where
        I: Iterator<Item = &'a [u8]>,
    {
        Err(Self::DataError::UnsupportedStorageOperation)
    }

    fn contract_state_remove_range(
        &mut self,
        _contract: &ContractId,
        _start_key: &Bytes32,
        _range: usize,
    ) -> Result<Option<()>, Self::DataError> {
        Err(Self::DataError::UnsupportedStorageOperation)
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/storage/memory.rs

Source
#![allow(clippy::cast_possible_truncation)]

use crate::storage::{
    ContractsAssetKey,
    ContractsAssets,
    ContractsRawCode,
    ContractsState,
    ContractsStateData,
    ContractsStateKey,
    InterpreterStorage,
    UploadedBytecode,
    UploadedBytecodes,
};

use fuel_crypto::Hasher;
use fuel_storage::{
    Mappable,
    StorageAsRef,
    StorageInspect,
    StorageMutate,
    StorageRead,
    StorageSize,
    StorageWrite,
};
use fuel_tx::{
    ConsensusParameters,
    Contract,
};
use fuel_types::{
    BlobId,
    BlockHeight,
    Bytes32,
    ContractId,
    Word,
};
use tai64::Tai64;

use super::{
    interpreter::ContractsAssetsStorage,
    BlobBytes,
    BlobData,
};

use crate::storage::predicate::PredicateStorageRequirements;
use alloc::{
    borrow::Cow,
    collections::BTreeMap,
    vec::Vec,
};
use core::convert::Infallible;

#[derive(Debug, Default, Clone, PartialEq, Eq)]
struct MemoryStorageInner {
    contracts: BTreeMap<ContractId, Contract>,
    balances: BTreeMap<ContractsAssetKey, Word>,
    contract_state: BTreeMap<ContractsStateKey, ContractsStateData>,
    blobs: BTreeMap<BlobId, BlobBytes>,
    /// Mapping from consensus parameters version to consensus parameters.
    consensus_parameters_versions: BTreeMap<u32, ConsensusParameters>,
    /// Mapping from state transition bytecode root to bytecode.
    state_transition_bytecodes: BTreeMap<Bytes32, UploadedBytecode>,
    /// Mapping from state transition bytecode version to hash.
    state_transition_bytecodes_versions: BTreeMap<u32, Bytes32>,
}

#[derive(Debug, Clone)]
/// In-memory storage implementation for the interpreter.
///
/// It tracks 3 states:
///
/// - memory: the transactions will be applied to this state.
/// - transacted: will receive the committed `memory` state.
/// - persisted: will receive the persisted `transacted` state.
pub struct MemoryStorage {
    block_height: BlockHeight,
    coinbase: ContractId,
    consensus_parameters_version: u32,
    state_transition_version: u32,
    memory: MemoryStorageInner,
    transacted: MemoryStorageInner,
    persisted: MemoryStorageInner,
}

impl MemoryStorage {
    /// Create a new memory storage.
    pub fn new(block_height: BlockHeight, coinbase: ContractId) -> Self {
        Self::new_with_versions(block_height, coinbase, 0, 0)
    }

    /// Create a new memory storage with versions.
    pub fn new_with_versions(
        block_height: BlockHeight,
        coinbase: ContractId,
        consensus_parameters_version: u32,
        state_transition_version: u32,
    ) -> Self {
        Self {
            block_height,
            coinbase,
            consensus_parameters_version,
            state_transition_version,
            memory: Default::default(),
            transacted: Default::default(),
            persisted: Default::default(),
        }
    }

    /// Iterate over all contract state in storage
    pub fn all_contract_state(
        &self,
    ) -> impl Iterator<Item = (&ContractsStateKey, &ContractsStateData)> {
        self.memory.contract_state.iter()
    }

    /// Fetch a mapping from the contract state.
    pub fn contract_state(
        &self,
        contract: &ContractId,
        key: &Bytes32,
    ) -> Cow<'_, ContractsStateData> {
        self.storage::<ContractsState>()
            .get(&(contract, key).into())
            .expect("Infallible")
            .unwrap_or(Cow::Owned(ContractsStateData::default()))
    }

    /// Set the transacted state to the memory state.
    pub fn commit(&mut self) {
        self.transacted = self.memory.clone();
    }

    /// Revert the memory state to the transacted state.
    pub fn revert(&mut self) {
        self.memory = self.transacted.clone();
    }

    /// Revert the memory and transacted changes to the persisted state.
    pub fn rollback(&mut self) {
        self.memory = self.persisted.clone();
        self.transacted = self.persisted.clone();
    }

    /// Persist the changes from transacted to memory+persisted state.
    pub fn persist(&mut self) {
        self.memory = self.transacted.clone();
        self.persisted = self.transacted.clone();
    }

    #[cfg(feature = "test-helpers")]
    /// Set the block height of the chain
    pub fn set_block_height(&mut self, block_height: BlockHeight) {
        self.block_height = block_height;
    }

    #[cfg(feature = "test-helpers")]
    /// Set the consensus parameters version
    pub fn set_consensus_parameters_version(
        &mut self,
        consensus_parameters_version: u32,
    ) {
        self.consensus_parameters_version = consensus_parameters_version;
    }

    #[cfg(feature = "test-helpers")]
    /// Set the state transition version
    pub fn set_state_transition_version(&mut self, state_transition_version: u32) {
        self.state_transition_version = state_transition_version;
    }

    #[cfg(feature = "test-helpers")]
    /// Returns mutable reference to the consensus parameters versions table.
    pub fn consensus_parameters_versions_mut(
        &mut self,
    ) -> &mut BTreeMap<u32, ConsensusParameters> {
        &mut self.memory.consensus_parameters_versions
    }

    #[cfg(feature = "test-helpers")]
    /// Returns mutable reference to the state transition bytecodes table.
    pub fn state_transition_bytecodes_mut(
        &mut self,
    ) -> &mut BTreeMap<Bytes32, UploadedBytecode> {
        &mut self.memory.state_transition_bytecodes
    }

    #[cfg(feature = "test-helpers")]
    /// Returns mutable reference to the state transition bytecodes versions table.
    pub fn state_transition_bytecodes_versions_mut(
        &mut self,
    ) -> &mut BTreeMap<u32, Bytes32> {
        &mut self.memory.state_transition_bytecodes_versions
    }
}

impl Default for MemoryStorage {
    fn default() -> Self {
        let block_height = 1.into();
        let coinbase = ContractId::from(*Hasher::hash(b"coinbase"));

        Self::new(block_height, coinbase)
    }
}

impl StorageInspect<ContractsRawCode> for MemoryStorage {
    type Error = Infallible;

    fn get(&self, key: &ContractId) -> Result<Option<Cow<'_, Contract>>, Infallible> {
        Ok(self.memory.contracts.get(key).map(Cow::Borrowed))
    }

    fn contains_key(&self, key: &ContractId) -> Result<bool, Infallible> {
        Ok(self.memory.contracts.contains_key(key))
    }
}

impl StorageMutate<ContractsRawCode> for MemoryStorage {
    fn replace(
        &mut self,
        key: &ContractId,
        value: &[u8],
    ) -> Result<Option<Contract>, Infallible> {
        Ok(self.memory.contracts.insert(*key, value.into()))
    }

    fn take(&mut self, key: &ContractId) -> Result<Option<Contract>, Infallible> {
        Ok(self.memory.contracts.remove(key))
    }
}

impl StorageWrite<ContractsRawCode> for MemoryStorage {
    fn write_bytes(&mut self, key: &ContractId, buf: &[u8]) -> Result<usize, Infallible> {
        let size = buf.len();
        self.memory.contracts.insert(*key, Contract::from(buf));
        Ok(size)
    }

    fn replace_bytes(
        &mut self,
        key: &ContractId,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error> {
        let size = buf.len();
        let prev = self
            .memory
            .contracts
            .insert(*key, Contract::from(buf))
            .map(Into::into);
        Ok((size, prev))
    }

    fn take_bytes(&mut self, key: &ContractId) -> Result<Option<Vec<u8>>, Self::Error> {
        let prev = self.memory.contracts.remove(key).map(Into::into);
        Ok(prev)
    }
}

impl StorageSize<ContractsRawCode> for MemoryStorage {
    fn size_of_value(&self, key: &ContractId) -> Result<Option<usize>, Infallible> {
        Ok(self.memory.contracts.get(key).map(|c| c.as_ref().len()))
    }
}

impl StorageRead<ContractsRawCode> for MemoryStorage {
    fn read(
        &self,
        key: &ContractId,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        Ok(self.memory.contracts.get(key).map(|c| {
            let len = buf.len().min(c.as_ref().len());
            buf.copy_from_slice(&c.as_ref()[..len]);
            len
        }))
    }

    fn read_alloc(&self, key: &ContractId) -> Result<Option<Vec<u8>>, Self::Error> {
        Ok(self.memory.contracts.get(key).map(|c| c.as_ref().to_vec()))
    }
}

impl StorageInspect<UploadedBytecodes> for MemoryStorage {
    type Error = Infallible;

    fn get(
        &self,
        key: &<UploadedBytecodes as Mappable>::Key,
    ) -> Result<Option<Cow<'_, UploadedBytecode>>, Infallible> {
        Ok(self
            .memory
            .state_transition_bytecodes
            .get(key)
            .map(Cow::Borrowed))
    }

    fn contains_key(
        &self,
        key: &<UploadedBytecodes as Mappable>::Key,
    ) -> Result<bool, Infallible> {
        Ok(self.memory.state_transition_bytecodes.contains_key(key))
    }
}

impl StorageMutate<UploadedBytecodes> for MemoryStorage {
    fn replace(
        &mut self,
        key: &<UploadedBytecodes as Mappable>::Key,
        value: &<UploadedBytecodes as Mappable>::Value,
    ) -> Result<Option<UploadedBytecode>, Infallible> {
        Ok(self
            .memory
            .state_transition_bytecodes
            .insert(*key, value.clone()))
    }

    fn take(
        &mut self,
        key: &<UploadedBytecodes as Mappable>::Key,
    ) -> Result<Option<UploadedBytecode>, Infallible> {
        Ok(self.memory.state_transition_bytecodes.remove(key))
    }
}

impl StorageInspect<ContractsAssets> for MemoryStorage {
    type Error = Infallible;

    fn get(
        &self,
        key: &<ContractsAssets as Mappable>::Key,
    ) -> Result<Option<Cow<'_, Word>>, Infallible> {
        Ok(self.memory.balances.get(key).map(Cow::Borrowed))
    }

    fn contains_key(
        &self,
        key: &<ContractsAssets as Mappable>::Key,
    ) -> Result<bool, Infallible> {
        Ok(self.memory.balances.contains_key(key))
    }
}

impl StorageMutate<ContractsAssets> for MemoryStorage {
    fn replace(
        &mut self,
        key: &<ContractsAssets as Mappable>::Key,
        value: &Word,
    ) -> Result<Option<Word>, Infallible> {
        Ok(self.memory.balances.insert(*key, *value))
    }

    fn take(
        &mut self,
        key: &<ContractsAssets as Mappable>::Key,
    ) -> Result<Option<Word>, Infallible> {
        Ok(self.memory.balances.remove(key))
    }
}

impl StorageInspect<ContractsState> for MemoryStorage {
    type Error = Infallible;

    fn get(
        &self,
        key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<Cow<'_, <ContractsState as Mappable>::OwnedValue>>, Infallible>
    {
        Ok(self.memory.contract_state.get(key).map(Cow::Borrowed))
    }

    fn contains_key(
        &self,
        key: &<ContractsState as Mappable>::Key,
    ) -> Result<bool, Infallible> {
        Ok(self.memory.contract_state.contains_key(key))
    }
}

impl StorageMutate<ContractsState> for MemoryStorage {
    fn replace(
        &mut self,
        key: &<ContractsState as Mappable>::Key,
        value: &<ContractsState as Mappable>::Value,
    ) -> Result<Option<<ContractsState as Mappable>::OwnedValue>, Infallible> {
        Ok(self.memory.contract_state.insert(*key, value.into()))
    }

    fn take(
        &mut self,
        key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<ContractsStateData>, Infallible> {
        Ok(self.memory.contract_state.remove(key))
    }
}

impl StorageWrite<ContractsState> for MemoryStorage {
    fn write_bytes(
        &mut self,
        key: &<ContractsState as Mappable>::Key,
        buf: &[u8],
    ) -> Result<usize, Infallible> {
        let size = buf.len();
        self.memory
            .contract_state
            .insert(*key, ContractsStateData::from(buf));
        Ok(size)
    }

    fn replace_bytes(
        &mut self,
        key: &<ContractsState as Mappable>::Key,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error>
    where
        Self: StorageSize<ContractsState>,
    {
        let size = buf.len();
        let prev = self
            .memory
            .contract_state
            .insert(*key, ContractsStateData::from(buf))
            .map(Into::into);
        Ok((size, prev))
    }

    fn take_bytes(
        &mut self,
        key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        let prev = self.memory.contract_state.remove(key).map(Into::into);
        Ok(prev)
    }
}

impl StorageSize<ContractsState> for MemoryStorage {
    fn size_of_value(
        &self,
        key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<usize>, Infallible> {
        Ok(self
            .memory
            .contract_state
            .get(key)
            .map(|c| c.as_ref().len()))
    }
}

impl StorageRead<ContractsState> for MemoryStorage {
    fn read(
        &self,
        key: &<ContractsState as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        Ok(self.memory.contract_state.get(key).map(|data| {
            let len = buf.len().min(data.as_ref().len());
            buf.copy_from_slice(&data.as_ref()[..len]);
            len
        }))
    }

    fn read_alloc(
        &self,
        key: &<ContractsState as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Ok(self
            .memory
            .contract_state
            .get(key)
            .map(|c| c.as_ref().to_vec()))
    }
}

impl StorageSize<BlobData> for MemoryStorage {
    fn size_of_value(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<usize>, Infallible> {
        Ok(self.memory.blobs.get(key).map(|c| c.as_ref().len()))
    }
}

impl StorageRead<BlobData> for MemoryStorage {
    fn read(
        &self,
        key: &<BlobData as Mappable>::Key,
        buf: &mut [u8],
    ) -> Result<Option<usize>, Self::Error> {
        Ok(self.memory.blobs.get(key).map(|data| {
            let len = buf.len().min(data.as_ref().len());
            buf.copy_from_slice(&data.as_ref()[..len]);
            len
        }))
    }

    fn read_alloc(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        Ok(self.memory.blobs.get(key).map(|c| c.as_ref().to_vec()))
    }
}

impl StorageInspect<BlobData> for MemoryStorage {
    type Error = Infallible;

    fn get(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<Cow<'_, <BlobData as Mappable>::OwnedValue>>, Infallible> {
        Ok(self.memory.blobs.get(key).map(Cow::Borrowed))
    }

    fn contains_key(
        &self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<bool, Infallible> {
        Ok(self.memory.blobs.contains_key(key))
    }
}

impl StorageMutate<BlobData> for MemoryStorage {
    fn replace(
        &mut self,
        key: &<BlobData as Mappable>::Key,
        value: &<BlobData as Mappable>::Value,
    ) -> Result<Option<<BlobData as Mappable>::OwnedValue>, Infallible> {
        Ok(self.memory.blobs.insert(*key, value.into()))
    }

    fn take(
        &mut self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<BlobBytes>, Infallible> {
        Ok(self.memory.blobs.remove(key))
    }
}

impl StorageWrite<BlobData> for MemoryStorage {
    fn write_bytes(
        &mut self,
        key: &<BlobData as Mappable>::Key,
        buf: &[u8],
    ) -> Result<usize, Infallible> {
        let size = buf.len();
        self.memory.blobs.insert(*key, BlobBytes::from(buf));
        Ok(size)
    }

    fn replace_bytes(
        &mut self,
        key: &<BlobData as Mappable>::Key,
        buf: &[u8],
    ) -> Result<(usize, Option<Vec<u8>>), Self::Error>
    where
        Self: StorageSize<BlobData>,
    {
        let size = buf.len();
        let prev = self
            .memory
            .blobs
            .insert(*key, BlobBytes::from(buf))
            .map(Into::into);
        Ok((size, prev))
    }

    fn take_bytes(
        &mut self,
        key: &<BlobData as Mappable>::Key,
    ) -> Result<Option<Vec<u8>>, Self::Error> {
        let prev = self.memory.blobs.remove(key).map(Into::into);
        Ok(prev)
    }
}

impl ContractsAssetsStorage for MemoryStorage {}

impl InterpreterStorage for MemoryStorage {
    type DataError = Infallible;

    fn block_height(&self) -> Result<BlockHeight, Infallible> {
        Ok(self.block_height)
    }

    fn consensus_parameters_version(&self) -> Result<u32, Self::DataError> {
        Ok(self.consensus_parameters_version)
    }

    fn state_transition_version(&self) -> Result<u32, Self::DataError> {
        Ok(self.state_transition_version)
    }

    #[allow(clippy::arithmetic_side_effects)] // Safety: not enough bits to overflow
    fn timestamp(&self, height: BlockHeight) -> Result<Word, Self::DataError> {
        const GENESIS: Tai64 = Tai64::UNIX_EPOCH;
        const INTERVAL: Word = 10;

        Ok((GENESIS + (*height as Word * INTERVAL)).0)
    }

    fn block_hash(&self, block_height: BlockHeight) -> Result<Bytes32, Infallible> {
        Ok(Hasher::hash(block_height.to_be_bytes()))
    }

    fn coinbase(&self) -> Result<ContractId, Infallible> {
        Ok(self.coinbase)
    }

    fn set_consensus_parameters(
        &mut self,
        version: u32,
        consensus_parameters: &ConsensusParameters,
    ) -> Result<Option<ConsensusParameters>, Self::DataError> {
        Ok(self
            .memory
            .consensus_parameters_versions
            .insert(version, consensus_parameters.clone()))
    }

    fn set_state_transition_bytecode(
        &mut self,
        version: u32,
        bytecode: &Bytes32,
    ) -> Result<Option<Bytes32>, Self::DataError> {
        Ok(self
            .memory
            .state_transition_bytecodes_versions
            .insert(version, *bytecode))
    }

    fn contract_state_range(
        &self,
        id: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Vec<Option<Cow<ContractsStateData>>>, Self::DataError> {
        let start: ContractsStateKey = (id, start_key).into();
        let end: ContractsStateKey = (id, &Bytes32::new([u8::MAX; 32])).into();
        let mut iter = self.memory.contract_state.range(start..end);

        let mut next_item = iter.next();
        Ok(core::iter::successors(Some(**start_key), |n| {
            let mut n = *n;
            if add_one(&mut n) {
                None
            } else {
                Some(n)
            }
        })
        .map(|next_key: [u8; 32]| match next_item.take() {
            Some((k, v)) => match next_key.cmp(k.state_key()) {
                core::cmp::Ordering::Less => {
                    next_item = Some((k, v));
                    None
                }
                core::cmp::Ordering::Equal => {
                    next_item = iter.next();
                    Some(Cow::Borrowed(v))
                }
                core::cmp::Ordering::Greater => None,
            },
            None => None,
        })
        .take(range)
        .collect())
    }

    fn contract_state_insert_range<'a, I>(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        values: I,
    ) -> Result<usize, Self::DataError>
    where
        I: Iterator<Item = &'a [u8]>,
    {
        let storage: &mut dyn StorageWrite<ContractsState, Error = Self::DataError> =
            self;
        let mut unset_count = 0;
        core::iter::successors(Some(**start_key), |n| {
            let mut n = *n;
            if add_one(&mut n) {
                None
            } else {
                Some(n)
            }
        })
        .zip(values)
        .try_for_each(|(key, value)| {
            let key: ContractsStateKey = (contract, &Bytes32::from(key)).into();
            // Safety: we never have over usize::MAX items in one call
            #[allow(clippy::arithmetic_side_effects)]
            if !storage.contains_key(&key)? {
                unset_count += 1;
            }
            storage.write_bytes(&key, value)?;
            Ok::<_, Self::DataError>(())
        })?;
        Ok(unset_count)
    }

    fn contract_state_remove_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Option<()>, Self::DataError> {
        let mut all_set_key = true;
        let mut values: hashbrown::HashSet<_> =
            core::iter::successors(Some(**start_key), |n| {
                let mut n = *n;
                if add_one(&mut n) {
                    None
                } else {
                    Some(n)
                }
            })
            .take(range)
            .collect();
        self.memory.contract_state.retain(|key, _| {
            let c = key.contract_id();
            let k = key.state_key();
            let r = values.remove(&**k);
            all_set_key &= c == contract && r;
            c != contract || !r
        });
        Ok((all_set_key && values.is_empty()).then_some(()))
    }
}

impl PredicateStorageRequirements for MemoryStorage {
    fn storage_error_to_string(error: Self::Error) -> alloc::string::String {
        alloc::format!("{:?}", error)
    }
}

fn add_one(a: &mut [u8; 32]) -> bool {
    let right = u128::from_be_bytes(a[16..].try_into().unwrap());
    let (right, of) = right.overflowing_add(1);
    a[16..].copy_from_slice(&right.to_be_bytes()[..]);
    if of {
        let left = u128::from_be_bytes(a[..16].try_into().unwrap());
        let (left, of) = left.overflowing_add(1);
        a[..16].copy_from_slice(&left.to_be_bytes()[..]);
        return of
    }
    false
}

#[cfg(test)]
mod tests {
    use super::*;
    use alloc::vec;
    use test_case::test_case;

    const fn key(k: u8) -> [u8; 32] {
        [
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, k,
        ]
    }

    #[test_case(&[&[0u8; 32]], &[0u8; 32], 1 => vec![Some(Default::default())])]
    #[test_case(&[&[0u8; 32]], &[0u8; 32], 0 => Vec::<Option<ContractsStateData>>::with_capacity(0))]
    #[test_case(&[], &[0u8; 32], 1 => vec![None])]
    #[test_case(&[], &[1u8; 32], 1 => vec![None])]
    #[test_case(&[&[0u8; 32]], &key(1), 2 => vec![None, None])]
    #[test_case(&[&key(1), &key(3)], &[0u8; 32], 4 => vec![None, Some(Default::default()), None, Some(Default::default())])]
    #[test_case(&[&[0u8; 32], &key(1)], &[0u8; 32], 1 => vec![Some(Default::default())])]
    fn test_contract_state_range(
        store: &[&[u8; 32]],
        start: &[u8; 32],
        range: usize,
    ) -> Vec<Option<ContractsStateData>> {
        let mut mem = MemoryStorage::default();
        for k in store {
            mem.memory.contract_state.insert(
                (&ContractId::default(), &(**k).into()).into(),
                Default::default(),
            );
        }
        mem.contract_state_range(&ContractId::default(), &(*start).into(), range)
            .unwrap()
            .into_iter()
            .map(|v| v.map(|v| v.into_owned()))
            .collect()
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/storage/contracts_state.rs

Source
use crate::double_key;
use fuel_storage::Mappable;
use fuel_types::{
    fmt_truncated_hex,
    Bytes32,
    ContractId,
};

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

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

/// The storage table for contract's hashed key-value state.
///
/// Lifetime is for optimization to avoid `clone`.
pub struct ContractsState;

impl Mappable for ContractsState {
    type Key = Self::OwnedKey;
    /// The table key is combination of the `ContractId` and `Bytes32` hash of the value's
    /// key.
    type OwnedKey = ContractsStateKey;
    type OwnedValue = ContractsStateData;
    type Value = [u8];
}

double_key!(
    ContractsStateKey,
    ContractId,
    contract_id,
    Bytes32,
    state_key
);

/// Storage type for contract state
#[derive(Derivative, Clone, PartialEq, Eq, Hash)]
#[derivative(Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ContractsStateData(
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))] pub Vec<u8>,
);

// TODO: Remove fixed size default when adding support for dynamic storage
impl Default for ContractsStateData {
    fn default() -> Self {
        Self(vec![0u8; 32])
    }
}

impl From<Vec<u8>> for ContractsStateData {
    fn from(c: Vec<u8>) -> Self {
        Self(c)
    }
}

impl From<&[u8]> for ContractsStateData {
    fn from(c: &[u8]) -> Self {
        Self(c.into())
    }
}

impl From<&mut [u8]> for ContractsStateData {
    fn from(c: &mut [u8]) -> Self {
        Self(c.into())
    }
}

impl From<ContractsStateData> for Vec<u8> {
    fn from(c: ContractsStateData) -> Vec<u8> {
        c.0
    }
}

impl AsRef<[u8]> for ContractsStateData {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl AsMut<[u8]> for ContractsStateData {
    fn as_mut(&mut self) -> &mut [u8] {
        self.0.as_mut()
    }
}

#[cfg(feature = "random")]
impl Distribution<ContractsStateData> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> ContractsStateData {
        ContractsStateData(rng.gen::<Bytes32>().to_vec())
    }
}

impl IntoIterator for ContractsStateData {
    type IntoIter = alloc::vec::IntoIter<Self::Item>;
    type Item = u8;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/storage/blob_data.rs

Source
use fuel_storage::Mappable;
use fuel_types::{
    fmt_truncated_hex,
    BlobId,
};

use alloc::vec::Vec;
use derivative::Derivative;

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

/// The storage table for blob data bytes.
pub struct BlobData;

impl Mappable for BlobData {
    type Key = Self::OwnedKey;
    type OwnedKey = BlobId;
    type OwnedValue = BlobBytes;
    type Value = [u8];
}

/// Storage type for blob bytes
#[derive(Derivative, Clone, PartialEq, Eq, Hash)]
#[derivative(Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BlobBytes(
    #[derivative(Debug(format_with = "fmt_truncated_hex::<16>"))] pub Vec<u8>,
);

impl From<Vec<u8>> for BlobBytes {
    fn from(c: Vec<u8>) -> Self {
        Self(c)
    }
}

impl From<&[u8]> for BlobBytes {
    fn from(c: &[u8]) -> Self {
        Self(c.into())
    }
}

impl From<&mut [u8]> for BlobBytes {
    fn from(c: &mut [u8]) -> Self {
        Self(c.into())
    }
}

impl From<BlobBytes> for Vec<u8> {
    fn from(c: BlobBytes) -> Vec<u8> {
        c.0
    }
}

impl AsRef<[u8]> for BlobBytes {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl AsMut<[u8]> for BlobBytes {
    fn as_mut(&mut self) -> &mut [u8] {
        self.0.as_mut()
    }
}

#[cfg(feature = "random")]
impl Distribution<BlobBytes> for Standard {
    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> BlobBytes {
        let len = rng.gen_range(0..1024);
        let mut val = Vec::new();
        for _ in 0..len {
            val.push(rng.gen());
        }
        BlobBytes(val)
    }
}

impl IntoIterator for BlobBytes {
    type IntoIter = alloc::vec::IntoIter<Self::Item>;
    type Item = u8;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

/home/marten/fuel/fuel-vm/fuel-vm/src/storage/interpreter.rs

Source
//! Trait definitions for storage backend

use fuel_storage::{
    StorageAsRef,
    StorageInspect,
    StorageMutate,
    StorageRead,
    StorageSize,
    StorageWrite,
};
use fuel_tx::{
    ConsensusParameters,
    Contract,
    StorageSlot,
};
use fuel_types::{
    AssetId,
    BlockHeight,
    Bytes32,
    ContractId,
    Word,
};

use crate::{
    prelude::{
        InterpreterError,
        RuntimeError,
    },
    storage::{
        ContractsAssets,
        ContractsRawCode,
        ContractsState,
        ContractsStateData,
        UploadedBytecode,
        UploadedBytecodes,
    },
};
use alloc::{
    borrow::Cow,
    vec::Vec,
};
use core::ops::{
    Deref,
    DerefMut,
};

use super::blob_data::BlobData;

/// When this trait is implemented, the underlying interpreter is guaranteed to
/// have full functionality
pub trait InterpreterStorage:
    StorageWrite<ContractsRawCode, Error = Self::DataError>
    + StorageSize<ContractsRawCode, Error = Self::DataError>
    + StorageRead<ContractsRawCode, Error = Self::DataError>
    + StorageWrite<ContractsState, Error = Self::DataError>
    + StorageSize<ContractsState, Error = Self::DataError>
    + StorageRead<ContractsState, Error = Self::DataError>
    + StorageMutate<UploadedBytecodes, Error = Self::DataError>
    + StorageWrite<BlobData, Error = Self::DataError>
    + StorageSize<BlobData, Error = Self::DataError>
    + StorageRead<BlobData, Error = Self::DataError>
    + ContractsAssetsStorage<Error = Self::DataError>
{
    /// Error implementation for reasons unspecified in the protocol.
    type DataError: Into<InterpreterError<Self::DataError>>
        + Into<RuntimeError<Self::DataError>>
        + core::fmt::Debug;

    /// Provide the current block height in which the transactions should be
    /// executed.
    fn block_height(&self) -> Result<BlockHeight, Self::DataError>;

    /// Provide the current version of consensus parameters used to execute transaction.
    fn consensus_parameters_version(&self) -> Result<u32, Self::DataError>;

    /// Provide the current version of state transition function used to execute
    /// transaction.
    fn state_transition_version(&self) -> Result<u32, Self::DataError>;

    /// Return the timestamp of a given block
    ///
    /// This isn't optional because the VM is expected to panic if an invalid block height
    /// is passed - under the assumption that the block height is consistent, the
    /// storage should necessarily have the timestamp for the block, unless some I/O
    /// error prevents it from fetching it.
    fn timestamp(&self, height: BlockHeight) -> Result<Word, Self::DataError>;

    /// Provide the block hash from a given height.
    fn block_hash(&self, block_height: BlockHeight) -> Result<Bytes32, Self::DataError>;

    /// Provide the coinbase address for the VM instructions implementation.
    fn coinbase(&self) -> Result<ContractId, Self::DataError>;

    /// Set the consensus parameters in the storage under the `version`.
    ///
    /// Returns the previous consensus parameters if they were set.
    fn set_consensus_parameters(
        &mut self,
        version: u32,
        consensus_parameters: &ConsensusParameters,
    ) -> Result<Option<ConsensusParameters>, Self::DataError>;

    /// Returns `true` if the fully uploaded state transition bytecode is present in the
    /// storage.
    fn contains_state_transition_bytecode_root(
        &self,
        root: &Bytes32,
    ) -> Result<bool, Self::DataError> {
        let bytecode = self.storage::<UploadedBytecodes>().get(root)?;

        if let Some(cow) = bytecode {
            if let UploadedBytecode::Completed(_) = cow.as_ref() {
                Ok(true)
            } else {
                Ok(false)
            }
        } else {
            Ok(false)
        }
    }

    /// Set the state transition bytecode in the storage under the `version`.
    ///
    /// Returns the previous bytecode if it was set.
    fn set_state_transition_bytecode(
        &mut self,
        version: u32,
        hash: &Bytes32,
    ) -> Result<Option<Bytes32>, Self::DataError>;

    /// Deploy a contract into the storage with contract id
    fn deploy_contract_with_id(
        &mut self,
        slots: &[StorageSlot],
        contract: &Contract,
        id: &ContractId,
    ) -> Result<(), Self::DataError> {
        self.storage_contract_insert(id, contract)?;

        // On the `fuel-core` side it is done in more optimal way
        slots.iter().try_for_each(|s| {
            self.contract_state_insert(id, s.key(), s.value().as_ref())?;
            Ok(())
        })?;
        Ok(())
    }

    /// Fetch a previously inserted contract code from the chain state for a
    /// given contract.
    fn storage_contract(
        &self,
        id: &ContractId,
    ) -> Result<Option<Cow<'_, Contract>>, Self::DataError> {
        StorageInspect::<ContractsRawCode>::get(self, id)
    }

    /// Fetch the size of a previously inserted contract code from the chain state for a
    /// given contract.
    fn storage_contract_size(
        &self,
        id: &ContractId,
    ) -> Result<Option<usize>, Self::DataError> {
        StorageSize::<ContractsRawCode>::size_of_value(self, id)
    }

    /// Read contract bytes from storage into the buffer.
    fn read_contract(
        &self,
        id: &ContractId,
        writer: &mut [u8],
    ) -> Result<Option<Word>, Self::DataError> {
        Ok(StorageRead::<ContractsRawCode>::read(self, id, writer)?.map(|r| r as Word))
    }

    /// Append a contract to the chain, provided its identifier.
    ///
    /// Canonically, the identifier should be [`Contract::id`].
    fn storage_contract_insert(
        &mut self,
        id: &ContractId,
        contract: &Contract,
    ) -> Result<(), Self::DataError> {
        StorageMutate::<ContractsRawCode>::insert(self, id, contract.as_ref())
    }

    /// Check if a provided contract exists in the chain.
    fn storage_contract_exists(&self, id: &ContractId) -> Result<bool, Self::DataError> {
        self.storage::<ContractsRawCode>().contains_key(id)
    }

    /// Fetch the value form a key-value mapping in a contract storage.
    fn contract_state(
        &self,
        id: &ContractId,
        key: &Bytes32,
    ) -> Result<Option<Cow<'_, ContractsStateData>>, Self::DataError> {
        StorageInspect::<ContractsState>::get(self, &(id, key).into())
    }

    /// Insert a key-value mapping in a contract storage.
    fn contract_state_insert(
        &mut self,
        contract: &ContractId,
        key: &Bytes32,
        value: &[u8],
    ) -> Result<(), Self::DataError> {
        StorageWrite::<ContractsState>::write_bytes(
            self,
            &(contract, key).into(),
            value,
        )?;
        Ok(())
    }

    /// Insert a key-value mapping into a contract storage.
    fn contract_state_replace(
        &mut self,
        contract: &ContractId,
        key: &Bytes32,
        value: &[u8],
    ) -> Result<Option<Vec<u8>>, Self::DataError> {
        let (_, prev) = StorageWrite::<ContractsState>::replace_bytes(
            self,
            &(contract, key).into(),
            value,
        )?;
        Ok(prev)
    }

    /// Fetch a range of values from a key-value mapping in a contract storage.
    /// Returns the full range requested using optional values in case
    /// a requested slot is unset.  
    fn contract_state_range(
        &self,
        id: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Vec<Option<Cow<ContractsStateData>>>, Self::DataError>;

    /// Insert a range of key-value mappings into contract storage.
    /// Returns the number of keys that were previously unset but are now set.
    fn contract_state_insert_range<'a, I>(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        values: I,
    ) -> Result<usize, Self::DataError>
    where
        I: Iterator<Item = &'a [u8]>;

    /// Remove a range of key-values from contract storage.
    /// Returns None if any of the keys in the range were already unset.
    fn contract_state_remove_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Option<()>, Self::DataError>;
}

/// Storage operations for contract assets.
pub trait ContractsAssetsStorage: StorageMutate<ContractsAssets> {
    /// Fetch the balance of an asset ID in a contract storage.
    fn contract_asset_id_balance(
        &self,
        id: &ContractId,
        asset_id: &AssetId,
    ) -> Result<Option<Word>, Self::Error> {
        let balance = self
            .storage::<ContractsAssets>()
            .get(&(id, asset_id).into())?
            .map(Cow::into_owned);

        Ok(balance)
    }

    /// Update the balance of an asset ID in a contract storage.
    fn contract_asset_id_balance_insert(
        &mut self,
        contract: &ContractId,
        asset_id: &AssetId,
        value: Word,
    ) -> Result<(), Self::Error> {
        StorageMutate::<ContractsAssets>::insert(
            self,
            &(contract, asset_id).into(),
            &value,
        )
    }

    /// Update the balance of an asset ID in a contract storage.
    /// Returns the old balance, if any.
    fn contract_asset_id_balance_replace(
        &mut self,
        contract: &ContractId,
        asset_id: &AssetId,
        value: Word,
    ) -> Result<Option<Word>, Self::Error> {
        StorageMutate::<ContractsAssets>::replace(
            self,
            &(contract, asset_id).into(),
            &value,
        )
    }
}

impl<S> ContractsAssetsStorage for &mut S where S: ContractsAssetsStorage {}

impl<S> InterpreterStorage for &mut S
where
    S: InterpreterStorage,
{
    type DataError = <S as InterpreterStorage>::DataError;

    fn block_height(&self) -> Result<BlockHeight, Self::DataError> {
        <S as InterpreterStorage>::block_height(self.deref())
    }

    fn consensus_parameters_version(&self) -> Result<u32, Self::DataError> {
        <S as InterpreterStorage>::consensus_parameters_version(self.deref())
    }

    fn state_transition_version(&self) -> Result<u32, Self::DataError> {
        <S as InterpreterStorage>::state_transition_version(self.deref())
    }

    fn timestamp(&self, height: BlockHeight) -> Result<Word, Self::DataError> {
        <S as InterpreterStorage>::timestamp(self.deref(), height)
    }

    fn block_hash(&self, block_height: BlockHeight) -> Result<Bytes32, Self::DataError> {
        <S as InterpreterStorage>::block_hash(self.deref(), block_height)
    }

    fn coinbase(&self) -> Result<ContractId, Self::DataError> {
        <S as InterpreterStorage>::coinbase(self.deref())
    }

    fn set_consensus_parameters(
        &mut self,
        version: u32,
        consensus_parameters: &ConsensusParameters,
    ) -> Result<Option<ConsensusParameters>, Self::DataError> {
        <S as InterpreterStorage>::set_consensus_parameters(
            self.deref_mut(),
            version,
            consensus_parameters,
        )
    }

    fn set_state_transition_bytecode(
        &mut self,
        version: u32,
        hash: &Bytes32,
    ) -> Result<Option<Bytes32>, Self::DataError> {
        <S as InterpreterStorage>::set_state_transition_bytecode(
            self.deref_mut(),
            version,
            hash,
        )
    }

    fn storage_contract_size(
        &self,
        id: &ContractId,
    ) -> Result<Option<usize>, Self::DataError> {
        <S as InterpreterStorage>::storage_contract_size(self.deref(), id)
    }

    fn read_contract(
        &self,
        id: &ContractId,
        writer: &mut [u8],
    ) -> Result<Option<Word>, Self::DataError> {
        <S as InterpreterStorage>::read_contract(self.deref(), id, writer)
    }

    fn contract_state_range(
        &self,
        id: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Vec<Option<Cow<ContractsStateData>>>, Self::DataError> {
        <S as InterpreterStorage>::contract_state_range(
            self.deref(),
            id,
            start_key,
            range,
        )
    }

    fn contract_state_insert_range<'a, I>(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        values: I,
    ) -> Result<usize, Self::DataError>
    where
        I: Iterator<Item = &'a [u8]>,
    {
        <S as InterpreterStorage>::contract_state_insert_range(
            self.deref_mut(),
            contract,
            start_key,
            values,
        )
    }

    fn contract_state_remove_range(
        &mut self,
        contract: &ContractId,
        start_key: &Bytes32,
        range: usize,
    ) -> Result<Option<()>, Self::DataError> {
        <S as InterpreterStorage>::contract_state_remove_range(
            self.deref_mut(),
            contract,
            start_key,
            range,
        )
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/in_memory.rs

Source
use crate::{
    binary::{
        self,
        Primitive,
    },
    common::{
        Bytes32,
        ProofSet,
        StorageMap,
    },
    storage::Mappable,
};

/// The table of the Binary Merkle Tree's nodes. [`MerkleTree`] works with it as
/// a binary array, where the storage key of the node is the `u64` index and
/// value is the [`Node`](crate::binary::Node).
#[derive(Debug, Clone)]
pub struct NodesTable;

impl Mappable for NodesTable {
    type Key = Self::OwnedKey;
    type OwnedKey = u64;
    type OwnedValue = Primitive;
    type Value = Self::OwnedValue;
}

type Storage = StorageMap<NodesTable>;
type BinaryMerkleTree = binary::MerkleTree<NodesTable, Storage>;

#[derive(Debug, Clone)]
pub struct MerkleTree {
    tree: BinaryMerkleTree,
}

impl MerkleTree {
    pub fn new() -> Self {
        Self {
            tree: BinaryMerkleTree::new(Storage::new()),
        }
    }

    pub fn push(&mut self, data: &[u8]) {
        let _ = self.tree.push(data);
    }

    pub fn root(&self) -> Bytes32 {
        self.tree.root()
    }

    pub fn prove(&self, proof_index: u64) -> Option<(Bytes32, ProofSet)> {
        self.tree.prove(proof_index).ok()
    }

    pub fn reset(&mut self) {
        self.tree.reset();
    }
}

impl Default for MerkleTree {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use binary::{
        empty_sum,
        leaf_sum,
        node_sum,
    };
    use fuel_merkle_test_helpers::TEST_DATA;

    #[test]
    fn root_returns_the_empty_root_for_0_leaves() {
        let tree = MerkleTree::new();

        let root = tree.root();
        assert_eq!(root, empty_sum().clone());
    }

    #[test]
    fn root_returns_the_merkle_root_for_1_leaf() {
        let mut tree = MerkleTree::new();

        let data = &TEST_DATA[0..1]; // 1 leaf
        for datum in data.iter() {
            tree.push(datum);
        }

        let leaf_0 = leaf_sum(data[0]);

        let root = tree.root();
        assert_eq!(root, leaf_0);
    }

    #[test]
    fn root_returns_the_merkle_root_for_7_leaves() {
        let mut tree = MerkleTree::new();

        let data = &TEST_DATA[0..7]; // 7 leaves
        for datum in data.iter() {
            tree.push(datum);
        }

        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      \
        //  /  \    /  \    /  \      \
        // 00  02  04  06  08  10     12
        // 00  01  02  03  04  05     06

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);
        let leaf_4 = leaf_sum(data[4]);
        let leaf_5 = leaf_sum(data[5]);
        let leaf_6 = leaf_sum(data[6]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);
        let node_9 = node_sum(&leaf_4, &leaf_5);
        let node_11 = node_sum(&node_9, &leaf_6);
        let node_7 = node_sum(&node_3, &node_11);

        let root = tree.root();
        assert_eq!(root, node_7);
    }

    #[test]
    fn prove_returns_none_for_0_leaves() {
        let tree = MerkleTree::new();

        let proof = tree.prove(0);
        assert!(proof.is_none());
    }

    #[test]
    fn prove_returns_none_when_index_is_greater_than_number_of_leaves() {
        let mut tree = MerkleTree::new();

        let data = &TEST_DATA[0..5]; // 5 leaves
        for datum in data.iter() {
            tree.push(datum);
        }

        let proof = tree.prove(10);
        assert!(proof.is_none());
    }

    #[test]
    fn prove_returns_the_merkle_root_and_proof_set_for_1_leaf() {
        let mut tree = MerkleTree::new();

        let data = &TEST_DATA[0..1]; // 1 leaf
        for datum in data.iter() {
            tree.push(datum);
        }

        let leaf_0 = leaf_sum(data[0]);

        {
            let (root, proof_set) = tree.prove(0).unwrap();
            assert_eq!(root, leaf_0);
            assert!(proof_set.is_empty());
        }
    }

    #[test]
    fn prove_returns_the_merkle_root_and_proof_set_for_7_leaves() {
        let mut tree = MerkleTree::new();

        let data = &TEST_DATA[0..7]; // 7 leaves
        for datum in data.iter() {
            tree.push(datum);
        }

        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      \
        //  /  \    /  \    /  \      \
        // 00  02  04  06  08  10     12
        // 00  01  02  03  04  05     06

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);
        let leaf_4 = leaf_sum(data[4]);
        let leaf_5 = leaf_sum(data[5]);
        let leaf_6 = leaf_sum(data[6]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);
        let node_9 = node_sum(&leaf_4, &leaf_5);
        let node_11 = node_sum(&node_9, &leaf_6);
        let node_7 = node_sum(&node_3, &node_11);

        {
            let (root, proof_set) = tree.prove(0).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_1);
            assert_eq!(proof_set[1], node_5);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(1).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_0);
            assert_eq!(proof_set[1], node_5);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(2).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_3);
            assert_eq!(proof_set[1], node_1);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(3).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_2);
            assert_eq!(proof_set[1], node_1);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(4).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_5);
            assert_eq!(proof_set[1], leaf_6);
            assert_eq!(proof_set[2], node_3);
        }
        {
            let (root, proof_set) = tree.prove(5).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_4);
            assert_eq!(proof_set[1], leaf_6);
            assert_eq!(proof_set[2], node_3);
        }
        {
            let (root, proof_set) = tree.prove(6).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], node_9);
            assert_eq!(proof_set[1], node_3);
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/verify.rs

Source
use crate::{
    binary::{
        leaf_sum,
        node_sum,
    },
    common::{
        Bytes32,
        ProofSet,
    },
};

/// Returns None if:
/// - `num_leaves` is 0
/// - the result doens't fit in an usize
fn path_length_from_key(key: u64, num_leaves: u64) -> Option<usize> {
    if num_leaves == 0 {
        return None;
    }

    #[allow(clippy::arithmetic_side_effects)] // ilog2(..) < 64
    let path_length = if num_leaves.is_power_of_two() {
        num_leaves.ilog2()
    } else {
        num_leaves.ilog2() + 1
    };

    #[allow(clippy::arithmetic_side_effects)] // ilog2(..) > 0
    let num_leaves_left_subtree = 1 << (path_length - 1);

    let subtree_leaves = num_leaves.saturating_sub(num_leaves_left_subtree);

    let Some(subtree_key) = key.checked_sub(num_leaves_left_subtree) else {
        // If leaf is in left subtree, path length is full height of left subtree
        return path_length.try_into().ok();
    };

    // Otherwise, if left or right subtree has only one leaf, path has one additional step
    if num_leaves_left_subtree == 1 || subtree_leaves <= 1 {
        return Some(1);
    }

    // Otherwise, add 1 to height and recurse into right subtree
    path_length_from_key(subtree_key, subtree_leaves)?.checked_add(1)
}

pub fn verify<T: AsRef<[u8]>>(
    root: &Bytes32,
    data: &T,
    proof_set: &ProofSet,
    proof_index: u64,
    num_leaves: u64,
) -> bool {
    if num_leaves <= 1 {
        if !proof_set.is_empty() {
            return false;
        }
    } else if Some(proof_set.len()) != path_length_from_key(proof_index, num_leaves) {
        return false;
    }

    if proof_index >= num_leaves {
        return false;
    }

    let mut sum = leaf_sum(data.as_ref());
    if proof_set.is_empty() {
        return if num_leaves == 1 { *root == sum } else { false }
    }
    #[allow(clippy::arithmetic_side_effects)] // checked above
    let last_leaf = num_leaves - 1;

    let mut parent = 0usize;
    let mut stable_end = proof_index;

    loop {
        #[allow(clippy::arithmetic_side_effects)] // path_length_from_key checks
        let height = parent + 1;

        let subtree_size = 1u64 << height;
        #[allow(clippy::arithmetic_side_effects)] // floor(a / b) * b <= a
        let subtree_start_index = proof_index / subtree_size * subtree_size;
        #[allow(clippy::arithmetic_side_effects)]
        let subtree_end_index = subtree_start_index + subtree_size - 1;

        if subtree_end_index >= num_leaves {
            break
        }

        stable_end = subtree_end_index;

        if proof_set.len() < height {
            return false
        }

        let proof_data = proof_set[parent];
        #[allow(clippy::arithmetic_side_effects)] // proof_index > subtree_start_index
        if proof_index - subtree_start_index < (1 << parent) {
            sum = node_sum(&sum, &proof_data);
        } else {
            sum = node_sum(&proof_data, &sum);
        }

        #[allow(clippy::arithmetic_side_effects)] // path_length_from_key checks
        {
            parent += 1;
        }
    }

    if stable_end != last_leaf {
        if proof_set.len() <= parent {
            return false
        }
        let proof_data = proof_set[parent];
        sum = node_sum(&sum, &proof_data);
        #[allow(clippy::arithmetic_side_effects)] // path_length_from_key checks
        {
            parent += 1;
        }
    }

    while parent < proof_set.len() {
        let proof_data = proof_set[parent];
        sum = node_sum(&proof_data, &sum);
        #[allow(clippy::arithmetic_side_effects)] // path_length_from_key checks
        {
            parent += 1;
        }
    }

    sum == *root
}

#[cfg(test)]
mod test {
    use super::verify;
    use crate::{
        binary::{
            MerkleTree,
            Primitive,
        },
        common::StorageMap,
    };
    use fuel_merkle_test_helpers::TEST_DATA;
    use fuel_storage::Mappable;

    #[derive(Debug)]
    struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = u64;
        type OwnedValue = Primitive;
        type Value = Self::OwnedValue;
    }

    #[test]
    fn verify_returns_true_when_the_given_proof_set_matches_the_given_merkle_root() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        const PROOF_INDEX: usize = 2;
        const LEAVES_COUNT: usize = 5;

        let data = &TEST_DATA[0..LEAVES_COUNT]; // 5 leaves
        for datum in data.iter() {
            tree.push(datum).unwrap();
        }

        let (root, proof_set) = tree.prove(PROOF_INDEX as u64).unwrap();
        let verification = verify(
            &root,
            &TEST_DATA[PROOF_INDEX],
            &proof_set,
            PROOF_INDEX as u64,
            LEAVES_COUNT as u64,
        );
        assert!(verification);
    }

    #[test]
    fn verify_returns_false_when_the_given_proof_set_does_not_match_the_given_merkle_root(
    ) {
        // Check the Merkle root of one tree against the computed Merkle root of
        // another tree's proof set: because the two roots come from different
        // trees, the comparison should fail.

        // Generate the first Merkle tree and get its root
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        const PROOF_INDEX: usize = 2;
        const LEAVES_COUNT: usize = 5;

        let data = &TEST_DATA[0..LEAVES_COUNT - 1];
        for datum in data.iter() {
            tree.push(datum).unwrap();
        }
        let proof = tree.prove(PROOF_INDEX as u64).unwrap();
        let root = proof.0;

        // Generate the second Merkle tree and get its proof set
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[5..10];
        for datum in data.iter() {
            tree.push(datum).unwrap();
        }
        let proof = tree.prove(PROOF_INDEX as u64).unwrap();
        let set = proof.1;

        let verification = verify(
            &root,
            &TEST_DATA[PROOF_INDEX],
            &set,
            PROOF_INDEX as u64,
            LEAVES_COUNT as u64,
        );
        assert!(!verification);
    }

    #[test]
    fn verify_returns_false_when_the_proof_set_is_empty() {
        const PROOF_INDEX: usize = 0;
        const LEAVES_COUNT: usize = 0;

        let verification = verify(
            &Default::default(),
            &TEST_DATA[PROOF_INDEX],
            &vec![],
            PROOF_INDEX as u64,
            LEAVES_COUNT as u64,
        );
        assert!(!verification);
    }

    #[test]
    fn verify_returns_false_when_the_proof_index_is_invalid() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        const PROOF_INDEX: usize = 0;
        const LEAVES_COUNT: usize = 5;

        let data = &TEST_DATA[0..LEAVES_COUNT - 1];
        for datum in data.iter() {
            tree.push(datum).unwrap();
        }

        let proof = tree.prove(PROOF_INDEX as u64).unwrap();
        let root = proof.0;
        let set = proof.1;

        let verification = verify(
            &root,
            &TEST_DATA[PROOF_INDEX],
            &set,
            PROOF_INDEX as u64 + 15,
            LEAVES_COUNT as u64,
        );
        assert!(!verification);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/node.rs

Source
use crate::{
    binary::{
        leaf_sum,
        node_sum,
    },
    common::{
        Bytes32,
        Position,
    },
};

use core::fmt::Debug;
#[derive(Clone, PartialEq, Eq, Debug)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Node {
    position: Position,
    hash: Bytes32,
}

impl Node {
    pub fn new(position: Position, hash: Bytes32) -> Self {
        Self { position, hash }
    }

    /// Returns `None` if the leaf cannot be created due to incorrect position.
    pub fn create_leaf(index: u64, data: &[u8]) -> Option<Self> {
        let position = Position::from_leaf_index(index)?;
        let hash = leaf_sum(data);
        Some(Self { position, hash })
    }

    /// Creates a new node with the given children.
    pub fn create_node(
        position: Position,
        left_child: &Self,
        right_child: &Self,
    ) -> Self {
        let hash = node_sum(left_child.hash(), right_child.hash());
        Self { position, hash }
    }

    pub fn position(&self) -> &Position {
        &self.position
    }

    pub fn key(&self) -> u64 {
        self.position().in_order_index()
    }

    pub fn hash(&self) -> &Bytes32 {
        &self.hash
    }

    pub fn height(&self) -> u32 {
        self.position().height()
    }
}

impl AsRef<Node> for Node {
    fn as_ref(&self) -> &Node {
        self
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/primitive.rs

Source
use crate::{
    binary::Node,
    common::{
        Bytes32,
        Position,
    },
};

pub type Primitive = (u64, Bytes32);

pub trait PrimitiveView {
    fn position(&self) -> Position;
    fn hash(&self) -> &Bytes32;
}

impl PrimitiveView for Primitive {
    fn position(&self) -> Position {
        Position::from_in_order_index(self.0)
    }

    fn hash(&self) -> &Bytes32 {
        &self.1
    }
}

impl From<&Node> for Primitive {
    fn from(node: &Node) -> Self {
        (node.position().in_order_index(), *node.hash())
    }
}

impl From<Primitive> for Node {
    fn from(primitive: Primitive) -> Self {
        let position = primitive.position();
        let hash = *primitive.hash();
        Node::new(position, hash)
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/merkle_tree.rs

Source
use crate::{
    binary::{
        empty_sum,
        in_memory::NodesTable,
        Node,
        Primitive,
    },
    common::{
        Bytes32,
        Position,
        ProofSet,
        StorageMap,
    },
    storage::{
        Mappable,
        StorageInspect,
        StorageInspectInfallible,
        StorageMutate,
        StorageMutateInfallible,
    },
};

use alloc::vec::Vec;
use core::{
    convert::Infallible,
    marker::PhantomData,
};

use super::root_calculator::{
    MerkleRootCalculator,
    NodeStackPushError,
};

#[derive(Debug, Clone, derive_more::Display, PartialEq, Eq)]
pub enum MerkleTreeError<StorageError> {
    #[display(fmt = "proof index {_0} is not valid")]
    InvalidProofIndex(u64),

    #[display(fmt = "cannot load node with key {_0}; the key is not found in storage")]
    LoadError(u64),

    #[display(fmt = "{}", _0)]
    StorageError(StorageError),

    #[display(fmt = "the tree is too large")]
    TooLarge,
}

impl<StorageError> From<StorageError> for MerkleTreeError<StorageError> {
    fn from(err: StorageError) -> MerkleTreeError<StorageError> {
        MerkleTreeError::StorageError(err)
    }
}

#[derive(Debug, Clone)]
pub struct MerkleTree<TableType, StorageType> {
    storage: StorageType,
    nodes: MerkleRootCalculator,
    leaves_count: u64,
    phantom_table: PhantomData<TableType>,
}

impl<TableType, StorageType> MerkleTree<TableType, StorageType> {
    pub const fn empty_root() -> &'static Bytes32 {
        empty_sum()
    }

    pub fn root(&self) -> Bytes32 {
        let mut scratch_storage = StorageMap::<NodesTable>::new();
        let root_node = self
            .root_node::<Infallible>(&mut scratch_storage)
            .expect("The type doesn't allow constructing invalid trees.");
        match root_node {
            None => *Self::empty_root(),
            Some(ref node) => *node.hash(),
        }
    }

    pub fn leaves_count(&self) -> u64 {
        self.leaves_count
    }

    /// The root node is generated by joining all MMR peaks, where a peak is
    /// defined as the head of a balanced subtree. A tree can be composed of a
    /// single balanced subtree, in which case the tree is itself balanced, or
    /// several balanced subtrees, in which case the tree is imbalanced. Only
    /// nodes at the head of a balanced tree are persisted in storage; any node,
    /// including the root node, whose child is an imbalanced child subtree will
    /// not be saved in persistent storage. This is because node data for such
    /// nodes is liable to change as more leaves are pushed to the tree.
    /// Instead, intermediate nodes must be held in a temporary storage space.
    ///
    /// When calling `root_node`, callees must pass a mutable reference to a
    /// temporary storage space that will be used to hold any intermediate nodes
    /// that are created during root node calculation. At the end of the method
    /// call, this temporary storage space will contain all intermediate nodes
    /// not held in persistent storage, and these nodes will be available to the
    /// callee.
    ///
    /// Returns `None` if the tree is empty, and the root node otherwise.
    fn root_node<E>(
        &self,
        scratch_storage: &mut StorageMap<NodesTable>,
    ) -> Result<Option<Node>, MerkleTreeError<E>> {
        let mut nodes = self.nodes.stack().iter().rev();
        let Some(mut head) = nodes.next().cloned() else {
            return Ok(None); // Empty tree
        };

        for node in nodes {
            let parent = node
                .position()
                .parent()
                .map_err(|_| MerkleTreeError::TooLarge)?;
            head = Node::create_node(parent, node, &head);
            StorageMutateInfallible::insert(
                scratch_storage,
                &head.key(),
                &(&head).into(),
            );
        }

        Ok(Some(head))
    }
}

impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
where
    TableType: Mappable<Key = u64, Value = Primitive, OwnedValue = Primitive>,
    StorageType: StorageInspect<TableType, Error = StorageError>,
{
    pub fn new(storage: StorageType) -> Self {
        Self {
            storage,
            nodes: MerkleRootCalculator::new(),
            leaves_count: 0,
            phantom_table: Default::default(),
        }
    }

    /// A binary Merkle tree can be built from a collection of Merkle Mountain
    /// Range (MMR) peaks. The MMR structure can be accurately defined by the
    /// number of leaves in the leaf row.
    ///
    /// Consider a binary Merkle tree with seven leaves, producing the following
    /// MMR structure:
    ///
    /// ```text
    ///       03
    ///      /  \
    ///     /    \
    ///   01      05      09
    ///  /  \    /  \    /  \
    /// 00  02  04  06  08  10  12
    /// ```
    ///
    /// We observe that the tree has three peaks at positions `03`, `09`, and
    /// `12`. These peak positions are recorded in the order that they appear,
    /// reading left to right in the tree structure, and only descend in height.
    /// These peak positions communicate everything needed to determine the
    /// remaining internal nodes building upwards to the root position:
    ///
    /// ```text
    ///            07
    ///           /  \
    ///          /    \
    ///         /      \
    ///        /        \
    ///       /          \
    ///      /            \
    ///    03              11
    ///   /  \            /  \
    /// ...  ...         /    \
    ///                09      \
    ///               /  \      \
    ///             ...  ...    12
    /// ```
    ///
    /// No additional intermediate nodes or leaves are required to calculate
    /// the root position.
    ///
    /// The positions of the MMR peaks can be deterministically calculated as a
    /// function of `n + 1` where `n` is the number of leaves in the tree. By
    /// appending an additional leaf node to the tree, we generate a new tree
    /// structure with additional internal nodes (N.B.: this may also change the
    /// root position if the tree is already balanced).
    ///
    /// In our example, we add an additional leaf at leaf index `7` (in-order
    /// index `14`):
    ///
    /// ```text
    ///            07
    ///           /  \
    ///          /    \
    ///         /      \
    ///        /        \
    ///       /          \
    ///      /            \
    ///    03              11
    ///   /  \            /  \
    /// ...  ...         /    \
    ///                09      13
    ///               /  \    /  \
    ///             ...  ... 12  14
    /// ```
    ///
    /// We observe that the path from the root position to our new leaf position
    /// yields a set of side positions that includes our original peak
    /// positions (see [Path Iterator](crate::common::path_iterator::PathIter)):
    ///
    /// | Path position | Side position |
    /// |---------------|---------------|
    /// |            07 |            07 |
    /// |            11 |            03 |
    /// |            13 |            09 |
    /// |            14 |            12 |
    ///
    /// By excluding the root position `07`, we have established the set of
    /// side positions `03`, `09`, and `12`, matching our set of MMR peaks.
    pub fn load(
        storage: StorageType,
        leaves_count: u64,
    ) -> Result<Self, MerkleTreeError<StorageError>> {
        let mut nodes = Vec::new();
        let peaks = peak_positions(leaves_count).ok_or(MerkleTreeError::TooLarge)?;
        for peak in peaks.iter() {
            let key = peak.in_order_index();
            let node = storage
                .get(&key)?
                .ok_or(MerkleTreeError::LoadError(key))?
                .into_owned()
                .into();
            nodes.push(node);
        }

        Ok(Self {
            storage,
            nodes: MerkleRootCalculator::new_with_stack(nodes),
            leaves_count,
            phantom_table: Default::default(),
        })
    }

    pub fn prove(
        &self,
        proof_index: u64,
    ) -> Result<(Bytes32, ProofSet), MerkleTreeError<StorageError>> {
        if proof_index >= self.leaves_count {
            return Err(MerkleTreeError::InvalidProofIndex(proof_index))
        }

        let root_position = root_position(self.leaves_count)
            .expect("This tree is too large, but push should have prevented this");
        let leaf_position = Position::from_leaf_index(proof_index)
            .expect("leaves_count is valid, and this is less than leaves_count");
        let (_, mut side_positions): (Vec<_>, Vec<_>) = root_position
            .path(&leaf_position, self.leaves_count)
            .iter()
            .unzip();
        side_positions.reverse(); // Reorder side positions from leaf to root.
        side_positions.pop(); // The last side position is the root; remove it.

        // Allocate scratch storage to store temporary nodes when building the
        // root.
        let mut scratch_storage = StorageMap::<NodesTable>::new();
        let root_node = self
            .root_node(&mut scratch_storage)?
            .expect("Root node must be present, as leaves_count is nonzero");

        // Get side nodes. First, we check the scratch storage. If the side node
        // is not found in scratch storage, we then check main storage. Finally,
        // if the side node is not found in main storage, we exit with a load
        // error.
        let mut proof_set = ProofSet::new();
        for side_position in side_positions {
            let key = side_position.in_order_index();
            let primitive = StorageInspectInfallible::get(&scratch_storage, &key)
                .or(StorageInspect::get(&self.storage, &key)?)
                .ok_or(MerkleTreeError::LoadError(key))?
                .into_owned();
            let node = Node::from(primitive);
            proof_set.push(*node.hash());
        }

        let root = *root_node.hash();
        Ok((root, proof_set))
    }

    pub fn reset(&mut self) {
        self.nodes.clear();
    }
}

impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
where
    TableType: Mappable<Key = u64, Value = Primitive, OwnedValue = Primitive>,
    StorageType: StorageMutate<TableType, Error = StorageError>,
{
    /// Adds a new leaf node to the tree.
    /// # WARNING
    /// This code might modify the storage, and then return an error.
    /// TODO: fix this issue
    pub fn push(&mut self, data: &[u8]) -> Result<(), MerkleTreeError<StorageError>> {
        let new_node = Node::create_leaf(self.leaves_count, data)
            .ok_or(MerkleTreeError::TooLarge)?;

        // u64 cannot overflow, as memory is finite
        #[allow(clippy::arithmetic_side_effects)]
        {
            self.leaves_count += 1;
        }

        self.nodes
            .push_with_callback(new_node, |node| {
                self.storage
                    .insert(&node.key(), &node.into())
                    .map_err(MerkleTreeError::StorageError)
                    .map(|_| ())
            })
            .map_err(|err| match err {
                NodeStackPushError::Callback(err) => err,
                NodeStackPushError::TooLarge => MerkleTreeError::TooLarge,
            })
    }
}

/// Calculcate root position from leaf count.
/// Returns `None` if the tree is too large.
fn root_position(leaves_count: u64) -> Option<Position> {
    // The root position of a tree will always have an in-order index equal
    // to N' - 1, where N is the leaves count and N' is N rounded (or equal)
    // to the next power of 2.
    #[allow(clippy::arithmetic_side_effects)] // next_power_of_two() > 0
    Some(Position::from_in_order_index(
        leaves_count.checked_add(1)?.next_power_of_two() - 1,
    ))
}

/// Calculcate peak positons for given leaf count.
/// Returns `None` if the tree is too large.
fn peak_positions(leaves_count: u64) -> Option<Vec<Position>> {
    let leaf_position = Position::from_leaf_index(leaves_count)?;
    let root_position = root_position(leaves_count)?;

    // Checked by root_position
    #[allow(clippy::arithmetic_side_effects)]
    let next_leaves_count = leaves_count + 1;

    let mut peaks_itr = root_position.path(&leaf_position, next_leaves_count).iter();
    peaks_itr.next(); // Omit the root

    let (_, peaks): (Vec<_>, Vec<_>) = peaks_itr.unzip();

    Some(peaks)
}

#[cfg(test)]
mod test {
    use super::{
        MerkleTree,
        MerkleTreeError,
    };
    use crate::{
        binary::{
            empty_sum,
            leaf_sum,
            node_sum,
            Node,
            Primitive,
        },
        common::StorageMap,
    };
    use fuel_merkle_test_helpers::TEST_DATA;
    use fuel_storage::{
        Mappable,
        StorageInspect,
        StorageMutate,
    };

    use alloc::vec::Vec;

    #[derive(Debug)]
    struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = u64;
        type OwnedValue = Primitive;
        type Value = Self::OwnedValue;
    }

    #[test]
    fn test_push_builds_internal_tree_structure() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..7]; // 7 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      \
        //  /  \    /  \    /  \      \
        // 00  02  04  06  08  10     12
        // 00  01  02  03  04  05     06

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);
        let leaf_4 = leaf_sum(data[4]);
        let leaf_5 = leaf_sum(data[5]);
        let leaf_6 = leaf_sum(data[6]);
        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);
        let node_9 = node_sum(&leaf_4, &leaf_5);

        let s_leaf_0 = storage_map.get(&0).unwrap().unwrap();
        let s_leaf_1 = storage_map.get(&2).unwrap().unwrap();
        let s_leaf_2 = storage_map.get(&4).unwrap().unwrap();
        let s_leaf_3 = storage_map.get(&6).unwrap().unwrap();
        let s_leaf_4 = storage_map.get(&8).unwrap().unwrap();
        let s_leaf_5 = storage_map.get(&10).unwrap().unwrap();
        let s_leaf_6 = storage_map.get(&12).unwrap().unwrap();
        let s_node_1 = storage_map.get(&1).unwrap().unwrap();
        let s_node_5 = storage_map.get(&5).unwrap().unwrap();
        let s_node_9 = storage_map.get(&9).unwrap().unwrap();
        let s_node_3 = storage_map.get(&3).unwrap().unwrap();

        assert_eq!(*Node::from(s_leaf_0.into_owned()).hash(), leaf_0);
        assert_eq!(*Node::from(s_leaf_1.into_owned()).hash(), leaf_1);
        assert_eq!(*Node::from(s_leaf_2.into_owned()).hash(), leaf_2);
        assert_eq!(*Node::from(s_leaf_3.into_owned()).hash(), leaf_3);
        assert_eq!(*Node::from(s_leaf_4.into_owned()).hash(), leaf_4);
        assert_eq!(*Node::from(s_leaf_5.into_owned()).hash(), leaf_5);
        assert_eq!(*Node::from(s_leaf_6.into_owned()).hash(), leaf_6);
        assert_eq!(*Node::from(s_node_1.into_owned()).hash(), node_1);
        assert_eq!(*Node::from(s_node_5.into_owned()).hash(), node_5);
        assert_eq!(*Node::from(s_node_9.into_owned()).hash(), node_9);
        assert_eq!(*Node::from(s_node_3.into_owned()).hash(), node_3);
    }

    #[test]
    fn load_returns_a_valid_tree() {
        const LEAVES_COUNT: u64 = 2u64.pow(16) - 1;

        let mut storage_map = StorageMap::<TestTable>::new();

        let expected_root = {
            let mut tree = MerkleTree::new(&mut storage_map);
            let data = (0u64..LEAVES_COUNT)
                .map(|i| i.to_be_bytes())
                .collect::<Vec<_>>();
            for datum in data.iter() {
                let _ = tree.push(datum);
            }
            tree.root()
        };

        let root = {
            let tree = MerkleTree::load(&mut storage_map, LEAVES_COUNT).unwrap();
            tree.root()
        };

        assert_eq!(expected_root, root);
    }

    #[test]
    fn load_returns_empty_tree_for_0_leaves() {
        const LEAVES_COUNT: u64 = 0;

        let expected_root = *MerkleTree::<(), ()>::empty_root();

        let root = {
            let mut storage_map = StorageMap::<TestTable>::new();
            let tree = MerkleTree::load(&mut storage_map, LEAVES_COUNT).unwrap();
            tree.root()
        };

        assert_eq!(expected_root, root);
    }

    #[test]
    fn load_returns_a_load_error_if_the_storage_is_not_valid_for_the_leaves_count() {
        const LEAVES_COUNT: u64 = 5;

        let mut storage_map = StorageMap::<TestTable>::new();

        let mut tree = MerkleTree::new(&mut storage_map);
        let data = (0u64..LEAVES_COUNT)
            .map(|i| i.to_be_bytes())
            .collect::<Vec<_>>();
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        let err = MerkleTree::load(&mut storage_map, LEAVES_COUNT * 2)
            .expect_err("Expected load() to return Error; got Ok");
        assert!(matches!(err, MerkleTreeError::LoadError(_)));
    }

    #[test]
    fn root_returns_the_empty_root_for_0_leaves() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let tree = MerkleTree::new(&mut storage_map);

        let root = tree.root();
        assert_eq!(root, empty_sum().clone());
    }

    #[test]
    fn root_returns_the_merkle_root_for_1_leaf() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..1]; // 1 leaf
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        let leaf_0 = leaf_sum(data[0]);

        let root = tree.root();
        assert_eq!(root, leaf_0);
    }

    #[test]
    fn root_returns_the_merkle_root_for_7_leaves() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..7]; // 7 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      \
        //  /  \    /  \    /  \      \
        // 00  02  04  06  08  10     12
        // 00  01  02  03  04  05     06

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);
        let leaf_4 = leaf_sum(data[4]);
        let leaf_5 = leaf_sum(data[5]);
        let leaf_6 = leaf_sum(data[6]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);
        let node_9 = node_sum(&leaf_4, &leaf_5);
        let node_11 = node_sum(&node_9, &leaf_6);
        let node_7 = node_sum(&node_3, &node_11);

        let root = tree.root();
        assert_eq!(root, node_7);
    }

    #[test]
    fn prove_returns_invalid_proof_index_error_for_0_leaves() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let tree = MerkleTree::new(&mut storage_map);

        let err = tree
            .prove(0)
            .expect_err("Expected prove() to return Error; got Ok");
        assert!(matches!(err, MerkleTreeError::InvalidProofIndex(0)));
    }

    #[test]
    fn prove_returns_invalid_proof_index_error_when_index_is_greater_than_number_of_leaves(
    ) {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..5]; // 5 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        let err = tree
            .prove(10)
            .expect_err("Expected prove() to return Error; got Ok");
        assert!(matches!(err, MerkleTreeError::InvalidProofIndex(10)))
    }

    #[test]
    fn prove_returns_the_merkle_root_and_proof_set_for_1_leaf() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..1]; // 1 leaf
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        let leaf_0 = leaf_sum(data[0]);

        {
            let (root, proof_set) = tree.prove(0).unwrap();
            assert_eq!(root, leaf_0);
            assert!(proof_set.is_empty());
        }
    }

    #[test]
    fn prove_returns_the_merkle_root_and_proof_set_for_4_leaves() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..4]; // 4 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        //       03
        //      /  \
        //     /    \
        //   01      05
        //  /  \    /  \
        // 00  02  04  06
        // 00  01  02  03

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);

        {
            let (root, proof_set) = tree.prove(0).unwrap();
            assert_eq!(root, node_3);
            assert_eq!(proof_set[0], leaf_1);
            assert_eq!(proof_set[1], node_5);
        }
        {
            let (root, proof_set) = tree.prove(1).unwrap();
            assert_eq!(root, node_3);
            assert_eq!(proof_set[0], leaf_0);
            assert_eq!(proof_set[1], node_5);
        }
        {
            let (root, proof_set) = tree.prove(2).unwrap();
            assert_eq!(root, node_3);
            assert_eq!(proof_set[0], leaf_3);
            assert_eq!(proof_set[1], node_1);
        }
        {
            let (root, proof_set) = tree.prove(3).unwrap();
            assert_eq!(root, node_3);
            assert_eq!(proof_set[0], leaf_2);
            assert_eq!(proof_set[1], node_1);
        }
    }

    #[test]
    fn prove_returns_the_merkle_root_and_proof_set_for_5_leaves() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..5]; // 5 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        //          07
        //          /\
        //         /  \
        //       03    \
        //      /  \    \
        //     /    \    \
        //   01      05   \
        //  /  \    /  \   \
        // 00  02  04  06  08
        // 00  01  02  03  04

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);
        let leaf_4 = leaf_sum(data[4]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);
        let node_7 = node_sum(&node_3, &leaf_4);

        {
            let (root, proof_set) = tree.prove(0).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_1);
            assert_eq!(proof_set[1], node_5);
            assert_eq!(proof_set[2], leaf_4);
        }
        {
            let (root, proof_set) = tree.prove(1).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_0);
            assert_eq!(proof_set[1], node_5);
            assert_eq!(proof_set[2], leaf_4);
        }
        {
            let (root, proof_set) = tree.prove(2).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_3);
            assert_eq!(proof_set[1], node_1);
            assert_eq!(proof_set[2], leaf_4);
        }
        {
            let (root, proof_set) = tree.prove(3).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_2);
            assert_eq!(proof_set[1], node_1);
            assert_eq!(proof_set[2], leaf_4);
        }
        {
            let (root, proof_set) = tree.prove(4).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], node_3);
        }
    }

    #[test]
    fn prove_returns_the_merkle_root_and_proof_set_for_7_leaves() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..7]; // 7 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      \
        //  /  \    /  \    /  \      \
        // 00  02  04  06  08  10     12
        // 00  01  02  03  04  05     06

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);
        let leaf_4 = leaf_sum(data[4]);
        let leaf_5 = leaf_sum(data[5]);
        let leaf_6 = leaf_sum(data[6]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);
        let node_9 = node_sum(&leaf_4, &leaf_5);
        let node_11 = node_sum(&node_9, &leaf_6);
        let node_7 = node_sum(&node_3, &node_11);

        {
            let (root, proof_set) = tree.prove(0).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_1);
            assert_eq!(proof_set[1], node_5);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(1).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_0);
            assert_eq!(proof_set[1], node_5);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(2).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_3);
            assert_eq!(proof_set[1], node_1);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(3).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_2);
            assert_eq!(proof_set[1], node_1);
            assert_eq!(proof_set[2], node_11);
        }
        {
            let (root, proof_set) = tree.prove(4).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_5);
            assert_eq!(proof_set[1], leaf_6);
            assert_eq!(proof_set[2], node_3);
        }
        {
            let (root, proof_set) = tree.prove(5).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], leaf_4);
            assert_eq!(proof_set[1], leaf_6);
            assert_eq!(proof_set[2], node_3);
        }
        {
            let (root, proof_set) = tree.prove(6).unwrap();
            assert_eq!(root, node_7);
            assert_eq!(proof_set[0], node_9);
            assert_eq!(proof_set[1], node_3);
        }
    }

    #[test]
    fn reset_reverts_tree_to_empty_state() {
        let mut storage_map = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage_map);

        let data = &TEST_DATA[0..4]; // 4 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        tree.reset();

        let root = tree.root();
        let expected_root = *MerkleTree::<(), ()>::empty_root();
        assert_eq!(root, expected_root);

        let data = &TEST_DATA[0..4]; // 4 leaves
        for datum in data.iter() {
            let _ = tree.push(datum);
        }

        let leaf_0 = leaf_sum(data[0]);
        let leaf_1 = leaf_sum(data[1]);
        let leaf_2 = leaf_sum(data[2]);
        let leaf_3 = leaf_sum(data[3]);

        let node_1 = node_sum(&leaf_0, &leaf_1);
        let node_5 = node_sum(&leaf_2, &leaf_3);
        let node_3 = node_sum(&node_1, &node_5);

        let root = tree.root();
        let expected_root = node_3;
        assert_eq!(root, expected_root);
    }

    #[test]
    fn load_overflows() {
        // Given
        let storage_map = StorageMap::<TestTable>::new();
        const LEAVES_COUNT: u64 = u64::MAX;

        // When
        let result = MerkleTree::load(storage_map, LEAVES_COUNT).map(|_| ());

        // Then
        assert_eq!(result, Err(MerkleTreeError::TooLarge));
    }

    #[test]
    fn push_overflows() {
        // Given
        let mut storage_map = StorageMap::<TestTable>::new();
        const LEAVES_COUNT: u64 = u64::MAX / 2;
        loop {
            let result = MerkleTree::load(&mut storage_map, LEAVES_COUNT).map(|_| ());

            if let Err(MerkleTreeError::LoadError(index)) = result {
                storage_map.insert(&index, &Primitive::default()).unwrap();
            } else {
                break;
            }
        }

        // When
        let mut tree = MerkleTree::load(storage_map, LEAVES_COUNT)
            .expect("Expected `load()` to succeed");
        let _ = tree.push(&[]);
        let result = tree.push(&[]);

        // Then
        assert_eq!(result, Err(MerkleTreeError::TooLarge));
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/root_calculator.rs

Source
use core::convert::Infallible;

use crate::{
    binary::{
        empty_sum,
        Node,
    },
    common::Bytes32,
};

use crate::alloc::borrow::ToOwned;
use alloc::vec::Vec;

#[derive(Debug)]
pub(crate) enum NodeStackPushError<E> {
    Callback(E),
    TooLarge,
}

#[derive(Default, Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MerkleRootCalculator {
    stack: Vec<Node>,
}

impl MerkleRootCalculator {
    pub fn new() -> Self {
        Self { stack: Vec::new() }
    }

    pub fn new_with_stack(stack: Vec<Node>) -> Self {
        Self { stack }
    }

    pub fn clear(&mut self) {
        self.stack.clear();
    }

    /// Push a leaf to stack of nodes, propagating changes through the tree.
    /// Calls `node_created` for each new node created, stopping on first error.
    pub(crate) fn push_with_callback<F, E>(
        &mut self,
        node: Node,
        mut node_created: F,
    ) -> Result<(), NodeStackPushError<E>>
    where
        F: FnMut(&Node) -> Result<(), E>,
    {
        node_created(&node).map_err(NodeStackPushError::Callback)?;
        self.stack.push(node);

        // Propagate changes through the tree.
        #[allow(clippy::arithmetic_side_effects)] // ensured by loop condition
        while self.stack.len() > 1 {
            let rhs = &self.stack[self.stack.len() - 1];
            let lhs = &self.stack[self.stack.len() - 2];
            if rhs.height() != lhs.height() {
                break;
            }

            let parent_pos = lhs
                .position()
                .parent()
                .map_err(|_| NodeStackPushError::TooLarge)?;
            let new = Node::create_node(parent_pos, lhs, rhs);
            node_created(&new).map_err(NodeStackPushError::Callback)?;
            let _ = self.stack.pop();
            let _ = self.stack.pop();
            self.stack.push(new);
        }

        Ok(())
    }

    /// Push a new leaf node.
    /// Panics if the tree would be too large to compute the root for.
    /// In practice this never occurs, as you'd run out of memory first.
    pub fn push(&mut self, data: &[u8]) {
        let node = Node::create_leaf(0, data).expect("Zero is a valid index for a leaf");
        self.push_with_callback::<_, Infallible>(node, |_| Ok(()))
            .expect("Tree too large");
    }

    pub fn root(mut self) -> Bytes32 {
        if self.stack.is_empty() {
            return empty_sum().to_owned()
        }
        while self.stack.len() > 1 {
            let right_child = self.stack.pop().expect("Checked in loop bound");
            let left_child = self.stack.pop().expect("Checked in loop bound");
            let merged_pos = left_child
                .position()
                .parent()
                .expect("Left child has no parent");
            let merged_node = Node::create_node(merged_pos, &left_child, &right_child);
            self.stack.push(merged_node);
        }
        self.stack.pop().unwrap().hash().to_owned()
    }

    pub fn root_from_iterator<I: Iterator<Item = T>, T: AsRef<[u8]>>(
        self,
        iterator: I,
    ) -> Bytes32 {
        let mut calculator = MerkleRootCalculator::new();

        for data in iterator {
            calculator.push(data.as_ref());
        }

        calculator.root()
    }

    pub fn stack(&self) -> &Vec<Node> {
        &self.stack
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::binary::in_memory::MerkleTree;
    use fuel_merkle_test_helpers::TEST_DATA;
    #[cfg(test)]
    use serde_json as _;

    #[test]
    fn root_returns_the_empty_root_for_0_leaves() {
        let tree = MerkleTree::new();
        let calculate_root = MerkleRootCalculator::new();

        assert_eq!(tree.root(), calculate_root.root());
    }

    #[test]
    fn root_returns_the_merkle_root_for_1_leaf() {
        let mut tree = MerkleTree::new();
        let mut calculate_root = MerkleRootCalculator::new();

        let data = &TEST_DATA[0..1]; // 1 leaf
        for datum in data.iter() {
            tree.push(datum);
            calculate_root.push(datum)
        }

        assert_eq!(tree.root(), calculate_root.root());
    }

    #[test]
    fn root_returns_the_merkle_root_for_7_leaves() {
        let mut tree = MerkleTree::new();
        let mut calculate_root = MerkleRootCalculator::new();

        let data = &TEST_DATA[0..7];
        for datum in data.iter() {
            tree.push(datum);
            calculate_root.push(datum)
        }
        assert_eq!(tree.root(), calculate_root.root());
    }

    #[test]
    fn root_returns_the_merkle_root_for_100000_leaves() {
        let mut tree = MerkleTree::new();
        let mut calculate_root = MerkleRootCalculator::new();

        for value in 0..10000u64 {
            let data = value.to_le_bytes();
            tree.push(&data);
            calculate_root.push(&data);
        }

        assert_eq!(tree.root(), calculate_root.root());
    }

    #[test]
    fn root_returns_the_merkle_root_from_iterator() {
        let mut tree = MerkleTree::new();
        let calculate_root = MerkleRootCalculator::new();

        let data = &TEST_DATA[0..7];
        for datum in data.iter() {
            tree.push(datum);
        }

        let root = calculate_root.root_from_iterator(data.iter());

        assert_eq!(tree.root(), root);
    }

    #[test]
    #[cfg(feature = "serde")]
    fn test_serialize_deserialize() {
        let mut calculator = MerkleRootCalculator::new();

        let data = &TEST_DATA[0..7];
        for datum in data.iter() {
            calculator.push(datum);
        }
        let json = serde_json::to_string(&calculator).unwrap();

        let deserialized_calculator: MerkleRootCalculator =
            serde_json::from_str(&json).expect("Unable to read from str");

        assert_eq!(calculator.root(), deserialized_calculator.root());
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/binary/hash.rs

Source
use crate::common::{
    empty_sum_sha256,
    Bytes32,
    Prefix,
};

use digest::Digest;
use sha2::Sha256;

type Hash = Sha256;

// Merkle Tree hash of an empty list
// MTH({}) = Hash()
pub const fn empty_sum() -> &'static Bytes32 {
    empty_sum_sha256()
}

// Merkle tree hash of an n-element list D[n]
// MTH(D[n]) = Hash(0x01 || MTH(D[0:k]) || MTH(D[k:n])
pub fn node_sum(lhs_data: &Bytes32, rhs_data: &Bytes32) -> Bytes32 {
    let mut hash = Hash::new();

    hash.update(Prefix::Node);
    hash.update(lhs_data);
    hash.update(rhs_data);

    hash.finalize().into()
}

// Merkle tree hash of a list with one entry
// MTH({d(0)}) = Hash(0x00 || d(0))
pub fn leaf_sum(data: &[u8]) -> Bytes32 {
    let mut hash = Hash::new();

    hash.update(Prefix::Leaf);
    hash.update(data);

    hash.finalize().into()
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/storage.rs

Source
use alloc::borrow::Cow;
use core::convert::Infallible;

// Re-export fuel-storage traits
pub use fuel_storage::{
    Mappable,
    StorageInspect,
    StorageMutate,
};

pub trait StorageInspectInfallible<Type: Mappable> {
    fn get(&self, key: &Type::Key) -> Option<Cow<Type::OwnedValue>>;
    fn contains_key(&self, key: &Type::Key) -> bool;
}

pub trait StorageMutateInfallible<Type: Mappable> {
    fn insert(&mut self, key: &Type::Key, value: &Type::Value);
    fn remove(&mut self, key: &Type::Key);
}

impl<S, Type> StorageInspectInfallible<Type> for S
where
    S: StorageInspect<Type, Error = Infallible>,
    Type: Mappable,
{
    fn get(&self, key: &Type::Key) -> Option<Cow<Type::OwnedValue>> {
        <Self as StorageInspect<Type>>::get(self, key)
            .expect("Expected get() to be infallible")
    }

    fn contains_key(&self, key: &Type::Key) -> bool {
        <Self as StorageInspect<Type>>::contains_key(self, key)
            .expect("Expected contains_key() to be infallible")
    }
}

impl<S, Type> StorageMutateInfallible<Type> for S
where
    S: StorageMutate<Type, Error = Infallible>,
    Type: Mappable,
{
    fn insert(&mut self, key: &Type::Key, value: &Type::Value) {
        <Self as StorageMutate<Type>>::insert(self, key, value)
            .expect("Expected insert() to be infallible")
    }

    fn remove(&mut self, key: &Type::Key) {
        <Self as StorageMutate<Type>>::remove(self, key)
            .expect("Expected remove() to be infallible")
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/msb.rs

Source
type Bit = bool;

pub trait Msb {
    fn get_bit_at_index_from_msb(&self, index: u32) -> Option<Bit>;
    fn common_prefix_count(&self, other: &[u8]) -> u64;
}

impl<const N: usize> Msb for [u8; N] {
    fn get_bit_at_index_from_msb(&self, index: u32) -> Option<Bit> {
        // The byte that contains the bit
        let byte_index = index / 8;
        // The bit within the containing byte
        let byte_bit_index = index % 8;
        self.get(byte_index as usize).map(|byte| {
            #[allow(clippy::arithmetic_side_effects)] // checked above
            let mask = 1 << (7 - byte_bit_index);
            byte & mask != 0
        })
    }

    fn common_prefix_count(&self, other: &[u8]) -> u64 {
        let mut count = 0;
        for (byte1, byte2) in self.iter().zip(other.iter()) {
            // For each pair of bytes, compute the similarity of each byte using
            // exclusive or (XOR). The leading zeros measures the number of
            // similar bits from left to right. For equal bytes, this will be 8.
            let common_bits = (byte1 ^ byte2).leading_zeros();
            #[allow(clippy::arithmetic_side_effects)] // u64 is always large enough
            {
                count += common_bits as u64;
            }
            if byte1 != byte2 {
                break
            }
        }
        count
    }
}

#[allow(clippy::cast_possible_truncation)]
#[cfg(test)]
mod test {
    use crate::common::{
        Bytes1,
        Bytes2,
        Bytes4,
        Bytes8,
        Msb,
    };
    use core::mem::size_of;

    #[test]
    fn test_msb_for_bytes_1() {
        const NUM_BITS: u32 = size_of::<Bytes1>() as u32 * 8;

        let bytes: Bytes1 = [0b10101010];
        let expected_n = u8::from_be_bytes(bytes);

        let mut n = 0;
        for i in 0..NUM_BITS {
            let bit = bytes.get_bit_at_index_from_msb(i).unwrap() as u8;
            let shift = bit << (NUM_BITS - 1 - i);
            n |= shift;
        }

        assert_eq!(n, expected_n);
    }

    #[test]
    fn test_msb_for_bytes_2() {
        const NUM_BITS: u32 = size_of::<Bytes2>() as u32 * 8;

        let bytes: Bytes2 = [0b10101010, 0b10101010];
        let expected_n = u16::from_be_bytes(bytes);

        let mut n = 0;
        for i in 0..NUM_BITS {
            let bit = bytes.get_bit_at_index_from_msb(i).unwrap() as u16;
            let shift = bit << (NUM_BITS - 1 - i);
            n |= shift;
        }

        assert_eq!(n, expected_n);
    }

    #[test]
    fn test_msb_for_bytes_4() {
        const NUM_BITS: u32 = size_of::<Bytes4>() as u32 * 8;

        let bytes: Bytes4 = [0b10101010, 0b10101010, 0b10101010, 0b10101010];
        let expected_n = u32::from_be_bytes(bytes);

        let mut n = 0;
        for i in 0..NUM_BITS {
            let bit = bytes.get_bit_at_index_from_msb(i).unwrap() as u32;
            let shift = bit << (NUM_BITS - 1 - i);
            n |= shift;
        }

        assert_eq!(n, expected_n);
    }

    #[test]
    fn test_msb_for_bytes_8() {
        const NUM_BITS: u32 = size_of::<Bytes8>() as u32 * 8;

        let bytes: Bytes8 = [
            0b10101010, 0b10101010, 0b10101010, 0b10101010, 0b10101010, 0b10101010,
            0b10101010, 0b10101010,
        ];
        let expected_n = u64::from_be_bytes(bytes);

        let mut n = 0;
        for i in 0..NUM_BITS {
            let bit = bytes.get_bit_at_index_from_msb(i).unwrap() as u64;
            let shift = bit << (NUM_BITS - 1 - i);
            n |= shift;
        }

        assert_eq!(n, expected_n);
    }

    #[test]
    fn test_get_bit_at_index_from_msb_returns_none_for_index_out_of_bounds() {
        let bytes: Bytes4 = [0b10101010, 0b10101010, 0b10101010, 0b10101010];

        // Returns None; acceptable inputs for Bytes4 are in [0, 31]
        let bit = bytes.get_bit_at_index_from_msb(32);
        assert_eq!(bit, None);
    }

    #[test]
    fn test_common_prefix_count_returns_count_of_common_bits_when_all_bits_match() {
        let lhs_bytes: Bytes4 = [0b10101010, 0b10101010, 0b10101010, 0b10101010];
        let rhs_bytes: Bytes4 = [0b10101010, 0b10101010, 0b10101010, 0b10101010];
        let common_prefix_count = lhs_bytes.common_prefix_count(&rhs_bytes);

        assert_eq!(common_prefix_count, 4 * 8);
    }

    #[test]
    fn test_common_prefix_count_returns_count_of_common_bits_when_some_bits_match() {
        let lhs_bytes: Bytes4 = [0b11111111, 0b11111111, 0b11111111, 0b11111111];
        let rhs_bytes: Bytes4 = [0b11111111, 0b11111111, 0b11100000, 0b00000000];
        let common_prefix_count = lhs_bytes.common_prefix_count(&rhs_bytes);

        assert_eq!(common_prefix_count, 19);
    }

    #[test]
    fn test_common_prefix_count_returns_0_when_the_first_bits_are_different() {
        let lhs_bytes: Bytes4 = [0b11111111, 0b11111111, 0b11111111, 0b11111111];
        let rhs_bytes: Bytes4 = [0b01111111, 0b11111111, 0b11111111, 0b11111111];
        let common_prefix_count = lhs_bytes.common_prefix_count(&rhs_bytes);

        assert_eq!(common_prefix_count, 0);
    }

    #[test]
    fn test_common_prefix_count_returns_0_when_all_bits_are_different() {
        let lhs_bytes: Bytes4 = [0b11111111, 0b11111111, 0b11111111, 0b11111111];
        let rhs_bytes: Bytes4 = [0b00000000, 0b00000000, 0b00000000, 0b00000000];
        let common_prefix_count = lhs_bytes.common_prefix_count(&rhs_bytes);

        assert_eq!(common_prefix_count, 0);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/path_iterator.rs

Source
use crate::common::{
    node::{
        ChildKeyResult,
        ChildResult,
        ParentNode,
    },
    path::{
        Path,
        Side,
    },
};

/// # Path Iterator
///
/// A naturally arising property of binary trees is that a leaf index encodes
/// the unique path needed to traverse from the root of the tree to that leaf.
/// The index's binary representation can be read left to right as a sequence of
/// traversal instructions: a `0` bit means "descend left" and a `1` bit means
/// "descend right". By following the `x` bits composing the index, starting at
/// the root, descending to the left child at each `0`, descending to the right
/// child at each `1`, we arrive at the leaf position, having touched every node
/// position along the path formed by this index. Note that this algorithm does
/// not prescribe how to descend from one node to the next; it describes merely
/// the direction in which to descend at each step.
///
/// Alternatively, this can be interpreted as reading the index's most
/// significant bit (MSB) at an offset `n`: read the `n`th bit to the right of
/// the MSB. Here, `n` is a given step in the tree traversal, starting at 0, and
/// incrementing by 1 at each depth until the leaf is reached. The
/// traversal path is then the list of nodes calculated by traversing the tree
/// using the instruction (`0` or `1`) indicated at `x`<sub>`n`</sub>, where `x`
/// is the index in binary representation, and `n` is the offset for each digit
/// in `x` from the MSB.
///
/// Reversing this path gives us the path from the leaf to the root.
///
/// Imagine a 3-bit integer type `u3` underpinning a tree's leaf indices. 3 bits
/// give our tree a maximum height of 3, and a maximum number of leaf nodes
/// 2<sup>3</sup> = 8. For demonstration, internal nodes are numbered using
/// in-order indices (note that this would require an integer type with 4 bits
/// or more in practice). In-order indexing provides a deterministic way to
/// descend from one node to the next (see [Position](crate::common::Position)).
///
/// ```text
///                             07
///                            /  \
///                           /    \
///                          /      \
///                         /        \
///                        /          \
///                       /            \
///                     03              11
///                    /  \            /  \
///                   /    \          /    \
///                 01      05      09      13
///                /  \    /  \    /  \    /  \
/// In-order idx: 00  02  04  06  08  10  12  14
///     Leaf idx:  0   1   2   3   4   5   6   7
/// ```
///
/// Let us now find the path to leaf with index `6`. In the above diagram, this
/// is the seventh leaf in the leaf layer. A priori, we can see that the path
/// from the root to this leaf is represented by the following list of in-order
/// indices: `07, 11, 13, 12` (note that the leaf index that corresponds to the
/// in-order index `12` is `6`).
///
/// ```text
/// 0d6: u3 = 0b110
///         = Right, Right, Left
/// ```
///
/// Starting at the tree's root at index `07`, we can follow the instructions
/// encoded by the binary representation of leaf `6` (`0b110`). In combination
/// with our in-order index rules for descending nodes, we evaluate the
/// following:
///
/// 1. The first bit is `1`; move right from `07` to `11`.
/// 2. The next bit is `1`; move right from `11` to `13`.
/// 3. The next and final bit is `0`; move left from `13` to `12`.
///
/// We have arrived at the desired leaf position with in-order index `12` and
/// leaf index `6`. Indeed, following the instructions at each bit has produced
/// the same list of positional indices that we observed earlier: `07, 11, 13,
/// 12`.
pub struct PathIter<T: ParentNode> {
    leaf_key: T::Key,
    current: Option<(ChildResult<T>, ChildKeyResult<T>)>,
    current_offset: u32,
}

impl<T> PathIter<T>
where
    T: ParentNode + Clone,
    T::Key: Clone,
{
    pub fn new(root: &T, leaf_key: &T::Key) -> Self {
        let initial = (Ok(root.clone()), Ok(root.key()));

        #[rustfmt::skip]
        // The initial offset from the most significant bit (MSB).
        //
        // The offset from the MSB indicates which bit to read when deducing the
        // path from the root to the leaf. As we descend down the tree,
        // increasing the traversal depth, we increment this offset and read the
        // corresponding bit to get the next traversal instruction.
        //
        // In the general case, we start by reading the first bit of the path at
        // offset 0. This happens when the path fills its allocated memory;
        // e.g., a path of 256 instructions is encoded within a 256 bit
        // allocation for the leaf key. This also means that the key size in
        // bits is equal to the maximum height of the tree.
        //
        // In the case that the length of the path is less than the number of
        // bits in the key, the initial offset from the MSB must be augmented to
        // accommodate the shortened path. This occurs when the key is allocated
        // with a larger address space to reduce collisions of node addresses.
        //
        // E.g,
        // With an 8-bit key and heights 1 through 7:
        //
        // Height Depth
        // 7      0                        127                    Offset = Bits - Height = 8 - 7 = 1
        //                                 / \
        //                                /   \
        // ...                          ...   ...
        //                              /       \
        //                             /         \
        // 3      4                   07         247              Offset = Bits - Height = 8 - 3 = 5
        //                           /  \        / \
        //                          /    \     ...  \
        //                         /      \          \
        //                        /        \          \
        //                       /          \          \
        //                      /            \          \
        // 2      5           03              11        251       Offset = Bits - Height = 8 - 2 = 6
        //                   /  \            /  \       / \
        //                  /    \          /    \    ...  \
        // 1      6       01      05      09      13       253    Offset = Bits - Height = 8 - 1 = 7
        //               /  \    /  \    /  \    /  \      / \
        // 0      7     00  02  04  06  08  10  12  14   252 254
        //              00  01  02  03  04  05  06  07   126 127
        //
        let initial_offset = T::key_size_bits().checked_sub(root.height())
        .expect("Root height more than key size allows, ParentNode impl is incorrect");
        Self {
            leaf_key: leaf_key.clone(),
            current: Some(initial),
            current_offset: initial_offset,
        }
    }
}

impl<T> Iterator for PathIter<T>
where
    T: ParentNode,
    T::Key: Path,
{
    type Item = (ChildResult<T>, ChildKeyResult<T>);

    fn next(&mut self) -> Option<Self::Item> {
        let value = self.current.take();

        if let Some((ref path_node, _)) = value {
            match path_node {
                Ok(path_node) if path_node.is_node() => {
                    let path = &self.leaf_key;
                    let instruction = path.get_instruction(self.current_offset);
                    self.current = instruction.map(|instruction| {
                        // get_instruction ensures current_offset is ok
                        #[allow(clippy::arithmetic_side_effects)]
                        {
                            self.current_offset += 1;
                        }
                        match instruction {
                            Side::Left => {
                                (path_node.left_child(), path_node.right_child_key())
                            }
                            Side::Right => {
                                (path_node.right_child(), path_node.left_child_key())
                            }
                        }
                    });
                }
                // Terminate the iterator if any of the following are true:
                //    - The path node is a leaf (traversal is complete)
                //    - The left or right child was not found and returned a ChildNotFound
                //      error
                //    - The left or right child returned any other error
                _ => self.current = None,
            }
        }

        value
    }
}

pub trait AsPathIterator<T: ParentNode> {
    fn as_path_iter(&self, leaf_key: &T::Key) -> PathIter<T>;
}

impl<T> AsPathIterator<T> for T
where
    T: ParentNode + Clone,
    T::Key: Clone,
{
    fn as_path_iter(&self, leaf_key: &T::Key) -> PathIter<T> {
        PathIter::new(self, leaf_key)
    }
}

#[cfg(test)]
#[allow(
    clippy::restriction,
    clippy::cast_possible_wrap,
    clippy::cast_sign_loss
)]
mod test {
    use crate::common::{
        node::{
            ChildKeyResult,
            ChildResult,
            Node,
            ParentNode,
        },
        AsPathIterator,
        Bytes8,
    };
    use alloc::vec::Vec;
    use core::convert::Infallible;

    #[derive(Debug, Clone, PartialEq)]
    struct TestNode {
        value: u64,
    }

    impl TestNode {
        pub fn in_order_index(&self) -> u64 {
            self.value
        }

        pub fn leaf_index(&self) -> u64 {
            assert!(self.is_leaf());
            self.value / 2
        }

        pub fn from_in_order_index(index: u64) -> Self {
            Self { value: index }
        }

        pub fn from_leaf_index(index: u64) -> Self {
            Self { value: index * 2 }
        }

        pub fn height(&self) -> u32 {
            (!self.in_order_index()).trailing_zeros()
        }

        pub fn is_leaf(&self) -> bool {
            self.in_order_index() % 2 == 0
        }

        fn child(&self, direction: i64) -> Self {
            assert!(!self.is_leaf());
            let shift = 1 << (self.height() - 1);
            let index = self.in_order_index() as i64 + shift * direction;
            Self::from_in_order_index(index as u64)
        }
    }

    impl Node for TestNode {
        type Key = Bytes8;

        fn height(&self) -> u32 {
            TestNode::height(self)
        }

        #[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)] // const
        fn key_size_bits() -> u32 {
            core::mem::size_of::<Self::Key>() as u32 * 8
        }

        fn leaf_key(&self) -> Self::Key {
            TestNode::leaf_index(self).to_be_bytes()
        }

        fn is_leaf(&self) -> bool {
            TestNode::is_leaf(self)
        }

        fn is_node(&self) -> bool {
            !TestNode::is_leaf(self)
        }
    }

    impl ParentNode for TestNode {
        type ChildKey = u64;
        type Error = Infallible;

        fn key(&self) -> Self::ChildKey {
            self.in_order_index()
        }

        fn left_child(&self) -> ChildResult<Self> {
            Ok(TestNode::child(self, -1))
        }

        fn left_child_key(&self) -> ChildKeyResult<Self> {
            self.left_child().map(|node| node.in_order_index())
        }

        fn right_child(&self) -> ChildResult<Self> {
            Ok(TestNode::child(self, 1))
        }

        fn right_child_key(&self) -> ChildKeyResult<Self> {
            self.right_child().map(|node| node.in_order_index())
        }
    }

    #[test]
    fn test_path_iter_returns_path() {
        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      13
        //  /  \    /  \    /  \    /  \
        // 00  02  04  06  08  10  12  14
        // 00  01  02  03  04  05  06  07
        //
        type Node = TestNode;
        let root = Node::from_in_order_index(7);

        {
            let leaf = Node::from_leaf_index(0);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(3),
                Node::from_in_order_index(1),
                Node::from_leaf_index(0),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(1);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(3),
                Node::from_in_order_index(1),
                Node::from_leaf_index(1),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(2);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(3),
                Node::from_in_order_index(5),
                Node::from_leaf_index(2),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(3);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(3),
                Node::from_in_order_index(5),
                Node::from_leaf_index(3),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(4);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(11),
                Node::from_in_order_index(9),
                Node::from_leaf_index(4),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(5);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(11),
                Node::from_in_order_index(9),
                Node::from_leaf_index(5),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(6);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(11),
                Node::from_in_order_index(13),
                Node::from_leaf_index(6),
            ];
            assert_eq!(path, expected_path);
        }

        {
            let leaf = Node::from_leaf_index(7);
            let path: Vec<TestNode> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(path, _)| path.unwrap())
                .collect();
            let expected_path = vec![
                Node::from_in_order_index(7),
                Node::from_in_order_index(11),
                Node::from_in_order_index(13),
                Node::from_leaf_index(7),
            ];
            assert_eq!(path, expected_path);
        }
    }

    #[test]
    fn test_path_iter_returns_side_nodes() {
        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      13
        //  /  \    /  \    /  \    /  \
        // 00  02  04  06  08  10  12  14
        // 00  01  02  03  04  05  06  07
        //
        type Node = TestNode;
        let root = Node::from_in_order_index(7); // 2^3 - 1

        {
            let leaf = Node::from_leaf_index(0);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value,  // Root's dummy side
                Node::from_in_order_index(11).value, // Sibling of node 3
                Node::from_in_order_index(5).value,  // Sibling of node 1
                Node::from_leaf_index(1).value,      // Sibling of leaf 0
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(1);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value,  // Root's dummy side
                Node::from_in_order_index(11).value, // Sibling of node 3
                Node::from_in_order_index(5).value,  // Sibling of node 1
                Node::from_leaf_index(0).value,      // Sibling of leaf 1
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(2);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value,  // Root's dummy side
                Node::from_in_order_index(11).value, // Sibling of node 3
                Node::from_in_order_index(1).value,  // Sibling of node 5
                Node::from_leaf_index(3).value,      // Sibling of leaf 2
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(3);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value,  // Root's dummy side
                Node::from_in_order_index(11).value, // Sibling of node 3
                Node::from_in_order_index(1).value,  // Sibling of node 5
                Node::from_leaf_index(2).value,      // Sibling of leaf 3
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(4);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value,  // Root's dummy side
                Node::from_in_order_index(3).value,  // Sibling of node 11
                Node::from_in_order_index(13).value, // Sibling of node 9
                Node::from_leaf_index(5).value,      // Sibling of leaf 4
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(5);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value,  // Root's dummy side
                Node::from_in_order_index(3).value,  // Sibling of node 11
                Node::from_in_order_index(13).value, // Sibling of node 9
                Node::from_leaf_index(4).value,      // Sibling of leaf 5
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(6);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value, // Root's dummy side
                Node::from_in_order_index(3).value, // Sibling of node 11
                Node::from_in_order_index(9).value, // Sibling of node 13
                Node::from_leaf_index(7).value,     // Sibling of leaf 6
            ];
            assert_eq!(side, expected_side);
        }

        {
            let leaf = Node::from_leaf_index(7);
            let side: Vec<_> = root
                .as_path_iter(&leaf.leaf_key())
                .map(|(_, side)| side.unwrap())
                .collect();
            let expected_side = vec![
                Node::from_in_order_index(7).value, // Root's dummy side
                Node::from_in_order_index(3).value, // Sibling of node 11
                Node::from_in_order_index(9).value, // Sibling of node 13
                Node::from_leaf_index(6).value,     // Sibling of leaf 7
            ];
            assert_eq!(side, expected_side);
        }
    }

    #[test]
    fn test_path_iter_height_4() {
        type Node = TestNode;
        let root = Node::from_in_order_index(15); // 2^4 - 1
        let leaf = Node::from_leaf_index(4); // 0b0100

        let path: Vec<TestNode> = root
            .as_path_iter(&leaf.leaf_key())
            .map(|(path, _)| path.unwrap())
            .collect();

        let expected_path = vec![
            Node::from_in_order_index(15),
            Node::from_in_order_index(7),
            Node::from_in_order_index(11),
            Node::from_in_order_index(9),
            Node::from_in_order_index(8),
        ];
        assert_eq!(path, expected_path);
    }

    #[test]
    fn test_path_iter_height_8() {
        type Node = TestNode;
        let root = Node::from_in_order_index(255); // 2^8 - 1
        let leaf = Node::from_leaf_index(61); // 0b00111101

        let path: Vec<TestNode> = root
            .as_path_iter(&leaf.leaf_key())
            .map(|(path, _)| path.unwrap())
            .collect();

        let expected_path = vec![
            Node::from_in_order_index(255),
            Node::from_in_order_index(127),
            Node::from_in_order_index(63),
            Node::from_in_order_index(95),
            Node::from_in_order_index(111),
            Node::from_in_order_index(119),
            Node::from_in_order_index(123),
            Node::from_in_order_index(121),
            Node::from_leaf_index(61),
        ];
        assert_eq!(path, expected_path);
    }

    #[test]
    fn test_path_iter_returns_root_root_when_root_is_leaf() {
        type Node = TestNode;
        let root = Node::from_in_order_index(0);
        let leaf = Node::from_leaf_index(0);

        let (path, side): (Vec<TestNode>, Vec<_>) = root
            .as_path_iter(&leaf.leaf_key())
            .map(|(path, side)| (path.unwrap(), side.unwrap()))
            .unzip();

        let expected_path = vec![Node::from_in_order_index(0)];
        let expected_side = vec![0];
        assert_eq!(path, expected_path);
        assert_eq!(side, expected_side);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/position.rs

Source
use crate::common::{
    node::{
        ChildKeyResult,
        Node,
        ParentNode,
    },
    Bytes8,
    PositionPath,
};
use core::convert::Infallible;

use super::{
    node::{
        ChildError,
        ChildResult,
    },
    path::Side,
};

/// # Position
///
/// A `Position` represents a node's position in a binary tree by encapsulating
/// the node's index data. Indices are calculated through in-order traversal of
/// the nodes, starting with the first leaf node. Indexing starts at 0.
///
/// Merkle Trees
///
/// In the context of Merkle trees, trees are constructed "upwards" from leaf
/// nodes. Therefore, indexing is done from the bottom up, starting with the
/// leaves, rather than top down, starting with the root, and we can guarantee a
/// deterministic construction of index data.
///
/// ```text
///               07
///              /  \
///             /    \
///            /      \
///           /        \
///          /          \
///         /            \
///       03              11
///      /  \            /  \
///     /    \          /    \
///   01      05      09      13
///  /  \    /  \    /  \    /  \
/// 00  02  04  06  08  10  12  14
/// ```
///
/// In-order indices can be considered internal to the `Position` struct and are
/// used to facilitate the calculation of positional attributes and the
/// construction of other nodes. Leaf nodes have both an in-order index as part
/// of the tree, and a leaf index determined by its position in the bottom row.
/// Because of the in-order traversal used to calculate the in-order indices,
/// leaf nodes have the property that their in-order index is always equal to
/// their leaf index multiplied by 2.
///
/// ```text
///                    /  \    /  \    /  \    /  \
///     Leaf indices: 00  01  02  03  04  05  06  07
/// In-order indices: 00  02  04  06  08  10  12  14
/// ```
///
/// This allows us to construct a `Position` (and its in-order index) by
/// providing either an in-order index directly or, in the case of a leaf, a
/// leaf index. This functionality is captured by `from_in_order_index()` and
/// `from_leaf_index()` respectively.
///
/// Traversal of a Merkle Tree can be performed by the methods on a given
/// `Position` to retrieve its sibling, parent, or uncle `Position`.
///
/// Merkle Mountain Ranges
///
/// Because the `Position` indices are calculated from in-order traversal
/// starting with the leaves, the deterministic quality of the indices holds
/// true for imbalanced binary trees, including Merkle Mountain Ranges. Consider
/// the following binary tree construction composed of seven leaves (with leaf
/// indices 0 through 6):
///
/// ```text
///       03
///      /  \
///     /    \
///   01      05      09
///  /  \    /  \    /  \
/// 00  02  04  06  08  10  12
/// ```
///
/// Note the absence of internal nodes that would be present in a fully balanced
/// tree: inner nodes with indices 7 and 11 are absent. This is owing to the
/// fact that node indices are calculated deterministically through in-order
/// traversal, not calculated as a sequence.
///
/// Traversal of a Merkle Mountain Range is still done in the same manner as a
/// balanced Merkle tree, using methods to retrieve a `Position's` sibling,
/// parent, or uncle `Position`. However, in such cases, the corresponding
/// sibling or uncle nodes are not guaranteed to exist in the tree.
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Position(u64);

impl Position {
    pub fn in_order_index(self) -> u64 {
        self.0
    }

    pub fn leaf_index(self) -> u64 {
        assert!(self.is_leaf());
        self.in_order_index() / 2
    }

    /// Construct a position from an in-order index.
    pub fn from_in_order_index(index: u64) -> Self {
        Position(index)
    }

    /// Construct a position from a leaf index. The in-order index corresponding
    /// to the leaf index will always equal the leaf index multiplied by 2.
    /// Panics if index is too large to fit into u64.
    pub fn from_leaf_index(index: u64) -> Option<Self> {
        Some(Position(index.checked_mul(2)?))
    }

    #[cfg(test)]
    pub(crate) fn from_leaf_index_unwrap(index: u64) -> Self {
        Self::from_leaf_index(index).expect("Index too large")
    }

    /// The parent position.
    /// The parent position has a height less 1 relative to this position.
    pub fn parent(self) -> Result<Self, GetNodeError> {
        let shift = 1u64
            .checked_shl(self.height())
            .ok_or(GetNodeError::CannotExist)?;
        let this = self.in_order_index();
        Ok(Self::from_in_order_index(match self.orientation()? {
            Side::Left => this.checked_sub(shift).ok_or(GetNodeError::CannotExist)?,
            Side::Right => this.checked_add(shift).ok_or(GetNodeError::CannotExist)?,
        }))
    }

    /// The sibling position.
    /// A position shares the same parent and height as its sibling.
    #[cfg(test)]
    pub fn sibling(self) -> Result<Self, GetNodeError> {
        #[allow(clippy::arithmetic_side_effects)] // height() <= 64
        let shift = 1u64
            .checked_shl(self.height() + 1)
            .ok_or(GetNodeError::CannotExist)?;
        let this = self.in_order_index();
        Ok(Self::from_in_order_index(match self.orientation()? {
            Side::Left => this.checked_sub(shift).ok_or(GetNodeError::CannotExist)?,
            Side::Right => this.checked_add(shift).ok_or(GetNodeError::CannotExist)?,
        }))
    }

    /// The uncle position.
    /// The uncle position is the sibling of the parent and has a height less 1
    /// relative to this position.
    #[cfg(test)]
    pub fn uncle(self) -> Result<Self, GetNodeError> {
        self.parent()?.sibling()
    }

    /// The child position of the current position given by the direction.
    /// A child position has a height less 1 than the current position.
    ///
    /// A child position is calculated as a function of the current position's
    /// index and height, and the supplied direction. The left child
    /// position has the in-order index arriving before the current index;
    /// the right child position has the in-order index arriving after the
    /// current index.
    pub fn child(self, side: Side) -> Result<Self, GetNodeError> {
        if !self.is_node() {
            return Err(GetNodeError::IsLeaf);
        }
        let shift = 1u64
            .checked_shl(
                self.height()
                    .checked_sub(1)
                    .ok_or(GetNodeError::CannotExist)?,
            )
            .ok_or(GetNodeError::CannotExist)?;
        let this = self.in_order_index();
        Ok(Self::from_in_order_index(match side {
            Side::Left => this.checked_sub(shift).ok_or(GetNodeError::CannotExist)?,
            Side::Right => this.checked_add(shift).ok_or(GetNodeError::CannotExist)?,
        }))
    }

    /// Returns the left child of the current position.
    pub fn left_child(self) -> Result<Self, GetNodeError> {
        self.child(Side::Left)
    }

    /// Returns the right child of the current position.
    pub fn right_child(self) -> Result<Self, GetNodeError> {
        self.child(Side::Right)
    }

    /// The height of the index in a binary tree.
    /// Leaf nodes represent height 0. A leaf's parent represents height 1.
    /// Height values monotonically increase as you ascend the tree.
    ///
    /// Height is deterministically calculated as the number of trailing zeros
    /// of the complement of the position's index. The following table
    /// demonstrates the relationship between a position's height and the
    /// trailing zeros.
    ///
    /// | Index (Dec) | Index (Bin) | !Index (Bin) | Trailing 0s | Height |
    /// |-------------|-------------|--------------|-------------|--------|
    /// |           0 |        0000 |         1111 |           0 |      0 |
    /// |           2 |        0010 |         1101 |           0 |      0 |
    /// |           4 |        0100 |         1011 |           0 |      0 |
    /// |           1 |        0001 |         1110 |           1 |      1 |
    /// |           5 |        0101 |         1010 |           1 |      1 |
    /// |           9 |        1001 |         0110 |           1 |      1 |
    /// |           3 |        0011 |         1100 |           2 |      2 |
    /// |          11 |        1011 |         0100 |           2 |      2 |
    pub fn height(self) -> u32 {
        (!self.in_order_index()).trailing_zeros()
    }

    /// Whether or not this position represents a leaf node.
    /// Returns `true` if the position is a leaf node.
    /// Returns `false` if the position is an internal node.
    ///
    /// A position is a leaf node if and only if its in-order index is even. A
    /// position is an internal node if and only if its in-order index is
    /// odd.
    pub fn is_leaf(self) -> bool {
        self.in_order_index() % 2 == 0
    }

    /// Whether or not this position represents an internal node.
    /// Returns `false` if the position is a leaf node.
    /// Returns `true` if the position is an internal node.
    ///
    /// When a position is an internal node, the position will have both a left
    /// and right child.
    pub fn is_node(self) -> bool {
        !self.is_leaf()
    }

    /// Given a leaf position and the total count of leaves in a tree, get the
    /// path from this position to the given leaf position. The shape of the
    /// tree is defined by the `leaves_count` parameter and constrains the
    /// path. See [PositionPath](crate::common::PositionPath).
    pub fn path(self, leaf: &Self, leaves_count: u64) -> PositionPath {
        debug_assert!(leaves_count > 0);
        PositionPath::new(self, *leaf, leaves_count)
    }

    /// Orientation of the position index relative to its parent.
    ///
    /// The orientation is determined by the reading the `n`th rightmost digit
    /// of the index's binary value, where `n` = the height of the position
    /// `+ 1`. The following table demonstrates the relationships between a
    /// position's index, height, and orientation.
    ///
    /// | Index (Dec) | Index (Bin) | Height | Orientation |
    /// |-------------|-------------|--------|-------------|
    /// |           0 |        0000 |      0 |           L |
    /// |           2 |        0010 |      0 |           R |
    /// |           4 |        0100 |      0 |           L |
    /// |           6 |        0110 |      0 |           R |
    /// |           1 |        0001 |      1 |           L |
    /// |           5 |        0101 |      1 |           R |
    /// |           9 |        1001 |      1 |           L |
    /// |          13 |        1101 |      1 |           R |
    fn orientation(self) -> Result<Side, GetNodeError> {
        #[allow(clippy::arithmetic_side_effects)] // height() <= 64
        let shift = 1u64
            .checked_shl(self.height() + 1)
            .ok_or(GetNodeError::CannotExist)?;
        Ok(match self.in_order_index() & shift {
            0 => Side::Right,
            _ => Side::Left,
        })
    }
}

impl Node for Position {
    type Key = Bytes8;

    fn height(&self) -> u32 {
        Position::height(*self)
    }

    #[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)] // const
    fn key_size_bits() -> u32 {
        core::mem::size_of::<Self::Key>() as u32 * 8
    }

    fn leaf_key(&self) -> Self::Key {
        Position::leaf_index(*self).to_be_bytes()
    }

    fn is_leaf(&self) -> bool {
        Position::is_leaf(*self)
    }

    fn is_node(&self) -> bool {
        Position::is_node(*self)
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum GetNodeError {
    /// The operation requires a node that can have children.
    /// This is a leaf, and cannot have children.
    IsLeaf,
    /// The requested node cannot exists as it would be out of bounds.
    CannotExist,
}

impl ParentNode for Position {
    type ChildKey = u64;
    type Error = Infallible;

    fn key(&self) -> Self::ChildKey {
        self.in_order_index()
    }

    fn left_child(&self) -> ChildResult<Self> {
        match self.child(Side::Left) {
            Ok(child) => Ok(child),
            Err(GetNodeError::IsLeaf) => Err(ChildError::NodeIsLeaf),
            Err(GetNodeError::CannotExist) => Err(ChildError::ChildCannotExist),
        }
    }

    fn left_child_key(&self) -> ChildKeyResult<Self> {
        ParentNode::left_child(self).map(|child| child.in_order_index())
    }

    fn right_child(&self) -> ChildResult<Self> {
        match self.child(Side::Right) {
            Ok(child) => Ok(child),
            Err(GetNodeError::IsLeaf) => Err(ChildError::NodeIsLeaf),
            Err(GetNodeError::CannotExist) => Err(ChildError::ChildCannotExist),
        }
    }

    fn right_child_key(&self) -> ChildKeyResult<Self> {
        ParentNode::right_child(self).map(|child| child.in_order_index())
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_from_in_order_index() {
        assert_eq!(Position::from_in_order_index(0).in_order_index(), 0);
        assert_eq!(Position::from_in_order_index(1).in_order_index(), 1);
        assert_eq!(Position::from_in_order_index(!0u64).in_order_index(), !0u64);
    }

    #[test]
    fn test_from_leaf_index_unwrap() {
        assert_eq!(Position::from_leaf_index_unwrap(0).in_order_index(), 0);
        assert_eq!(Position::from_leaf_index_unwrap(1).in_order_index(), 2);
        assert_eq!(
            Position::from_leaf_index_unwrap((!0u64) >> 1).in_order_index(),
            !0u64 - 1
        );
    }

    #[test]
    fn test_equality_returns_true_for_two_equal_positions() {
        assert_eq!(Position(0), Position(0));
        assert_eq!(Position::from_in_order_index(0), Position(0));
        assert_eq!(Position::from_leaf_index_unwrap(1), Position(2));
    }

    #[test]
    fn test_equality_returns_false_for_two_unequal_positions() {
        assert_ne!(Position(0), Position(1));
        assert_ne!(Position::from_in_order_index(0), Position(1));
        assert_ne!(Position::from_leaf_index_unwrap(0), Position(2));
    }

    #[test]
    fn test_height() {
        assert_eq!(Position(0).height(), 0);
        assert_eq!(Position(2).height(), 0);
        assert_eq!(Position(4).height(), 0);

        assert_eq!(Position(1).height(), 1);
        assert_eq!(Position(5).height(), 1);
        assert_eq!(Position(9).height(), 1);

        assert_eq!(Position(3).height(), 2);
        assert_eq!(Position(11).height(), 2);
        assert_eq!(Position(19).height(), 2);
    }

    #[test]
    fn test_sibling() {
        assert_eq!(Position(0).sibling(), Ok(Position(2)));
        assert_eq!(Position(2).sibling(), Ok(Position(0)));

        assert_eq!(Position(1).sibling(), Ok(Position(5)));
        assert_eq!(Position(5).sibling(), Ok(Position(1)));

        assert_eq!(Position(3).sibling(), Ok(Position(11)));
        assert_eq!(Position(11).sibling(), Ok(Position(3)));
    }

    #[test]
    fn test_parent() {
        assert_eq!(Position(0).parent(), Ok(Position(1)));
        assert_eq!(Position(2).parent(), Ok(Position(1)));

        assert_eq!(Position(1).parent(), Ok(Position(3)));
        assert_eq!(Position(5).parent(), Ok(Position(3)));

        assert_eq!(Position(3).parent(), Ok(Position(7)));
        assert_eq!(Position(11).parent(), Ok(Position(7)));
    }

    #[test]
    fn test_uncle() {
        assert_eq!(Position(0).uncle(), Ok(Position(5)));
        assert_eq!(Position(2).uncle(), Ok(Position(5)));
        assert_eq!(Position(4).uncle(), Ok(Position(1)));
        assert_eq!(Position(6).uncle(), Ok(Position(1)));

        assert_eq!(Position(1).uncle(), Ok(Position(11)));
        assert_eq!(Position(5).uncle(), Ok(Position(11)));
        assert_eq!(Position(9).uncle(), Ok(Position(3)));
        assert_eq!(Position(13).uncle(), Ok(Position(3)));
    }

    #[test]
    fn test_left_child() {
        assert_eq!(Position(7).left_child(), Ok(Position(3)));
        assert_eq!(Position(3).left_child(), Ok(Position(1)));
        assert_eq!(Position(1).left_child(), Ok(Position(0)));
        assert_eq!(Position(11).left_child(), Ok(Position(9)));
        assert_eq!(Position(9).left_child(), Ok(Position(8)));
    }

    #[test]
    fn test_right_child() {
        assert_eq!(Position(7).right_child(), Ok(Position(11)));
        assert_eq!(Position(3).right_child(), Ok(Position(5)));
        assert_eq!(Position(1).right_child(), Ok(Position(2)));
        assert_eq!(Position(11).right_child(), Ok(Position(13)));
        assert_eq!(Position(9).right_child(), Ok(Position(10)));
    }

    #[test]
    fn test_is_leaf() {
        assert_eq!(Position(0).is_leaf(), true);
        assert_eq!(Position(2).is_leaf(), true);
        assert_eq!(Position(4).is_leaf(), true);
        assert_eq!(Position(6).is_leaf(), true);

        assert_eq!(Position(1).is_leaf(), false);
        assert_eq!(Position(5).is_leaf(), false);
        assert_eq!(Position(9).is_leaf(), false);
        assert_eq!(Position(13).is_leaf(), false);
    }

    #[test]
    fn test_is_node() {
        assert_eq!(Position(0).is_node(), false);
        assert_eq!(Position(2).is_node(), false);
        assert_eq!(Position(4).is_node(), false);
        assert_eq!(Position(6).is_node(), false);

        assert_eq!(Position(1).is_node(), true);
        assert_eq!(Position(5).is_node(), true);
        assert_eq!(Position(9).is_node(), true);
        assert_eq!(Position(13).is_node(), true);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/storage_map.rs

Source
use crate::{
    alloc::borrow::ToOwned,
    storage::{
        Mappable,
        StorageInspect,
        StorageMutate,
    },
};

use alloc::borrow::Cow;
use hashbrown::HashMap;

#[derive(Debug, Clone)]
pub struct StorageMap<Type>
where
    Type: Mappable,
{
    map: HashMap<Type::OwnedKey, Type::OwnedValue>,
}

impl<Type> Default for StorageMap<Type>
where
    Type: Mappable,
{
    fn default() -> Self {
        Self::new()
    }
}

impl<Type> StorageMap<Type>
where
    Type: Mappable,
{
    pub fn new() -> Self {
        Self {
            map: Default::default(),
        }
    }

    pub fn is_empty(&self) -> bool {
        self.map.is_empty()
    }

    pub fn len(&self) -> usize {
        self.map.len()
    }
}

impl<Type> StorageInspect<Type> for StorageMap<Type>
where
    Type: Mappable,
    Type::Key: Eq + core::hash::Hash,
    Type::OwnedKey: Eq + core::hash::Hash + core::borrow::Borrow<Type::Key>,
{
    type Error = core::convert::Infallible;

    fn get(&self, key: &Type::Key) -> Result<Option<Cow<Type::OwnedValue>>, Self::Error> {
        let result = self.map.get(key);
        let value = result.map(Cow::Borrowed);
        Ok(value)
    }

    fn contains_key(&self, key: &Type::Key) -> Result<bool, Self::Error> {
        let contains = self.map.contains_key(key);
        Ok(contains)
    }
}

impl<Type> StorageMutate<Type> for StorageMap<Type>
where
    Type: Mappable,
    Type::Key: Eq + core::hash::Hash,
    Type::OwnedKey: Eq + core::hash::Hash + core::borrow::Borrow<Type::Key>,
{
    fn replace(
        &mut self,
        key: &Type::Key,
        value: &Type::Value,
    ) -> Result<Option<Type::OwnedValue>, Self::Error> {
        let previous = self
            .map
            .insert(key.to_owned().into(), value.to_owned().into());
        Ok(previous)
    }

    fn take(&mut self, key: &Type::Key) -> Result<Option<Type::OwnedValue>, Self::Error> {
        let value = self.map.remove(key);
        Ok(value)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
    struct TestKey(u32);

    #[derive(Debug, Copy, Clone, PartialEq, Eq)]
    struct TestValue(u32);

    struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = TestKey;
        type OwnedValue = TestValue;
        type Value = Self::OwnedValue;
    }

    #[test]
    fn test_get_returns_value_for_given_key() {
        let key = TestKey(0);
        let mut store = StorageMap::<TestTable>::new();
        let _ = store.insert(&key, &TestValue(0));

        assert_eq!(store.get(&key).unwrap(), Some(Cow::Borrowed(&TestValue(0))));
    }
    #[test]
    fn test_get_returns_none_for_invalid_key() {
        let key = TestKey(0);
        let invalid_key = TestKey(1);
        let mut store = StorageMap::<TestTable>::new();
        let _ = store.insert(&key, &TestValue(0));

        assert_eq!(store.get(&invalid_key).unwrap(), None);
    }

    #[test]
    fn test_insert_existing_key_updates_value_for_given_key() {
        let key = TestKey(0);
        let mut store = StorageMap::<TestTable>::new();
        let _ = store.insert(&key, &TestValue(0));
        let _ = store.insert(&key, &TestValue(1));

        assert_eq!(store.get(&key).unwrap(), Some(Cow::Borrowed(&TestValue(1))));
    }

    #[test]
    fn test_remove_deletes_the_value_for_given_key() {
        let key = TestKey(0);
        let mut store = StorageMap::<TestTable>::new();
        let _ = store.insert(&key, &TestValue(0));
        let _ = store.remove(&key);

        assert_eq!(store.get(&key).unwrap(), None);
    }

    #[test]
    fn test_remove_returns_the_deleted_value_for_given_key() {
        let key = TestKey(0);
        let mut store = StorageMap::<TestTable>::new();
        let _ = store.insert(&key, &TestValue(0));

        assert_eq!(store.take(&key).unwrap(), Some(TestValue(0)));
    }

    #[test]
    fn test_remove_returns_none_for_invalid_key() {
        let invalid_key = TestKey(0);
        let mut store = StorageMap::<TestTable>::new();

        assert_eq!(store.take(&invalid_key).unwrap(), None);
    }

    #[test]
    fn test_contains_key_returns_true_for_valid_key() {
        let key = TestKey(0);
        let mut store = StorageMap::<TestTable>::new();
        let _ = store.insert(&key, &TestValue(0));

        assert_eq!(store.contains_key(&key).unwrap(), true);
    }

    #[test]
    fn test_contains_key_returns_false_for_invalid_key() {
        let invalid_key = TestKey(0);
        let store = StorageMap::<TestTable>::new();

        assert_eq!(store.contains_key(&invalid_key).unwrap(), false);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/path.rs

Source
use crate::common::Msb;

/// The side of a child node in a binary tree.
pub enum Side {
    Left,
    Right,
}

impl From<bool> for Side {
    fn from(bit: bool) -> Self {
        match bit {
            false => Side::Left,
            true => Side::Right,
        }
    }
}

pub trait Path {
    /// Which child node to follow at the given index.
    fn get_instruction(&self, index: u32) -> Option<Side>;

    fn common_path_length(&self, other: &[u8]) -> u64;
}

impl<T> Path for T
where
    T: Msb,
{
    fn get_instruction(&self, index: u32) -> Option<Side> {
        self.get_bit_at_index_from_msb(index).map(Into::into)
    }

    fn common_path_length(&self, other: &[u8]) -> u64 {
        self.common_prefix_count(other)
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/node.rs

Source
use crate::common::{
    Bytes32,
    Bytes8,
};

use alloc::string::String;
use core::fmt;

pub trait KeyFormatting {
    type PrettyType: fmt::Display;

    fn pretty(&self) -> Self::PrettyType;
}

pub trait Node {
    type Key: KeyFormatting;

    fn key_size_bits() -> u32;
    fn height(&self) -> u32;
    fn leaf_key(&self) -> Self::Key;
    fn is_leaf(&self) -> bool;
    fn is_node(&self) -> bool;
}

pub trait ParentNode: Sized + Node {
    type Error;
    type ChildKey;

    fn key(&self) -> Self::ChildKey;
    fn left_child(&self) -> ChildResult<Self>;
    fn left_child_key(&self) -> ChildKeyResult<Self>;
    fn right_child(&self) -> ChildResult<Self>;
    fn right_child_key(&self) -> ChildKeyResult<Self>;
}

#[allow(type_alias_bounds)]
pub type ChildResult<T: ParentNode> = Result<T, ChildError<T::Key, T::Error>>;
#[allow(type_alias_bounds)]
pub type ChildKeyResult<T: ParentNode> =
    Result<T::ChildKey, ChildError<T::Key, T::Error>>;

#[derive(Debug, Clone, derive_more::Display)]
pub enum ChildError<Key, E>
where
    Key: KeyFormatting,
{
    #[display(fmt = "Child with key {} was not found in storage", _0.pretty())]
    ChildNotFound(Key),
    #[display(fmt = "Node channot have the requested child")]
    ChildCannotExist,
    #[display(fmt = "Node is a leaf with no children")]
    NodeIsLeaf,
    #[display(fmt = "{}", _0)]
    Error(E),
}

impl<Key, E> From<E> for ChildError<Key, E>
where
    Key: KeyFormatting,
{
    fn from(e: E) -> Self {
        Self::Error(e)
    }
}

impl KeyFormatting for Bytes8 {
    type PrettyType = u64;

    fn pretty(&self) -> Self::PrettyType {
        u64::from_be_bytes(*self)
    }
}

impl KeyFormatting for Bytes32 {
    type PrettyType = String;

    fn pretty(&self) -> Self::PrettyType {
        hex::encode(self)
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/prefix.rs

Source
const NODE: u8 = 0x01;
const LEAF: u8 = 0x00;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
#[repr(u8)]
pub enum Prefix {
    Node = NODE,
    #[default]
    Leaf = LEAF,
}

impl From<Prefix> for u8 {
    fn from(prefix: Prefix) -> Self {
        match prefix {
            Prefix::Node => NODE,
            Prefix::Leaf => LEAF,
        }
    }
}

impl From<Prefix> for [u8; 1] {
    fn from(prefix: Prefix) -> Self {
        match prefix {
            Prefix::Node => [NODE],
            Prefix::Leaf => [LEAF],
        }
    }
}

#[derive(Debug, Clone, derive_more::Display)]
pub enum PrefixError {
    #[display(fmt = "prefix {_0} is not valid")]
    InvalidPrefix(u8),
}

impl TryFrom<u8> for Prefix {
    type Error = PrefixError;

    fn try_from(byte: u8) -> Result<Self, Self::Error> {
        match byte {
            NODE => Ok(Prefix::Node),
            LEAF => Ok(Prefix::Leaf),
            _ => Err(PrefixError::InvalidPrefix(byte)),
        }
    }
}

impl AsRef<[u8]> for Prefix {
    fn as_ref(&self) -> &[u8] {
        match self {
            Prefix::Node => &[NODE],
            Prefix::Leaf => &[LEAF],
        }
    }
}

impl AsRef<[u8; 1]> for Prefix {
    fn as_ref(&self) -> &[u8; 1] {
        match self {
            Prefix::Node => &[NODE],
            Prefix::Leaf => &[LEAF],
        }
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/position_path.rs

Source
use crate::common::{
    node::Node,
    path_iterator::PathIter,
    AsPathIterator,
    Position,
};

use super::path::Side;

/// # PositionPath
///
/// A PositionPath represents the path of positions created by traversing a
/// binary tree from the root position to the leaf position. The shape of the
/// tree determines path traversal, and can be described accurately by the
/// number of leaves comprising the tree. For example, traversing to the fifth
/// leaf of a balanced eight-leaf tree will generate a different path than
/// traversing to the fifth leaf of an imbalanced five-leaf tree.
///
/// A PositionPath exposes an `iter()` method for performing iteration on this
/// path. Each iteration returns a tuple containing the next position in the
/// path and the corresponding side node. Because the tree may be imbalanced, as
/// described by the path's `leaves_count` parameter, the side node may not
/// necessarily be the direct sibling of the path node; rather, it can be a
/// position at a lower spot in the tree altogether.
pub struct PositionPath {
    root: Position,
    leaf: Position,
    leaves_count: u64,
}

impl PositionPath {
    pub fn new(root: Position, leaf: Position, leaves_count: u64) -> Self {
        debug_assert!(leaves_count > 0);
        Self {
            root,
            leaf,
            leaves_count,
        }
    }

    pub fn iter(self) -> PositionPathIter {
        PositionPathIter::new(self.root, self.leaf, self.leaves_count)
    }
}

pub struct PositionPathIter {
    rightmost_position: Position,
    current_side_node: Option<Position>,
    path_iter: PathIter<Position>,
}

impl PositionPathIter {
    /// Panics if leaves_count is zero, as the tree is not valid
    pub fn new(root: Position, leaf: Position, leaves_count: u64) -> Self {
        Self {
            rightmost_position: Position::from_leaf_index(
                leaves_count
                    .checked_sub(1)
                    .expect("Path to a tree without leaves"),
            )
            .unwrap(),
            current_side_node: None,
            path_iter: root.as_path_iter(&leaf.leaf_key()),
        }
    }
}

impl Iterator for PositionPathIter {
    type Item = (Position, Position);

    fn next(&mut self) -> Option<Self::Item> {
        // Find the next set of path and side positions by iterating from the
        // given root position to the given leaf position and evaluating each
        // position against the tree described by the leaves count.
        let iter = self.path_iter.by_ref().map(|(path, side)| {
            // SAFETY: Path iteration over positions is infallible. Path
            // positions and side positions are both guaranteed to be valid in
            // this context.
            (path.unwrap(), side.unwrap())
        });
        for (path, side) in iter {
            let mut side = Position::from_in_order_index(side);
            // To determine if the position is in the tree, we observe that the
            // highest in-order index belongs to the tree's rightmost leaf
            // position (as defined by the `leaves_count` parameter) and that
            // all path nodes will have an in-order index less than or equal to
            // the in-order index of this rightmost leaf position. If a path
            // position has an in-order index greater than that of the rightmost
            // leaf position, it is invalid in the context of this tree and must
            // be discarded. However, the corresponding side node is valid (or
            // is the ancestor of a valid side node) and represents the side
            // node of a deeper path position that is also valid (i.e., has
            // in-order index less than or equal to that of the rightmost leaf).
            // We can save reference to it now so that we can generate the path
            // node and side node pair later, once both nodes are encountered.
            if path.in_order_index() <= self.rightmost_position.in_order_index() {
                // If we previously encountered a side node corresponding to an
                // invalid path node, we observe that the next valid path node
                // always pairs with this side node. Once the path and side node
                // have been paired, we continue to pair path and side nodes
                // normally.
                if let Some(node) = self.current_side_node.take() {
                    side = node;
                }

                // A side node with an in-order index greater than the index of
                // the rightmost leaf position is invalid and does not exist in
                // the context of this tree. The invalid side node will always
                // be the ancestor of the correct side node. Furthermore, the
                // correct side node will always be a leftward descendent of
                // this invalid side node.
                while side.in_order_index() > self.rightmost_position.in_order_index() {
                    side = side.child(Side::Left).expect("Verified above");
                }

                return Some((path, side))
            } else {
                // If the path node is invalid, save reference to the
                // corresponding side node.
                if self.current_side_node.is_none() {
                    self.current_side_node = Some(side);
                }
            }
        }

        None
    }
}

#[cfg(test)]
mod test {
    use crate::common::Position;
    use alloc::vec::Vec;

    #[test]
    fn test_path_set_returns_path_and_side_nodes_for_1_leaf() {
        let root = Position::from_in_order_index(0);
        let leaf = Position::from_leaf_index_unwrap(0);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 1).iter().unzip();
        let expected_path = [Position::from_in_order_index(0)];
        let expected_side = [Position::from_in_order_index(0)];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);
    }

    #[test]
    fn test_path_set_returns_path_and_side_nodes_for_4_leaves() {
        //       03
        //      /  \
        //     /    \
        //   01      05
        //  /  \    /  \
        // 00  02  04  06
        // 00  01  02  03

        let root = Position::from_in_order_index(3);

        let leaf = Position::from_leaf_index_unwrap(0);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 4).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(0),
        ];
        let expected_side = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(2),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(1);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 4).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(2),
        ];
        let expected_side = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(0),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(2);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 4).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(4),
        ];
        let expected_side = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(6),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(3);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 4).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(6),
        ];
        let expected_side = [
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(4),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);
    }

    #[test]
    fn test_path_set_returns_path_and_side_nodes_for_5_leaves() {
        //          07
        //         /  \
        //       03    \
        //      /  \    \
        //     /    \    \
        //   01      05   \
        //  /  \    /  \   \
        // 00  02  04  06  08
        // 00  01  02  03  04

        let root = Position::from_in_order_index(7);

        let leaf = Position::from_leaf_index_unwrap(0);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 5).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(0),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(8),
            Position::from_in_order_index(5),
            Position::from_in_order_index(2),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(1);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 5).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(2),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(8),
            Position::from_in_order_index(5),
            Position::from_in_order_index(0),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(2);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 5).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(4),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(8),
            Position::from_in_order_index(1),
            Position::from_in_order_index(6),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(3);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 5).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(6),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(8),
            Position::from_in_order_index(1),
            Position::from_in_order_index(4),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(4);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 5).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(8),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);
    }

    #[test]
    fn test_path_set_returns_path_and_side_nodes_for_6_leaves() {
        //            07
        //           /  \
        //          /    \
        //         /      \
        //       03        \
        //      /  \        \
        //     /    \        \
        //   01      05      09
        //  /  \    /  \    /  \
        // 00  02  04  06  08  10
        // 00  01  02  03  04  05

        let root = Position::from_in_order_index(7);

        let leaf = Position::from_leaf_index_unwrap(0);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 6).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(0),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(9),
            Position::from_in_order_index(5),
            Position::from_in_order_index(2),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(1);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 6).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(2),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(9),
            Position::from_in_order_index(5),
            Position::from_in_order_index(0),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(2);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 6).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(4),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(9),
            Position::from_in_order_index(1),
            Position::from_in_order_index(6),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(3);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 6).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(6),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(9),
            Position::from_in_order_index(1),
            Position::from_in_order_index(4),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(4);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 6).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(9),
            Position::from_in_order_index(8),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(10),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(5);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 6).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(9),
            Position::from_in_order_index(10),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(8),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);
    }

    #[test]
    fn test_path_set_returns_path_and_side_nodes_for_7_leaves() {
        //               07
        //              /  \
        //             /    \
        //            /      \
        //           /        \
        //          /          \
        //         /            \
        //       03              11
        //      /  \            /  \
        //     /    \          /    \
        //   01      05      09      \
        //  /  \    /  \    /  \      \
        // 00  02  04  06  08  10     12
        // 00  01  02  03  04  05     06

        let root = Position::from_in_order_index(7);

        let leaf = Position::from_leaf_index_unwrap(0);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(0),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(5),
            Position::from_in_order_index(2),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(1);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(1),
            Position::from_in_order_index(2),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(5),
            Position::from_in_order_index(0),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(2);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(4),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(1),
            Position::from_in_order_index(6),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(3);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(5),
            Position::from_in_order_index(6),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(1),
            Position::from_in_order_index(4),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(4);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(9),
            Position::from_in_order_index(8),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(12),
            Position::from_in_order_index(10),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(5);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(9),
            Position::from_in_order_index(10),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(12),
            Position::from_in_order_index(8),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);

        let leaf = Position::from_leaf_index_unwrap(6);
        let (path_positions, side_positions): (Vec<Position>, Vec<Position>) =
            root.path(&leaf, 7).iter().unzip();
        let expected_path = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(11),
            Position::from_in_order_index(12),
        ];
        let expected_side = [
            Position::from_in_order_index(7),
            Position::from_in_order_index(3),
            Position::from_in_order_index(9),
        ];
        assert_eq!(path_positions, expected_path);
        assert_eq!(side_positions, expected_side);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/error.rs

Source
use crate::common::PrefixError;

#[derive(Debug, Clone, derive_more::Display)]
pub enum DeserializeError {
    #[display(fmt = "{}", _0)]
    PrefixError(PrefixError),
}

impl From<PrefixError> for DeserializeError {
    fn from(err: PrefixError) -> Self {
        DeserializeError::PrefixError(err)
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common/hash.rs

Source
use super::Bytes32;

pub fn sum<T: AsRef<[u8]>>(data: T) -> Bytes32 {
    use digest::Digest;
    let mut hash = sha2::Sha256::new();
    hash.update(data.as_ref());
    hash.finalize().into()
}

pub fn sum_iter<I: IntoIterator<Item = T>, T: AsRef<[u8]>>(iterator: I) -> Bytes32 {
    use digest::Digest;
    let mut hash = sha2::Sha256::new();
    for data in iterator {
        hash.update(data.as_ref());
    }
    hash.finalize().into()
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse.rs

Source
mod hash;
mod merkle_tree;
mod primitive;

pub(crate) use hash::zero_sum;

pub use merkle_tree::{
    MerkleTree,
    MerkleTreeError,
    MerkleTreeKey,
};
pub use primitive::Primitive;
pub mod in_memory;
pub mod proof;

use crate::common::Bytes32;

pub const fn empty_sum() -> &'static Bytes32 {
    zero_sum()
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/common.rs

Source
mod hash;
mod msb;
mod path_iterator;
mod position;
mod position_path;
mod prefix;
mod storage_map;

pub(crate) mod error;
pub(crate) mod node;
pub(crate) mod path;

pub use path_iterator::AsPathIterator;
pub use position::Position;
pub use storage_map::StorageMap;

pub(crate) use msb::Msb;
pub(crate) use position_path::PositionPath;
pub(crate) use prefix::{
    Prefix,
    PrefixError,
};

pub type Bytes1 = [u8; 1];
pub type Bytes2 = [u8; 2];
pub type Bytes4 = [u8; 4];
pub type Bytes8 = [u8; 8];
pub type Bytes16 = [u8; 16];
pub type Bytes32 = [u8; 32];

use alloc::vec::Vec;
pub type ProofSet = Vec<Bytes32>;

pub use hash::{
    sum,
    sum_iter,
};

// Merkle Tree hash of an empty list
// MTH({}) = Hash()
pub const fn empty_sum_sha256() -> &'static Bytes32 {
    const EMPTY_SUM: Bytes32 = [
        0xe3, 0xb0, 0xc4, 0x42, 0x98, 0xfc, 0x1c, 0x14, 0x9a, 0xfb, 0xf4, 0xc8, 0x99,
        0x6f, 0xb9, 0x24, 0x27, 0xae, 0x41, 0xe4, 0x64, 0x9b, 0x93, 0x4c, 0xa4, 0x95,
        0x99, 0x1b, 0x78, 0x52, 0xb8, 0x55,
    ];

    &EMPTY_SUM
}

#[test]
fn empty_sum_sha256_is_empty_hash() {
    use digest::Digest;
    use sha2::Sha256;

    let sum = empty_sum_sha256();
    let empty = Bytes32::from(Sha256::new().finalize());

    assert_eq!(&empty, sum);
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/in_memory.rs

Source
use crate::{
    common::{
        Bytes32,
        StorageMap,
    },
    sparse::{
        self,
        merkle_tree::MerkleTreeKey,
        proof::Proof,
        Primitive,
    },
    storage::{
        Mappable,
        StorageInspect,
        StorageMutate,
    },
};
use alloc::{
    borrow::Cow,
    vec::Vec,
};

/// The table of the Sparse Merkle tree's nodes. [`MerkleTree`] works with it as a sparse
/// merkle tree, where the storage key is `Bytes32` and the value is the
/// [`Buffer`](crate::sparse::Buffer) (raw presentation of the
/// [`Node`](crate::sparse::Node)).
#[derive(Debug)]
pub struct NodesTable;

impl Mappable for NodesTable {
    type Key = Self::OwnedKey;
    type OwnedKey = Bytes32;
    type OwnedValue = Primitive;
    type Value = Self::OwnedValue;
}

type Storage = StorageMap<NodesTable>;
type SparseMerkleTree = sparse::MerkleTree<NodesTable, Storage>;

#[derive(Debug)]
pub struct MerkleTree {
    tree: SparseMerkleTree,
}

impl MerkleTree {
    pub fn new() -> Self {
        Self {
            tree: SparseMerkleTree::new(Storage::new()),
        }
    }

    /// Build a sparse Merkle tree from a set of key-value pairs. This is
    /// equivalent to creating an empty sparse Merkle tree and sequentially
    /// calling [update](Self::update) for each key-value pair. This constructor
    /// is more performant than calling individual sequential updates and is the
    /// preferred approach when the key-values are known upfront. Leaves can be
    /// appended to the returned tree using `update` to further accumulate leaf
    /// data.
    pub fn from_set<I, D>(set: I) -> Self
    where
        I: Iterator<Item = (MerkleTreeKey, D)>,
        D: AsRef<[u8]>,
    {
        let tree = SparseMerkleTree::from_set(Storage::new(), set)
            .expect("`Storage` can't return error");
        Self { tree }
    }

    /// Calculate the sparse Merkle root from a set of key-value pairs. This is
    /// similar to constructing a new tree from a set of key-value pairs using
    /// [from_set](Self::from_set), except this method returns only the root; it
    /// does not write to storage nor return a sparse Merkle tree instance. It
    /// is equivalent to calling `from_set(..)`, followed by `root()`, but does
    /// not incur the overhead of storage writes. This can be helpful when we
    /// know all the key-values in the set upfront and we will not need to
    /// update the set in the future.
    pub fn root_from_set<I, D>(set: I) -> Bytes32
    where
        I: Iterator<Item = (MerkleTreeKey, D)>,
        D: AsRef<[u8]>,
    {
        #[derive(Default)]
        struct EmptyStorage;

        impl StorageInspect<NodesTable> for EmptyStorage {
            type Error = core::convert::Infallible;

            fn get(&self, _: &Bytes32) -> Result<Option<Cow<Primitive>>, Self::Error> {
                Ok(None)
            }

            fn contains_key(&self, _: &Bytes32) -> Result<bool, Self::Error> {
                Ok(false)
            }
        }

        impl StorageMutate<NodesTable> for EmptyStorage {
            fn insert(&mut self, _: &Bytes32, _: &Primitive) -> Result<(), Self::Error> {
                Ok(())
            }

            fn replace(
                &mut self,
                _: &Bytes32,
                _: &Primitive,
            ) -> Result<Option<Primitive>, Self::Error> {
                Ok(None)
            }

            fn remove(&mut self, _: &Bytes32) -> Result<(), Self::Error> {
                Ok(())
            }

            fn take(&mut self, _: &Bytes32) -> Result<Option<Primitive>, Self::Error> {
                Ok(None)
            }
        }

        let tree = sparse::MerkleTree::<NodesTable, _>::from_set(EmptyStorage, set)
            .expect("`Storage` can't return error");
        tree.root()
    }

    /// Calculate the sparse Merkle root as well as all nodes in the Merkle tree
    /// from a set of key-value pairs. This is similar to constructing a new
    /// tree from a set of key-value pairs using [from_set](Self::from_set),
    /// except this method returns only the root and the list of leaves and
    /// nodes in the tree; it does not return a sparse Merkle tree instance.
    /// This can be helpful when we know all the key-values in the set upfront
    /// and we need to defer storage writes, such as expensive database inserts,
    /// for batch operations later in the process.
    pub fn nodes_from_set<I, D>(set: I) -> (Bytes32, Vec<(Bytes32, Primitive)>)
    where
        I: Iterator<Item = (MerkleTreeKey, D)>,
        D: AsRef<[u8]>,
    {
        #[derive(Default)]
        struct VectorStorage {
            storage: Vec<(Bytes32, Primitive)>,
        }

        impl StorageInspect<NodesTable> for VectorStorage {
            type Error = core::convert::Infallible;

            fn get(&self, _: &Bytes32) -> Result<Option<Cow<Primitive>>, Self::Error> {
                unimplemented!("Read operation is not supported")
            }

            fn contains_key(&self, _: &Bytes32) -> Result<bool, Self::Error> {
                unimplemented!("Read operation is not supported")
            }
        }

        impl StorageMutate<NodesTable> for VectorStorage {
            fn insert(
                &mut self,
                key: &Bytes32,
                value: &Primitive,
            ) -> Result<(), Self::Error> {
                self.storage.push((*key, *value));
                Ok(())
            }

            fn replace(
                &mut self,
                key: &Bytes32,
                value: &Primitive,
            ) -> Result<Option<Primitive>, Self::Error> {
                self.storage.push((*key, *value));
                Ok(None)
            }

            fn remove(&mut self, _: &Bytes32) -> Result<(), Self::Error> {
                unimplemented!("Remove operation is not supported")
            }

            fn take(&mut self, _: &Bytes32) -> Result<Option<Primitive>, Self::Error> {
                unimplemented!("Take operation is not supported")
            }
        }

        let tree =
            sparse::MerkleTree::<NodesTable, _>::from_set(VectorStorage::default(), set)
                .expect("`Storage` can't return error");
        let root = tree.root();
        let nodes = tree.into_storage().storage;

        (root, nodes)
    }

    pub fn update(&mut self, key: MerkleTreeKey, data: &[u8]) {
        let _ = self.tree.update(key, data);
    }

    pub fn delete(&mut self, key: MerkleTreeKey) {
        let _ = self.tree.delete(key);
    }

    pub fn root(&self) -> Bytes32 {
        self.tree.root()
    }

    pub fn generate_proof(&self, key: &MerkleTreeKey) -> Option<Proof> {
        self.tree.generate_proof(key).ok()
    }
}

impl Default for MerkleTree {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::common::sum;

    fn key(data: &[u8]) -> MerkleTreeKey {
        MerkleTreeKey::new_without_hash(sum(data))
    }

    #[test]
    fn test_empty_root() {
        let tree = MerkleTree::new();
        let root = tree.root();
        let expected_root =
            "0000000000000000000000000000000000000000000000000000000000000000";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_1() {
        let mut tree = MerkleTree::new();

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA");

        let root = tree.root();
        let expected_root =
            "39f36a7cb4dfb1b46f03d044265df6a491dffc1034121bc1071a34ddce9bb14b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_2() {
        let mut tree = MerkleTree::new();

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA");
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA");

        let root = tree.root();
        let expected_root =
            "8d0ae412ca9ca0afcb3217af8bcd5a673e798bd6fd1dfacad17711e883f494cb";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_3() {
        let mut tree = MerkleTree::new();

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA");
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA");
        tree.update(key(b"\x00\x00\x00\x02"), b"DATA");

        let root = tree.root();
        let expected_root =
            "52295e42d8de2505fdc0cc825ff9fead419cbcf540d8b30c7c4b9c9b94c268b7";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_1_delete_1() {
        let mut tree = MerkleTree::new();

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA");
        tree.delete(key(b"\x00\x00\x00\x00"));

        let root = tree.root();
        let expected_root =
            "0000000000000000000000000000000000000000000000000000000000000000";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_2_delete_1() {
        let mut tree = MerkleTree::new();

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA");
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA");
        tree.delete(key(b"\x00\x00\x00\x01"));

        let root = tree.root();
        let expected_root =
            "39f36a7cb4dfb1b46f03d044265df6a491dffc1034121bc1071a34ddce9bb14b";
        assert_eq!(hex::encode(root), expected_root);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/primitive.rs

Source
use crate::common::{
    Bytes32,
    Prefix,
    PrefixError,
};

/// **Leaf buffer:**
///
/// | Allocation | Data                       |
/// |------------|----------------------------|
/// | `00 - 04`  | Height (4 bytes)           |
/// | `04 - 05`  | Prefix (1 byte, `0x00`)    |
/// | `05 - 37`  | hash(Key) (32 bytes)       |
/// | `37 - 69`  | hash(Data) (32 bytes)      |
///
/// **Node buffer:**
///
/// | Allocation | Data                       |
/// |------------|----------------------------|
/// | `00 - 04`  | Height (4 bytes)           |
/// | `04 - 05`  | Prefix (1 byte, `0x01`)    |
/// | `05 - 37`  | Left child key (32 bytes)  |
/// | `37 - 69`  | Right child key (32 bytes) |
pub type Primitive = (u32, u8, Bytes32, Bytes32);

pub trait PrimitiveView {
    fn height(&self) -> u32;
    fn prefix(&self) -> Result<Prefix, PrefixError>;
    fn bytes_lo(&self) -> &Bytes32;
    fn bytes_hi(&self) -> &Bytes32;
}

impl PrimitiveView for Primitive {
    fn height(&self) -> u32 {
        self.0
    }

    fn prefix(&self) -> Result<Prefix, PrefixError> {
        Prefix::try_from(self.1)
    }

    fn bytes_lo(&self) -> &Bytes32 {
        &self.2
    }

    fn bytes_hi(&self) -> &Bytes32 {
        &self.3
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/proof.rs

Source
use crate::{
    common::{
        path::{
            Path,
            Side,
        },
        sum,
        Bytes32,
        ProofSet,
    },
    sparse::{
        hash::{
            calculate_leaf_hash,
            calculate_node_hash,
        },
        zero_sum,
        MerkleTreeKey,
    },
};

use alloc::vec::Vec;
use core::{
    fmt,
    fmt::Debug,
};

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Proof {
    Inclusion(InclusionProof),
    Exclusion(ExclusionProof),
}

impl Proof {
    pub fn proof_set(&self) -> &ProofSet {
        match self {
            Proof::Inclusion(proof) => &proof.proof_set,
            Proof::Exclusion(proof) => &proof.proof_set,
        }
    }

    pub fn is_inclusion(&self) -> bool {
        match self {
            Proof::Inclusion(_) => true,
            Proof::Exclusion(_) => false,
        }
    }

    pub fn is_exclusion(&self) -> bool {
        !self.is_inclusion()
    }
}

#[derive(Clone, Eq, PartialEq)]
pub struct InclusionProof {
    pub proof_set: ProofSet,
}

impl InclusionProof {
    pub fn verify(&self, root: &Bytes32, key: &MerkleTreeKey, value: &[u8]) -> bool {
        let Self { proof_set } = self;

        if proof_set.len() > 256usize {
            return false;
        }

        let mut current = calculate_leaf_hash(key, &sum(value));
        for (i, side_hash) in proof_set.iter().enumerate() {
            #[allow(clippy::arithmetic_side_effects)] // Cannot underflow
            let index =
                u32::try_from(proof_set.len() - 1 - i).expect("We've checked it above");
            current = match key.get_instruction(index).expect("Infallible") {
                Side::Left => calculate_node_hash(&current, side_hash),
                Side::Right => calculate_node_hash(side_hash, &current),
            };
        }
        current == *root
    }
}

impl Debug for InclusionProof {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let proof_set = self.proof_set.iter().map(hex::encode).collect::<Vec<_>>();
        f.debug_struct("InclusionProof")
            .field("Proof set", &proof_set)
            .finish()
    }
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum ExclusionLeaf {
    Leaf(ExclusionLeafData),
    Placeholder,
}

#[derive(Clone, Eq, PartialEq)]
pub struct ExclusionLeafData {
    /// The leaf key.
    pub leaf_key: Bytes32,
    /// Hash of the value of the leaf.
    pub leaf_value: Bytes32,
}

impl Debug for ExclusionLeafData {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExclusionLeafData")
            .field("Leaf key", &hex::encode(self.leaf_key))
            .field("Leaf value", &hex::encode(self.leaf_value))
            .finish()
    }
}

impl ExclusionLeaf {
    fn hash(&self) -> Bytes32 {
        match self {
            ExclusionLeaf::Leaf(data) => {
                calculate_leaf_hash(&data.leaf_key, &data.leaf_value)
            }
            ExclusionLeaf::Placeholder => *zero_sum(),
        }
    }
}

#[derive(Clone, Eq, PartialEq)]
pub struct ExclusionProof {
    pub proof_set: ProofSet,
    pub leaf: ExclusionLeaf,
}

impl ExclusionProof {
    pub fn verify(&self, root: &Bytes32, key: &MerkleTreeKey) -> bool {
        let Self { proof_set, leaf } = self;

        if let ExclusionLeaf::Leaf(data) = leaf {
            if data.leaf_key == key.as_ref() {
                return false;
            }
        }

        if proof_set.len() > 256usize {
            return false;
        }

        let mut current = leaf.hash();
        for (i, side_hash) in proof_set.iter().enumerate() {
            #[allow(clippy::arithmetic_side_effects)] // Cannot underflow
            let index =
                u32::try_from(proof_set.len() - 1 - i).expect("We've checked it above");
            current = match key.get_instruction(index).expect("Infallible") {
                Side::Left => calculate_node_hash(&current, side_hash),
                Side::Right => calculate_node_hash(side_hash, &current),
            };
        }
        current == *root
    }
}

impl Debug for ExclusionProof {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let proof_set = self.proof_set.iter().map(hex::encode).collect::<Vec<_>>();
        f.debug_struct("ExclusionProof")
            .field("Proof set", &proof_set)
            .field("Leaf", &self.leaf)
            .finish()
    }
}

#[cfg(test)]
#[allow(non_snake_case)]
mod test {
    use crate::{
        common::{
            Bytes32,
            StorageMap,
        },
        sparse::{
            proof::Proof,
            MerkleTree,
            Primitive,
        },
    };
    use fuel_storage::Mappable;

    #[derive(Debug)]
    struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = Bytes32;
        type OwnedValue = Primitive;
        type Value = Self::OwnedValue;
    }

    #[test]
    fn inclusion_proof__verify__returns_true_for_correct_key_and_correct_value() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32].into();
        let v0 = b"DATA_0";
        tree.update(k0, v0).expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let k1 = k1.into();
        let v1 = b"DATA_1";
        tree.update(k1, v1).expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let k2 = k2.into();
        let v2 = b"DATA_2";
        tree.update(k2, v2).expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let k3 = k3.into();
        let v3 = b"DATA_3";
        tree.update(k3, v3).expect("Expected successful update");

        let root = tree.root();

        {
            // Given
            let proof = tree.generate_proof(&k0).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k0, b"DATA_0"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(inclusion);
        }

        {
            // Given
            let proof = tree.generate_proof(&k1).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k1, b"DATA_1"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(inclusion);
        }

        {
            // Given
            let proof = tree.generate_proof(&k2).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k2, b"DATA_2"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(inclusion);
        }

        {
            // Given
            let proof = tree.generate_proof(&k3).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k3, b"DATA_3"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(inclusion);
        }
    }

    #[test]
    fn inclusion_proof__verify__returns_false_for_correct_key_and_incorrect_value() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32].into();
        let v0 = b"DATA_0";
        tree.update(k0, v0).expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let k1 = k1.into();
        let v1 = b"DATA_1";
        tree.update(k1, v1).expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let k2 = k2.into();
        let v2 = b"DATA_2";
        tree.update(k2, v2).expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let k3 = k3.into();
        let v3 = b"DATA_3";
        tree.update(k3, v3).expect("Expected successful update");

        let root = tree.root();

        {
            // Given
            let proof = tree.generate_proof(&k0).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k0, b"DATA_100"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(!inclusion);
        }

        {
            // Given
            let proof = tree.generate_proof(&k1).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k1, b"DATA_100"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(!inclusion);
        }

        {
            // Given
            let proof = tree.generate_proof(&k2).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k2, b"DATA_100"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };

            // Then
            assert!(!inclusion);
        }

        {
            // Given
            let proof = tree.generate_proof(&k3).unwrap();

            // When
            let inclusion = match proof {
                Proof::Inclusion(proof) => proof.verify(&root, &k3, b"DATA_100"),
                Proof::Exclusion(_) => panic!("Expected InclusionProof"),
            };
            // Then
            assert!(!inclusion);
        }
    }

    #[test]
    fn inclusion_proof__verify__returns_false_for_incorrect_key() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32].into();
        let v0 = b"DATA_0";
        tree.update(k0, v0).expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let k1 = k1.into();
        let v1 = b"DATA_1";
        tree.update(k1, v1).expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let k2 = k2.into();
        let v2 = b"DATA_2";
        tree.update(k2, v2).expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let k3 = k3.into();
        let v3 = b"DATA_3";
        tree.update(k3, v3).expect("Expected successful update");

        let root = tree.root();

        // Given
        let proof = tree.generate_proof(&k3).unwrap();

        // When
        let key = [1u8; 32].into();
        let inclusion = match proof {
            Proof::Inclusion(proof) => proof.verify(&root, &key, b"DATA_3"),
            Proof::Exclusion(_) => panic!("Expected InclusionProof"),
        };

        // Then
        assert!(!inclusion);
    }

    #[test]
    fn exclusion_proof__verify__returns_true_for_correct_key() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32];
        let v0 = b"DATA_0";
        tree.update(k0.into(), v0)
            .expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let v1 = b"DATA_1";
        tree.update(k1.into(), v1)
            .expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let v2 = b"DATA_2";
        tree.update(k2.into(), v2)
            .expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let v3 = b"DATA_3";
        tree.update(k3.into(), v3)
            .expect("Expected successful update");

        let root = tree.root();

        // Given
        let key = [0xffu8; 32].into();
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let exclusion = match proof {
            Proof::Inclusion(_) => panic!("Expected ExclusionProof"),
            Proof::Exclusion(proof) => proof.verify(&root, &key),
        };

        // Then
        assert!(exclusion);
    }

    #[test]
    fn exclusion_proof__verify__returns_false_for_incorrect_key() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32].into();
        let v0 = b"DATA_0";
        tree.update(k0, v0).expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let k1 = k1.into();
        let v1 = b"DATA_1";
        tree.update(k1, v1).expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let k2 = k2.into();
        let v2 = b"DATA_2";
        tree.update(k2, v2).expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let k3 = k3.into();
        let v3 = b"DATA_3";
        tree.update(k3, v3).expect("Expected successful update");

        let root = tree.root();

        // Given
        let key = [0xffu8; 32].into();
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let exclusion = match proof {
            Proof::Inclusion(_) => panic!("Expected ExclusionProof"),
            Proof::Exclusion(proof) => proof.verify(&root, &k1),
        };

        // Then
        assert!(!exclusion);
    }

    #[test]
    fn exclusion_proof__verify__returns_true_for_placeholder() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: P1  L0  L2  P0  L1  P2
        //          K0  K2      K1

        let mut k0 = [0u8; 32];
        k0[0] = 0b01000000;
        let k0 = k0.into();
        let v0 = b"DATA_0";
        tree.update(k0, v0).expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01100000;
        let k1 = k1.into();
        let v1 = b"DATA_1";
        tree.update(k1, v1).expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01001000;
        let k2 = k2.into();
        let v2 = b"DATA_2";
        tree.update(k2, v2).expect("Expected successful update");

        let root = tree.root();

        // Given
        let key = [0b00000000; 32].into();
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let exclusion = match proof {
            Proof::Inclusion(_) => panic!("Expected ExclusionProof"),
            Proof::Exclusion(proof) => proof.verify(&root, &key),
        };

        // Then
        assert!(exclusion);
    }
}

#[cfg(test)]
#[allow(non_snake_case)]
mod test_random {
    use crate::{
        common::{
            Bytes32,
            StorageMap,
        },
        sparse::{
            proof::Proof,
            MerkleTree,
            MerkleTreeKey,
            Primitive,
        },
    };
    use fuel_storage::Mappable;

    use rand::{
        prelude::StdRng,
        SeedableRng,
    };

    #[derive(Debug)]
    struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = Bytes32;
        type OwnedValue = Primitive;
        type Value = Self::OwnedValue;
    }

    fn random_bytes32<R>(rng: &mut R) -> Bytes32
    where
        R: rand::Rng + ?Sized,
    {
        let mut bytes = [0u8; 32];
        rng.fill(bytes.as_mut());
        bytes
    }

    #[test]
    fn inclusion_proof__verify__returns_true_for_correct_key_and_correct_value() {
        let mut rng = StdRng::seed_from_u64(0xDEADBEEF);
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        let key = random_bytes32(&mut rng).into();
        let value = random_bytes32(&mut rng);
        tree.update(key, &value).unwrap();

        for _ in 0..1_000 {
            let key = random_bytes32(&mut rng).into();
            let value = random_bytes32(&mut rng);
            tree.update(key, &value).unwrap();
        }

        let root = tree.root();

        // Given
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let inclusion = match proof {
            Proof::Inclusion(proof) => proof.verify(&root, &key, &value),
            Proof::Exclusion(_) => panic!("Expected InclusionProof"),
        };

        // Then
        assert!(inclusion);
    }

    #[test]
    fn inclusion_proof__verify__returns_false_for_correct_key_and_incorrect_value() {
        let mut rng = StdRng::seed_from_u64(0xDEADBEEF);
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        let key = random_bytes32(&mut rng).into();
        let value = random_bytes32(&mut rng);
        tree.update(key, &value).unwrap();

        for _ in 0..1_000 {
            let key = random_bytes32(&mut rng).into();
            let value = random_bytes32(&mut rng);
            tree.update(key, &value).unwrap();
        }

        let root = tree.root();

        // Given
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let inclusion = match proof {
            Proof::Inclusion(proof) => proof.verify(&root, &key, b"DATA"),
            Proof::Exclusion(_) => panic!("Expected InclusionProof"),
        };

        // Then
        assert!(!inclusion);
    }

    #[test]
    fn inclusion_proof__verify__returns_false_for_incorrect_key() {
        let mut rng = StdRng::seed_from_u64(0xDEADBEEF);
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        let key_1 = random_bytes32(&mut rng).into();
        let value_1 = random_bytes32(&mut rng);
        tree.update(key_1, &value_1).unwrap();

        let key_2 = random_bytes32(&mut rng).into();
        let value_2 = random_bytes32(&mut rng);
        tree.update(key_2, &value_2).unwrap();

        for _ in 0..1_000 {
            let key = random_bytes32(&mut rng).into();
            let value = random_bytes32(&mut rng);
            tree.update(key, &value).unwrap();
        }

        let root = tree.root();

        // Given
        // - Generate a proof with key_1
        let proof = tree.generate_proof(&key_1).unwrap();

        // When
        // - Attempt to verify the proof with key_2
        let inclusion = match proof {
            Proof::Inclusion(proof) => proof.verify(&root, &key_2, &value_2),
            Proof::Exclusion(_) => panic!("Expected InclusionProof"),
        };

        // Then
        assert!(!inclusion);
    }

    #[test]
    fn exclusion_proof__verify__returns_true_for_correct_key() {
        let mut rng = StdRng::seed_from_u64(0xDEADBEEF);
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for _ in 0..1_000 {
            let key = random_bytes32(&mut rng);
            let value = random_bytes32(&mut rng);
            tree.update(key.into(), &value).unwrap();
        }

        let root = tree.root();

        // Given
        let key: MerkleTreeKey = random_bytes32(&mut rng).into();
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let exclusion = match proof {
            Proof::Inclusion(_) => panic!("Expected ExclusionProof"),
            Proof::Exclusion(proof) => proof.verify(&root, &key),
        };

        // Then
        assert!(exclusion);
    }

    #[test]
    fn exclusion_proof__verify__returns_true_for_any_key_in_empty_tree() {
        let mut rng = StdRng::seed_from_u64(0xDEADBEEF);
        let mut storage = StorageMap::<TestTable>::new();
        let tree = MerkleTree::new(&mut storage);
        let root = tree.root();

        // Given
        let key = random_bytes32(&mut rng).into();
        let proof = tree.generate_proof(&key).unwrap();

        // When
        let exclusion = match proof {
            Proof::Inclusion(_) => panic!("Expected ExclusionProof"),
            Proof::Exclusion(proof) => proof.verify(&root, &key),
        };

        // Then
        assert!(exclusion);
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/merkle_tree/node.rs

Source
use crate::{
    common::{
        error::DeserializeError,
        node::{
            ChildError,
            ChildResult,
            Node as NodeTrait,
            ParentNode as ParentNodeTrait,
        },
        path::{
            Path,
            Side,
        },
        sum,
        Bytes32,
        Prefix,
    },
    sparse::{
        hash::{
            calculate_hash,
            calculate_leaf_hash,
            calculate_node_hash,
        },
        primitive::{
            Primitive,
            PrimitiveView,
        },
        zero_sum,
    },
    storage::{
        Mappable,
        StorageInspect,
    },
};

use crate::common::node::ChildKeyResult;
use core::{
    fmt,
    marker::PhantomData,
};

#[derive(Clone, PartialEq, Eq)]
pub(super) enum Node {
    Node {
        hash: Bytes32,
        height: u32,
        prefix: Prefix,
        bytes_lo: Bytes32,
        bytes_hi: Bytes32,
    },
    Placeholder,
}

impl Node {
    pub fn max_height() -> u32 {
        Node::key_size_bits()
    }

    pub fn new(
        height: u32,
        prefix: Prefix,
        bytes_lo: Bytes32,
        bytes_hi: Bytes32,
    ) -> Self {
        Self::Node {
            hash: calculate_hash(&prefix, &bytes_lo, &bytes_hi),
            height,
            prefix,
            bytes_lo,
            bytes_hi,
        }
    }

    pub fn create_leaf<D: AsRef<[u8]>>(key: &Bytes32, data: D) -> Self {
        let bytes_hi = sum(data);
        Self::Node {
            hash: calculate_leaf_hash(key, &bytes_hi),
            height: 0u32,
            prefix: Prefix::Leaf,
            bytes_lo: *key,
            bytes_hi,
        }
    }

    pub fn create_node(left_child: &Node, right_child: &Node, height: u32) -> Self {
        let bytes_lo = *left_child.hash();
        let bytes_hi = *right_child.hash();
        Self::Node {
            hash: calculate_node_hash(&bytes_lo, &bytes_hi),
            height,
            prefix: Prefix::Node,
            bytes_lo,
            bytes_hi,
        }
    }

    pub fn create_node_from_hashes(
        bytes_lo: Bytes32,
        bytes_hi: Bytes32,
        height: u32,
    ) -> Self {
        Self::Node {
            hash: calculate_node_hash(&bytes_lo, &bytes_hi),
            height,
            prefix: Prefix::Node,
            bytes_lo,
            bytes_hi,
        }
    }

    pub fn create_node_on_path(
        path: &dyn Path,
        path_node: &Node,
        side_node: &Node,
    ) -> Self {
        if path_node.is_leaf() && side_node.is_leaf() {
            // When joining two leaves, the joined node is found where the paths
            // of the two leaves diverge. The joined node may be a direct parent
            // of the leaves or an ancestor multiple generations above the
            // leaves.
            #[allow(clippy::cast_possible_truncation)] // Key is 32 bytes
            let parent_depth = path_node.common_path_length(side_node) as u32;
            #[allow(clippy::arithmetic_side_effects)] // parent_depth <= max_height
            let parent_height = Node::max_height() - parent_depth;
            match path.get_instruction(parent_depth).unwrap() {
                Side::Left => Node::create_node(path_node, side_node, parent_height),
                Side::Right => Node::create_node(side_node, path_node, parent_height),
            }
        } else {
            // When joining two nodes, or a node and a leaf, the joined node is
            // the direct parent of the node with the greater height and an
            // ancestor of the node with the lesser height.
            // N.B.: A leaf can be a placeholder.
            #[allow(clippy::arithmetic_side_effects)] // Neither node cannot be root
            let parent_height = path_node.height().max(side_node.height()) + 1;
            #[allow(clippy::arithmetic_side_effects)] // parent_height <= max_height
            let parent_depth = Node::max_height() - parent_height;
            match path.get_instruction(parent_depth).unwrap() {
                Side::Left => Node::create_node(path_node, side_node, parent_height),
                Side::Right => Node::create_node(side_node, path_node, parent_height),
            }
        }
    }

    pub fn create_placeholder() -> Self {
        Self::Placeholder
    }

    pub fn common_path_length(&self, other: &Node) -> u64 {
        debug_assert!(self.is_leaf());
        debug_assert!(other.is_leaf());

        // If either of the nodes is a placeholder, the common path length is
        // defined to be 0. This is needed to prevent a 0 bit in the
        // placeholder's key from producing an erroneous match with a 0 bit in
        // the leaf's key.
        if self.is_placeholder() || other.is_placeholder() {
            0
        } else {
            self.leaf_key().common_path_length(other.leaf_key())
        }
    }

    pub fn height(&self) -> u32 {
        match self {
            Node::Node { height, .. } => *height,
            Node::Placeholder => 0,
        }
    }

    pub fn is_leaf(&self) -> bool {
        self.prefix() == Prefix::Leaf || self.is_placeholder()
    }

    pub fn is_node(&self) -> bool {
        self.prefix() == Prefix::Node
    }

    pub fn is_placeholder(&self) -> bool {
        &Self::Placeholder == self
    }

    pub fn hash(&self) -> &Bytes32 {
        match self {
            Node::Node { hash, .. } => hash,
            Node::Placeholder => zero_sum(),
        }
    }

    fn prefix(&self) -> Prefix {
        match self {
            Node::Node { prefix, .. } => *prefix,
            Node::Placeholder => Prefix::Leaf,
        }
    }

    pub fn bytes_lo(&self) -> &Bytes32 {
        match self {
            Node::Node { bytes_lo, .. } => bytes_lo,
            Node::Placeholder => zero_sum(),
        }
    }

    pub fn bytes_hi(&self) -> &Bytes32 {
        match self {
            Node::Node { bytes_hi, .. } => bytes_hi,
            Node::Placeholder => zero_sum(),
        }
    }

    /// Get the leaf key of a leaf node.
    ///
    /// The leaf key is the lower 32 bytes stored in a leaf node.
    /// This method expects the node to be a leaf node, and this precondition
    /// must be guaranteed at the call site for correctness. This method should
    /// only be used within contexts where this precondition can be guaranteed,
    /// such as the [MerkleTree](super::MerkleTree).
    ///
    /// In `debug`, this method will panic if the node is not a leaf node to
    /// indicate to the developer that there is a potential problem in the
    /// tree's implementation.  
    pub(super) fn leaf_key(&self) -> &Bytes32 {
        debug_assert!(self.is_leaf());
        self.bytes_lo()
    }

    /// Get the leaf data of a leaf node.
    ///
    /// The leaf key is the upper 32 bytes stored in a leaf node.
    /// This method expects the node to be a leaf node, and this precondition
    /// must be guaranteed at the call site for correctness. This method should
    /// only be used within contexts where this precondition can be guaranteed,
    /// such as the [MerkleTree](super::MerkleTree).
    ///
    /// In `debug`, this method will panic if the node is not a leaf node to
    /// indicate to the developer that there is a potential problem in the
    /// tree's implementation.
    pub(super) fn leaf_data(&self) -> &Bytes32 {
        debug_assert!(self.is_leaf());
        self.bytes_hi()
    }

    /// Get the left child key of an internal node.
    ///
    /// The left child key is the lower 32 bytes stored in an internal node.
    /// This method expects the node to be an internal node, and this
    /// precondition must be guaranteed at the call site for correctness. This
    /// method should only be used within contexts where this precondition can
    /// be guaranteed, such as the [MerkleTree](super::MerkleTree).
    ///
    /// In `debug`, this method will panic if the node is not an internal node
    /// to indicate to the developer that there is a potential problem in the
    /// tree's implementation.
    pub(super) fn left_child_key(&self) -> &Bytes32 {
        debug_assert!(self.is_node());
        self.bytes_lo()
    }

    /// Get the right child key of an internal node.
    ///
    /// The right child key is the upper 32 bytes stored in an internal node.
    /// This method expects the node to be an internal node, and this
    /// precondition must be guaranteed at the call site for correctness. This
    /// method should only be used within contexts where this precondition can
    /// be guaranteed, such as the [MerkleTree](super::MerkleTree).
    ///
    /// In `debug`, this method will panic if the node is not an internal node
    /// to indicate to the developer that there is a potential problem in the
    /// tree's implementation.
    pub(super) fn right_child_key(&self) -> &Bytes32 {
        debug_assert!(self.is_node());
        self.bytes_hi()
    }
}

impl AsRef<Node> for Node {
    fn as_ref(&self) -> &Node {
        self
    }
}

impl NodeTrait for Node {
    type Key = Bytes32;

    fn height(&self) -> u32 {
        Node::height(self)
    }

    #[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)] // const
    fn key_size_bits() -> u32 {
        core::mem::size_of::<Self::Key>() as u32 * 8
    }

    fn leaf_key(&self) -> Self::Key {
        *Node::leaf_key(self)
    }

    fn is_leaf(&self) -> bool {
        Node::is_leaf(self)
    }

    fn is_node(&self) -> bool {
        Node::is_node(self)
    }
}

impl From<&Node> for Primitive {
    fn from(node: &Node) -> Self {
        (
            node.height(),
            node.prefix() as u8,
            *node.bytes_lo(),
            *node.bytes_hi(),
        )
    }
}

impl TryFrom<Primitive> for Node {
    type Error = DeserializeError;

    fn try_from(primitive: Primitive) -> Result<Self, Self::Error> {
        let height = primitive.height();
        let prefix = primitive.prefix()?;
        let bytes_lo = *primitive.bytes_lo();
        let bytes_hi = *primitive.bytes_hi();
        let node = Self::new(height, prefix, bytes_lo, bytes_hi);
        Ok(node)
    }
}

impl fmt::Debug for Node {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.is_node() {
            f.debug_struct("Node (Internal)")
                .field("Height", &self.height())
                .field("Hash", &hex::encode(self.hash()))
                .field("Left child key", &hex::encode(self.left_child_key()))
                .field("Right child key", &hex::encode(self.right_child_key()))
                .finish()
        } else {
            f.debug_struct("Node (Leaf)")
                .field("Height", &self.height())
                .field("Hash", &hex::encode(self.hash()))
                .field("Leaf key", &hex::encode(self.leaf_key()))
                .field("Leaf data", &hex::encode(self.leaf_data()))
                .finish()
        }
    }
}

pub(super) struct StorageNode<'storage, TableType, StorageType> {
    storage: &'storage StorageType,
    node: Node,
    phantom_table: PhantomData<TableType>,
}

impl<TableType, StorageType> Clone for StorageNode<'_, TableType, StorageType> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage,
            node: self.node.clone(),
            phantom_table: Default::default(),
        }
    }
}

impl<'s, TableType, StorageType> StorageNode<'s, TableType, StorageType> {
    pub fn new(storage: &'s StorageType, node: Node) -> Self {
        Self {
            node,
            storage,
            phantom_table: Default::default(),
        }
    }
}

impl<TableType, StorageType> StorageNode<'_, TableType, StorageType> {
    pub fn hash(&self) -> &Bytes32 {
        self.node.hash()
    }

    pub fn into_node(self) -> Node {
        self.node
    }
}

impl<TableType, StorageType> NodeTrait for StorageNode<'_, TableType, StorageType> {
    type Key = Bytes32;

    fn height(&self) -> u32 {
        self.node.height()
    }

    #[allow(clippy::arithmetic_side_effects, clippy::cast_possible_truncation)] // const
    fn key_size_bits() -> u32 {
        core::mem::size_of::<Self::Key>() as u32 * 8
    }

    fn leaf_key(&self) -> Self::Key {
        *self.node.leaf_key()
    }

    fn is_leaf(&self) -> bool {
        self.node.is_leaf()
    }

    fn is_node(&self) -> bool {
        self.node.is_node()
    }
}

#[derive(Debug, Clone, derive_more::Display)]
pub enum StorageNodeError<StorageError> {
    #[display(fmt = "{}", _0)]
    StorageError(StorageError),
    #[display(fmt = "{}", _0)]
    DeserializeError(DeserializeError),
}

impl<TableType, StorageType> ParentNodeTrait for StorageNode<'_, TableType, StorageType>
where
    StorageType: StorageInspect<TableType>,
    TableType: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,
{
    type ChildKey = Bytes32;
    type Error = StorageNodeError<StorageType::Error>;

    fn key(&self) -> Self::ChildKey {
        *self.hash()
    }

    fn left_child(&self) -> ChildResult<Self> {
        if self.is_leaf() {
            return Err(ChildError::NodeIsLeaf)
        }
        let key = self.node.left_child_key();
        if key == zero_sum() {
            return Ok(Self::new(self.storage, Node::create_placeholder()))
        }
        let primitive = self
            .storage
            .get(key)
            .map_err(StorageNodeError::StorageError)?
            .ok_or(ChildError::ChildNotFound(*key))?;
        Ok(primitive
            .into_owned()
            .try_into()
            .map(|node| Self::new(self.storage, node))
            .map_err(StorageNodeError::DeserializeError)?)
    }

    fn left_child_key(&self) -> ChildKeyResult<Self> {
        if self.is_leaf() {
            return Err(ChildError::NodeIsLeaf)
        }
        Ok(*self.node.left_child_key())
    }

    fn right_child(&self) -> ChildResult<Self> {
        if self.is_leaf() {
            return Err(ChildError::NodeIsLeaf)
        }
        let key = self.node.right_child_key();
        if key == zero_sum() {
            return Ok(Self::new(self.storage, Node::create_placeholder()))
        }
        let primitive = self
            .storage
            .get(key)
            .map_err(StorageNodeError::StorageError)?
            .ok_or(ChildError::ChildNotFound(*key))?;
        Ok(primitive
            .into_owned()
            .try_into()
            .map(|node| Self::new(self.storage, node))
            .map_err(StorageNodeError::DeserializeError)?)
    }

    fn right_child_key(&self) -> ChildKeyResult<Self> {
        if self.is_leaf() {
            return Err(ChildError::NodeIsLeaf)
        }
        Ok(*self.node.right_child_key())
    }
}

impl<TableType, StorageType> fmt::Debug for StorageNode<'_, TableType, StorageType>
where
    StorageType: StorageInspect<TableType>,
    TableType: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if self.is_node() {
            f.debug_struct("StorageNode (Internal)")
                .field("Height", &self.height())
                .field("Hash", &hex::encode(self.hash()))
                .field("Left child key", &hex::encode(self.node.left_child_key()))
                .field("Right child key", &hex::encode(self.node.right_child_key()))
                .finish()
        } else {
            f.debug_struct("StorageNode (Leaf)")
                .field("Height", &self.height())
                .field("Hash", &hex::encode(self.hash()))
                .field("Leaf key", &hex::encode(self.node.leaf_key()))
                .field("Leaf data", &hex::encode(self.node.leaf_data()))
                .finish()
        }
    }
}

#[cfg(test)]
mod test_node {
    use super::Node;
    use crate::{
        common::{
            error::DeserializeError,
            sum,
            Bytes32,
            Prefix,
            PrefixError,
        },
        sparse::{
            zero_sum,
            Primitive,
        },
    };

    fn leaf_hash(key: &Bytes32, data: &[u8]) -> Bytes32 {
        let mut buffer = [0; 65];
        buffer[0..1].clone_from_slice(Prefix::Leaf.as_ref());
        buffer[1..33].clone_from_slice(key);
        buffer[33..65].clone_from_slice(&sum(data));
        sum(buffer)
    }

    #[test]
    fn test_create_leaf_returns_a_valid_leaf() {
        let leaf = Node::create_leaf(&sum(b"LEAF"), [1u8; 32]);
        assert_eq!(leaf.is_leaf(), true);
        assert_eq!(leaf.is_node(), false);
        assert_eq!(leaf.height(), 0);
        assert_eq!(leaf.prefix(), Prefix::Leaf);
        assert_eq!(*leaf.leaf_key(), sum(b"LEAF"));
        assert_eq!(*leaf.leaf_data(), sum([1u8; 32]));
    }

    #[test]
    fn test_create_node_returns_a_valid_node() {
        let left_child = Node::create_leaf(&sum(b"LEFT CHILD"), [1u8; 32]);
        let right_child = Node::create_leaf(&sum(b"RIGHT CHILD"), [1u8; 32]);
        let node = Node::create_node(&left_child, &right_child, 1);
        assert_eq!(node.is_leaf(), false);
        assert_eq!(node.is_node(), true);
        assert_eq!(node.height(), 1);
        assert_eq!(node.prefix(), Prefix::Node);
        assert_eq!(
            *node.left_child_key(),
            leaf_hash(&sum(b"LEFT CHILD"), &[1u8; 32])
        );
        assert_eq!(
            *node.right_child_key(),
            leaf_hash(&sum(b"RIGHT CHILD"), &[1u8; 32])
        );
    }

    #[test]
    fn test_create_placeholder_returns_a_placeholder_node() {
        let node = Node::create_placeholder();
        assert_eq!(node.is_placeholder(), true);
        assert_eq!(node.hash(), zero_sum());
    }

    #[test]
    fn test_create_leaf_from_primitive_returns_a_valid_leaf() {
        let primitive = (0, Prefix::Leaf as u8, [0xff; 32], [0xff; 32]);

        let node: Node = primitive.try_into().unwrap();
        assert_eq!(node.is_leaf(), true);
        assert_eq!(node.is_node(), false);
        assert_eq!(node.height(), 0);
        assert_eq!(node.prefix(), Prefix::Leaf);
        assert_eq!(*node.leaf_key(), [0xff; 32]);
        assert_eq!(*node.leaf_data(), [0xff; 32]);
    }

    #[test]
    fn test_create_node_from_primitive_returns_a_valid_node() {
        let primitive = (255, Prefix::Node as u8, [0xff; 32], [0xff; 32]);

        let node: Node = primitive.try_into().unwrap();
        assert_eq!(node.is_leaf(), false);
        assert_eq!(node.is_node(), true);
        assert_eq!(node.height(), 255);
        assert_eq!(node.prefix(), Prefix::Node);
        assert_eq!(*node.left_child_key(), [0xff; 32]);
        assert_eq!(*node.right_child_key(), [0xff; 32]);
    }

    #[test]
    fn test_create_from_primitive_returns_deserialize_error_if_invalid_prefix() {
        let primitive = (0xff, 0xff, [0xff; 32], [0xff; 32]);

        // Should return Error; prefix 0xff is does not represent a node or leaf
        let err = Node::try_from(primitive)
            .expect_err("Expected try_from() to be Error; got OK");
        assert!(matches!(
            err,
            DeserializeError::PrefixError(PrefixError::InvalidPrefix(0xff))
        ));
    }

    /// For leaf node `node` of leaf data `d` with key `k`:
    /// ```node = (0x00, k, h(serialize(d)))```
    #[test]
    fn test_leaf_primitive_returns_expected_primitive() {
        let expected_primitive =
            (0_u32, Prefix::Leaf as u8, sum(b"LEAF"), sum([1u8; 32]));

        let leaf = Node::create_leaf(&sum(b"LEAF"), [1u8; 32]);
        let primitive = Primitive::from(&leaf);

        assert_eq!(primitive, expected_primitive);
    }

    /// For internal node `node` with children `l` and `r`:
    /// ```node = (0x01, l.v, r.v)```
    #[test]
    fn test_node_primitive_returns_expected_primitive() {
        let expected_primitive = (
            1_u32,
            Prefix::Node as u8,
            leaf_hash(&sum(b"LEFT CHILD"), &[1u8; 32]),
            leaf_hash(&sum(b"RIGHT CHILD"), &[1u8; 32]),
        );

        let left_child = Node::create_leaf(&sum(b"LEFT CHILD"), [1u8; 32]);
        let right_child = Node::create_leaf(&sum(b"RIGHT CHILD"), [1u8; 32]);
        let node = Node::create_node(&left_child, &right_child, 1);
        let primitive = Primitive::from(&node);

        assert_eq!(primitive, expected_primitive);
    }

    /// For leaf node `node` of leaf data `d` with key `k`:
    /// ```node.v = h(0x00, k, h(serialize(d)))```
    #[test]
    fn test_leaf_hash_returns_expected_hash_value() {
        let mut expected_buffer = [0u8; 65];
        expected_buffer[0..1].clone_from_slice(Prefix::Leaf.as_ref());
        expected_buffer[1..33].clone_from_slice(&sum(b"LEAF"));
        expected_buffer[33..65].clone_from_slice(&sum([1u8; 32]));
        let expected_value = sum(expected_buffer);

        let node = Node::create_leaf(&sum(b"LEAF"), [1u8; 32]);
        let value = *node.hash();

        assert_eq!(value, expected_value);
    }

    /// For internal node `node` with children `l` and `r`:
    /// ```node.v = h(0x01, l.v, r.v)```
    #[test]
    fn test_node_hash_returns_expected_hash_value() {
        let mut expected_buffer = [0u8; 65];
        expected_buffer[0..1].clone_from_slice(Prefix::Node.as_ref());
        expected_buffer[1..33]
            .clone_from_slice(&leaf_hash(&sum(b"LEFT CHILD"), &[1u8; 32]));
        expected_buffer[33..65]
            .clone_from_slice(&leaf_hash(&sum(b"RIGHT CHILD"), &[1u8; 32]));
        let expected_value = sum(expected_buffer);

        let left_child = Node::create_leaf(&sum(b"LEFT CHILD"), [1u8; 32]);
        let right_child = Node::create_leaf(&sum(b"RIGHT CHILD"), [1u8; 32]);
        let node = Node::create_node(&left_child, &right_child, 1);
        let value = *node.hash();

        assert_eq!(value, expected_value);
    }
}

#[cfg(test)]
mod test_storage_node {
    use super::{
        Node,
        StorageNode,
        StorageNodeError,
    };
    use crate::{
        common::{
            error::DeserializeError,
            node::{
                ChildError,
                ParentNode,
            },
            sum,
            Bytes32,
            PrefixError,
            StorageMap,
        },
        sparse::Primitive,
        storage::{
            Mappable,
            StorageMutate,
        },
    };

    pub struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = Bytes32;
        type OwnedValue = Primitive;
        type Value = Self::OwnedValue;
    }

    #[test]
    fn test_node_left_child_returns_the_left_child() {
        let mut s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let _ = s.insert(leaf_0.hash(), &leaf_0.as_ref().into());

        let leaf_1 = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let _ = s.insert(leaf_1.hash(), &leaf_1.as_ref().into());

        let node_0 = Node::create_node(&leaf_0, &leaf_1, 1);
        let _ = s.insert(node_0.hash(), &node_0.as_ref().into());

        let storage_node = StorageNode::new(&s, node_0);
        let child = storage_node.left_child().unwrap();

        assert_eq!(child.hash(), leaf_0.hash());
    }

    #[test]
    fn test_node_right_child_returns_the_right_child() {
        let mut s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let _ = s.insert(leaf_0.hash(), &leaf_0.as_ref().into());

        let leaf_1 = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let _ = s.insert(leaf_1.hash(), &leaf_1.as_ref().into());

        let node_0 = Node::create_node(&leaf_0, &leaf_1, 1);
        let _ = s.insert(node_0.hash(), &node_0.as_ref().into());

        let storage_node = StorageNode::new(&s, node_0);
        let child = storage_node.right_child().unwrap();

        assert_eq!(child.hash(), leaf_1.hash());
    }

    #[test]
    fn test_node_left_child_returns_placeholder_when_key_is_zero_sum() {
        let mut s = StorageMap::<TestTable>::new();

        let leaf = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let _ = s.insert(leaf.hash(), &leaf.as_ref().into());

        let node_0 = Node::create_node(&Node::create_placeholder(), &leaf, 1);
        let _ = s.insert(node_0.hash(), &node_0.as_ref().into());

        let storage_node = StorageNode::new(&s, node_0);
        let child = storage_node.left_child().unwrap();

        assert!(child.node.is_placeholder());
    }

    #[test]
    fn test_node_right_child_returns_placeholder_when_key_is_zero_sum() {
        let mut s = StorageMap::<TestTable>::new();

        let leaf = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let _ = s.insert(leaf.hash(), &leaf.as_ref().into());

        let node_0 = Node::create_node(&leaf, &Node::create_placeholder(), 1);
        let _ = s.insert(node_0.hash(), &node_0.as_ref().into());

        let storage_node = StorageNode::new(&s, node_0);
        let child = storage_node.right_child().unwrap();

        assert!(child.node.is_placeholder());
    }

    #[test]
    fn test_node_left_child_returns_error_when_node_is_leaf() {
        let s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let storage_node = StorageNode::new(&s, leaf_0);
        let err = storage_node
            .left_child()
            .expect_err("Expected left_child() to return Error; got OK");

        assert!(matches!(err, ChildError::NodeIsLeaf));
    }

    #[test]
    fn test_node_right_child_returns_error_when_node_is_leaf() {
        let s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let storage_node = StorageNode::new(&s, leaf_0);
        let err = storage_node
            .right_child()
            .expect_err("Expected right_child() to return Error; got OK");

        assert!(matches!(err, ChildError::NodeIsLeaf));
    }

    #[test]
    fn test_node_left_child_returns_error_when_key_is_not_found() {
        let s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [0u8; 32]);
        let leaf_1 = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let node_0 = Node::create_node(&leaf_0, &leaf_1, 1);

        let storage_node = StorageNode::new(&s, node_0);
        let err = storage_node
            .left_child()
            .expect_err("Expected left_child() to return Error; got Ok");

        let key = *storage_node.into_node().left_child_key();
        assert!(matches!(
            err,
            ChildError::ChildNotFound(k) if k == key
        ));
    }

    #[test]
    fn test_node_right_child_returns_error_when_key_is_not_found() {
        let s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let leaf_1 = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let node_0 = Node::create_node(&leaf_0, &leaf_1, 1);

        let storage_node = StorageNode::new(&s, node_0);
        let err = storage_node
            .right_child()
            .expect_err("Expected right_child() to return Error; got Ok");

        let key = *storage_node.into_node().right_child_key();
        assert!(matches!(
            err,
            ChildError::ChildNotFound(k) if k == key
        ));
    }

    #[test]
    fn test_node_left_child_returns_deserialize_error_when_primitive_is_invalid() {
        let mut s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let _ = s.insert(leaf_0.hash(), &(0xff, 0xff, [0xff; 32], [0xff; 32]));
        let leaf_1 = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let node_0 = Node::create_node(&leaf_0, &leaf_1, 1);

        let storage_node = StorageNode::new(&s, node_0);
        let err = storage_node
            .left_child()
            .expect_err("Expected left_child() to be Error; got Ok");

        assert!(matches!(
            err,
            ChildError::Error(StorageNodeError::DeserializeError(
                DeserializeError::PrefixError(PrefixError::InvalidPrefix(0xff))
            ))
        ));
    }

    #[test]
    fn test_node_right_child_returns_deserialize_error_when_primitive_is_invalid() {
        let mut s = StorageMap::<TestTable>::new();

        let leaf_0 = Node::create_leaf(&sum(b"Hello World"), [1u8; 32]);
        let leaf_1 = Node::create_leaf(&sum(b"Goodbye World"), [1u8; 32]);
        let _ = s.insert(leaf_1.hash(), &(0xff, 0xff, [0xff; 32], [0xff; 32]));
        let node_0 = Node::create_node(&leaf_0, &leaf_1, 1);

        let storage_node = StorageNode::new(&s, node_0);
        let err = storage_node
            .right_child()
            .expect_err("Expected right_child() to be Error; got Ok");

        assert!(matches!(
            err,
            ChildError::Error(StorageNodeError::DeserializeError(
                DeserializeError::PrefixError(PrefixError::InvalidPrefix(0xff))
            ))
        ));
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/merkle_tree/branch.rs

Source
use super::Node;
use crate::{
    common::{
        path::Path,
        Bytes32,
    },
    sparse::Primitive,
};
use fuel_storage::{
    Mappable,
    StorageMutate,
};

use core::iter;

pub(super) struct Branch {
    pub bits: Bytes32,
    pub node: Node,
}

impl From<Node> for Branch {
    fn from(leaf: Node) -> Self {
        Self {
            bits: *leaf.leaf_key(),
            node: leaf,
        }
    }
}

pub(super) fn merge_branches<Storage, Table>(
    storage: &mut Storage,
    mut left_branch: Branch,
    mut right_branch: Branch,
) -> Result<Branch, Storage::Error>
where
    Storage: StorageMutate<Table>,
    Table: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,
{
    #[allow(clippy::cast_possible_truncation)] // Key is 32 bytes, never truncates
    let ancestor_height = if left_branch.node.is_leaf() && right_branch.node.is_leaf() {
        let parent_depth = left_branch.node.common_path_length(&right_branch.node) as u32;
        #[allow(clippy::arithmetic_side_effects)] // common_path_length <= max_height
        let parent_height = Node::max_height() - parent_depth;
        parent_height
    } else {
        let ancestor_depth =
            left_branch.bits.common_path_length(&right_branch.bits) as u32;
        #[allow(clippy::arithmetic_side_effects)] // common_path_length <= max_height
        let ancestor_height = Node::max_height() - ancestor_depth;

        for branch in [&mut right_branch, &mut left_branch] {
            if branch.node.is_node() {
                let path = branch.bits;
                #[allow(clippy::arithmetic_side_effects)]
                // branch cannot be at max height
                let parent_height = branch.node.height() + 1;
                #[allow(clippy::arithmetic_side_effects)]
                // common_path_length <= max_height
                let stale_depth = ancestor_height - parent_height;
                let placeholders =
                    iter::repeat(Node::create_placeholder()).take(stale_depth as usize);
                for placeholder in placeholders {
                    branch.node =
                        Node::create_node_on_path(&path, &branch.node, &placeholder);
                    storage.insert(branch.node.hash(), &branch.node.as_ref().into())?;
                }
            }
        }
        ancestor_height
    };
    let node = Node::create_node(&left_branch.node, &right_branch.node, ancestor_height);
    storage.insert(node.hash(), &node.as_ref().into())?;
    Ok(Branch {
        bits: left_branch.bits,
        node,
    })
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/merkle_tree.rs

Source
mod branch;
mod node;

use branch::{
    merge_branches,
    Branch,
};
use node::{
    Node,
    StorageNode,
    StorageNodeError,
};

use crate::{
    common::{
        error::DeserializeError,
        node::ChildError,
        AsPathIterator,
        Bytes32,
    },
    sparse::{
        empty_sum,
        proof::{
            ExclusionLeaf,
            ExclusionLeafData,
            ExclusionProof,
            InclusionProof,
            Proof,
        },
        Primitive,
    },
    storage::{
        Mappable,
        StorageInspect,
        StorageMutate,
    },
};
use alloc::{
    format,
    vec::Vec,
};
use core::{
    fmt::{
        Debug,
        Formatter,
    },
    iter,
    marker::PhantomData,
    ops::Deref,
};

#[derive(Debug, Clone, derive_more::Display)]
pub enum MerkleTreeError<StorageError> {
    #[display(
        fmt = "cannot load node with key {}; the key is not found in storage",
        "hex::encode(_0)"
    )]
    LoadError(Bytes32),

    #[display(fmt = "{}", _0)]
    StorageError(StorageError),

    #[display(fmt = "{}", _0)]
    DeserializeError(DeserializeError),

    #[display(fmt = "{}", _0)]
    ChildError(ChildError<Bytes32, StorageNodeError<StorageError>>),
}

impl<StorageError> From<StorageError> for MerkleTreeError<StorageError> {
    fn from(err: StorageError) -> MerkleTreeError<StorageError> {
        MerkleTreeError::StorageError(err)
    }
}

/// The safe Merkle tree storage key prevents Merkle tree structure manipulations.
/// The type contains only one constructor that hashes the storage key.
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
#[cfg_attr(test, derive(proptest_derive::Arbitrary))]
pub struct MerkleTreeKey(Bytes32);

impl MerkleTreeKey {
    /// The safe way to create a `Self`. It hashes the `storage_key`, making
    /// it entirely random and preventing SMT structure manipulation.
    pub fn new<B>(storage_key: B) -> Self
    where
        B: AsRef<[u8]>,
    {
        use digest::Digest;
        let mut hash = sha2::Sha256::new();
        hash.update(storage_key.as_ref());
        let hash = hash.finalize().into();

        Self(hash)
    }

    /// Unsafe analog to create a `Self` that doesn't hash the `storage_key` unlike
    /// `Self::new`.
    ///
    /// # Safety
    ///
    /// It is safe to use this method if you know that `storage_key`
    /// was randomly generated like `ContractId` or `AssetId`.
    pub unsafe fn convert<B>(storage_key: B) -> Self
    where
        B: Into<Bytes32>,
    {
        Self(storage_key.into())
    }

    #[cfg(any(test, feature = "test-helpers"))]
    pub fn new_without_hash<B>(storage_key: B) -> Self
    where
        B: Into<Bytes32>,
    {
        unsafe { Self::convert(storage_key) }
    }
}

impl Debug for MerkleTreeKey {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.write_str(&format!("MerkleTreeKey({})", hex::encode(self.0)))
    }
}

impl From<MerkleTreeKey> for Bytes32 {
    fn from(value: MerkleTreeKey) -> Self {
        value.0
    }
}

impl AsRef<[u8]> for MerkleTreeKey {
    fn as_ref(&self) -> &[u8] {
        self.0.as_ref()
    }
}

impl AsRef<Bytes32> for MerkleTreeKey {
    fn as_ref(&self) -> &Bytes32 {
        &self.0
    }
}

impl Deref for MerkleTreeKey {
    type Target = Bytes32;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

#[cfg(any(test, feature = "test-helpers"))]
impl From<Bytes32> for MerkleTreeKey {
    fn from(value: Bytes32) -> Self {
        Self::new_without_hash(value)
    }
}

#[derive(Debug)]
pub struct MerkleTree<TableType, StorageType> {
    root_node: Node,
    storage: StorageType,
    phantom_table: PhantomData<TableType>,
}

impl<TableType, StorageType> MerkleTree<TableType, StorageType> {
    pub const fn empty_root() -> &'static Bytes32 {
        empty_sum()
    }

    pub fn root(&self) -> Bytes32 {
        *self.root_node().hash()
    }

    pub fn into_storage(self) -> StorageType {
        self.storage
    }

    pub fn storage(&self) -> &StorageType {
        &self.storage
    }

    fn root_node(&self) -> &Node {
        &self.root_node
    }

    fn set_root_node(&mut self, node: Node) {
        debug_assert!(node.is_leaf() || node.height() == Node::max_height());
        self.root_node = node;
    }
}

impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
where
    TableType: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,
    StorageType: StorageInspect<TableType, Error = StorageError>,
{
    pub fn new(storage: StorageType) -> Self {
        Self {
            root_node: Node::create_placeholder(),
            storage,
            phantom_table: Default::default(),
        }
    }

    pub fn load(
        storage: StorageType,
        root: &Bytes32,
    ) -> Result<Self, MerkleTreeError<StorageError>> {
        if root == Self::empty_root() {
            let tree = Self::new(storage);
            Ok(tree)
        } else {
            let primitive = storage
                .get(root)?
                .ok_or_else(|| MerkleTreeError::LoadError(*root))?
                .into_owned();
            let tree = Self {
                root_node: primitive
                    .try_into()
                    .map_err(MerkleTreeError::DeserializeError)?,
                storage,
                phantom_table: Default::default(),
            };
            Ok(tree)
        }
    }

    fn path_set(
        &self,
        leaf_key: &Bytes32,
    ) -> Result<(Vec<Node>, Vec<Bytes32>), MerkleTreeError<StorageError>> {
        let root_node = self.root_node().clone();
        let root_storage_node = StorageNode::new(&self.storage, root_node);
        let (mut path_nodes, mut side_nodes): (Vec<Node>, Vec<Bytes32>) =
            root_storage_node
                .as_path_iter(leaf_key)
                .map(|(path_node, side_node)| {
                    Ok((
                        path_node.map_err(MerkleTreeError::ChildError)?.into_node(),
                        side_node.map_err(MerkleTreeError::ChildError)?,
                    ))
                })
                .collect::<Result<Vec<_>, MerkleTreeError<StorageError>>>()?
                .into_iter()
                .unzip();
        path_nodes.reverse();
        side_nodes.reverse();
        side_nodes.pop(); // The last element in the side nodes list is the
                          // root; remove it.

        Ok((path_nodes, side_nodes))
    }
}

impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
where
    TableType: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,
    StorageType: StorageMutate<TableType, Error = StorageError>,
{
    /// Build a sparse Merkle tree from a set of key-value pairs. This is
    /// equivalent to creating an empty sparse Merkle tree and sequentially
    /// calling [update](Self::update) for each key-value pair. This constructor
    /// is more performant than calling individual sequential updates and is the
    /// preferred approach when the key-values are known upfront. Leaves can be
    /// appended to the returned tree using `update` to further accumulate leaf
    /// data.
    pub fn from_set<B, I, D>(
        mut storage: StorageType,
        set: I,
    ) -> Result<Self, StorageError>
    where
        I: Iterator<Item = (B, D)>,
        B: Into<Bytes32>,
        D: AsRef<[u8]>,
    {
        let sorted = set
            .into_iter()
            .map(|(k, v)| (k.into(), v))
            .collect::<alloc::collections::BTreeMap<Bytes32, D>>();
        let mut branches = sorted
            .iter()
            .filter(|(_, value)| !value.as_ref().is_empty())
            .map(|(key, data)| Node::create_leaf(key, data))
            .map(Into::<Branch>::into)
            .collect::<Vec<_>>();

        for branch in branches.iter() {
            let leaf = &branch.node;
            storage.insert(leaf.hash(), &leaf.as_ref().into())?;
        }

        if branches.is_empty() {
            let tree = Self::new(storage);
            return Ok(tree)
        }

        if branches.len() == 1 {
            let leaf = branches.pop().expect("Expected at least 1 leaf").node;
            let mut tree = Self::new(storage);
            tree.set_root_node(leaf);
            return Ok(tree)
        }

        let mut nodes = Vec::<Branch>::with_capacity(branches.len());
        let mut proximities = Vec::<u32>::with_capacity(branches.len());

        // Building the tree starts by merging all leaf nodes where possible.
        // Given a set of leaf nodes sorted left to right (i.e., keys are sorted
        // in lexical order), we scan the leaf set right to left, and analyze a
        // moving window of three leaves: a center (or "current") leaf, its left
        // neighbor, and its right neighbor.
        //
        // When merging leaf nodes, we analyze this three-node window to
        // determine if the condition for merging is met: When the current node
        // is closer to its right neighbor than it is to its left neighbor, we
        // merge the current node with its right neighbor. The merged node then
        // becomes the center of the window, and we must check the merge
        // condition again. We calculate proximity using the common path length
        // between two nodes, which is also the depth of their shared ancestor
        // in the tree.
        //
        // This three-node window is centered around a current node, and moves
        // leftward: At the next iteration, the current node is now the right
        // node, the left node is now the current node, and so on. When we have
        // checked all windows, we know that we have merged all leaf nodes where
        // possible.
        while let Some(left) = branches.pop() {
            if let Some(current) = nodes.last() {
                #[allow(clippy::cast_possible_truncation)] // Key is 32 bytes
                let left_proximity = current.node.common_path_length(&left.node) as u32;
                while {
                    // The current node's proximity to its right neighbor was
                    // stored previously. We now compare the distances between
                    // the current node's left and right neighbors. If, and only
                    // if, the current node is closer to its right neighbor, we
                    // merge these nodes to form an ancestor node. We then
                    // reform the window, using the ancestor node in the center,
                    // to check if we must merge again.
                    //
                    // If the current node is closer to its left, we do not have
                    // enough information to merge nodes, and we must continue
                    // scanning the leaf set leftwards to find a configuration
                    // that satisfies the merge condition.
                    if let Some(right_proximity) = proximities.last() {
                        *right_proximity > left_proximity
                    } else {
                        false
                    }
                } {
                    // The current node is closer to its right neighbor than its
                    // left neighbor. We now merge the current node with its
                    // right neighbor.
                    let current =
                        nodes.pop().expect("Expected current node to be present");
                    let right = nodes.pop().expect("Expected right node to be present");
                    let merged = merge_branches(&mut storage, current, right)?;
                    nodes.push(merged);

                    // Now that the current node and its right neighbour are
                    // merged, the distance between them has collapsed and their
                    // proximity is no longer needed.
                    proximities.pop();
                }
                proximities.push(left_proximity);
            }
            nodes.push(left);
        }

        // Where possible, all the leaves have been merged. The remaining leaves
        // and nodes are stacked in order of height descending. This means that
        // they are also ordered with the leftmost leaves at the top and the
        // rightmost nodes at the bottom. We can iterate through the stack and
        // merge them left to right.
        let top = {
            let mut node = nodes
                .pop()
                .expect("Nodes stack must have at least 1 element");
            while let Some(next) = nodes.pop() {
                node = merge_branches(&mut storage, node, next)?;
            }
            node
        };

        // Lastly, all leaves and nodes are merged into one. The resulting node
        // may still be an ancestor node below the root. To calculate the final
        // root, we merge placeholder nodes along the path until the resulting
        // node has the final height and forms the root node.
        let mut node = top.node;
        let path = top.bits;
        let height = node.height();
        #[allow(clippy::arithmetic_side_effects)] // height <= max_height
        let depth = Node::max_height() - height;
        let placeholders = iter::repeat(Node::create_placeholder()).take(depth as usize);
        for placeholder in placeholders {
            node = Node::create_node_on_path(&path, &node, &placeholder);
            storage.insert(node.hash(), &node.as_ref().into())?;
        }

        let tree = Self {
            root_node: node,
            storage,
            phantom_table: Default::default(),
        };
        Ok(tree)
    }

    pub fn update(
        &mut self,
        key: MerkleTreeKey,
        data: &[u8],
    ) -> Result<(), MerkleTreeError<StorageError>> {
        if data.is_empty() {
            // If the data is empty, this signifies a delete operation for the
            // given key.
            self.delete(key)?;
            return Ok(())
        }

        let leaf_node = Node::create_leaf(key.as_ref(), data);
        self.storage
            .insert(leaf_node.hash(), &leaf_node.as_ref().into())?;

        if self.root_node().is_placeholder() {
            self.set_root_node(leaf_node);
        } else {
            let (path_nodes, side_nodes) = self.path_set(key.as_ref())?;
            self.update_with_path_set(
                &leaf_node,
                path_nodes.as_slice(),
                side_nodes.as_slice(),
            )?;
        }

        Ok(())
    }

    pub fn delete(
        &mut self,
        key: MerkleTreeKey,
    ) -> Result<(), MerkleTreeError<StorageError>> {
        if self.root() == *Self::empty_root() {
            // The zero root signifies that all leaves are empty, including the
            // given key.
            return Ok(())
        }

        let (path_nodes, side_nodes): (Vec<Node>, Vec<_>) =
            self.path_set(key.as_ref())?;

        match path_nodes.first() {
            Some(node) if *node.leaf_key() == key.as_ref() => {
                self.delete_with_path_set(path_nodes.as_slice(), side_nodes.as_slice())?;
            }
            _ => {}
        };

        Ok(())
    }

    fn update_with_path_set(
        &mut self,
        requested_leaf_node: &Node,
        path_nodes: &[Node],
        side_nodes: &[Bytes32],
    ) -> Result<(), StorageError> {
        let path = requested_leaf_node.leaf_key();
        let actual_leaf_node = &path_nodes[0];

        if requested_leaf_node == actual_leaf_node {
            return Ok(())
        }

        // Build the tree upwards starting with the requested leaf node.
        let mut current_node = requested_leaf_node.clone();

        // If we are creating a new leaf node, the corresponding side node will
        // be the first node in the path set. The side node will be the leaf
        // node currently closest to the requested new leaf node. When creating
        // a new leaf node, we must merge the leaf node with its corresponding
        // side node to create a common ancestor. We then continue building the
        // tree upwards from this ancestor node. This may require creating new
        // placeholder side nodes, in addition to the existing side node set.
        //
        // If we are updating an existing leaf node, the leaf node we are
        // updating is the first node in the path set. The side node set will
        // already include all the side nodes needed to build up the tree from
        // the requested leaf node, since these side nodes were already built
        // during the creation of the leaf node.
        //
        // We can determine if we are updating an existing leaf node, or if we
        // are creating a new leaf node, by comparing the paths of the requested
        // leaf node and the leaf node at the start of the path set. When the
        // paths are equal, it means the leaf nodes occupy the same location,
        // and we are updating an existing leaf. Otherwise, it means we are
        // adding a new leaf node.
        if requested_leaf_node.leaf_key() != actual_leaf_node.leaf_key() {
            // Merge leaves
            if !actual_leaf_node.is_placeholder() {
                current_node =
                    Node::create_node_on_path(path, &current_node, actual_leaf_node);
                self.storage
                    .insert(current_node.hash(), &current_node.as_ref().into())?;
            }

            // Merge placeholders
            let ancestor_depth = requested_leaf_node.common_path_length(actual_leaf_node);
            #[allow(clippy::cast_possible_truncation)] // Key is 32 bytes
            let placeholders_count =
                (ancestor_depth as usize).saturating_sub(side_nodes.len());
            let placeholders =
                iter::repeat(Node::create_placeholder()).take(placeholders_count);
            for placeholder in placeholders {
                current_node =
                    Node::create_node_on_path(path, &current_node, &placeholder);
                self.storage
                    .insert(current_node.hash(), &current_node.as_ref().into())?;
            }
        } else {
            self.storage.remove(actual_leaf_node.hash())?;
        }

        // Merge side nodes
        for (side_node, old_parent) in
            side_nodes.iter().zip(path_nodes.iter().skip(1 /* leaf */))
        {
            let new_parent = if old_parent.bytes_lo() == side_node {
                Node::create_node_from_hashes(
                    *side_node,
                    *current_node.hash(),
                    old_parent.height(),
                )
            } else {
                Node::create_node_from_hashes(
                    *current_node.hash(),
                    *side_node,
                    old_parent.height(),
                )
            };

            current_node = new_parent;
            self.storage
                .insert(current_node.hash(), &current_node.as_ref().into())?;
            self.storage.remove(old_parent.hash())?;
        }

        self.set_root_node(current_node);

        Ok(())
    }

    fn delete_with_path_set(
        &mut self,
        path_nodes: &[Node],
        side_nodes: &[Bytes32],
    ) -> Result<(), MerkleTreeError<StorageError>> {
        for node in path_nodes {
            self.storage.remove(node.hash())?;
        }

        let mut side_nodes_iter = side_nodes.iter();
        let mut path_nodes_iter = path_nodes.iter();
        path_nodes_iter.next(); // Skip the requested leaf node

        // The deleted leaf is replaced by a placeholder. Build the tree upwards
        // starting with the placeholder.
        let mut current_node = Node::create_placeholder();

        // If the first side node is a leaf, it means the ancestor node is now
        // parent to a placeholder (the deleted leaf node) and a leaf node (the
        // first side node). We can immediately discard the ancestor node from
        // further calculation and attach the orphaned leaf node to its next
        // ancestor. Any subsequent ancestor nodes composed of this leaf node
        // and a placeholder must be similarly discarded from further
        // calculation. We then create a valid ancestor node for the orphaned
        // leaf node by joining it with the earliest non-placeholder side node.
        if let Some(first_side_node) = side_nodes.first() {
            let first_side_node: Node = self
                .storage
                .get(first_side_node)?
                .ok_or(MerkleTreeError::LoadError(*first_side_node))?
                .into_owned()
                .try_into()
                .map_err(MerkleTreeError::DeserializeError)?;

            if first_side_node.is_leaf() {
                side_nodes_iter.next();
                current_node = first_side_node.clone();

                // Advance the side node iterator to the next non-placeholder
                // node. This may be either another leaf node or an internal
                // node. If only placeholder nodes exist beyond the first leaf
                // node, then that leaf node is, in fact, the new root node.
                //
                // Using `find(..)` advances the iterator beyond the next
                // non-placeholder side node and returns it. Therefore, we must
                // consume the side node at this point. If another non-
                // placeholder node was found in the side node collection, merge
                // it with the first side node. This guarantees that the current
                // node will be an internal node, and not a leaf, by the time we
                // start merging the remaining side nodes.
                // See https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.find.
                if let Some(side_node) = side_nodes_iter
                    .find(|side_node| *side_node != Node::Placeholder.hash())
                {
                    // Skip parents until the parent of the first side node is found
                    if let Some(old_parent) = path_nodes_iter.find(|parent| {
                        parent.bytes_lo() == side_node || parent.bytes_hi() == side_node
                    }) {
                        let new_parent = if old_parent.bytes_lo() == side_node {
                            Node::create_node_from_hashes(
                                *side_node,
                                *current_node.hash(),
                                old_parent.height(),
                            )
                        } else {
                            Node::create_node_from_hashes(
                                *current_node.hash(),
                                *side_node,
                                old_parent.height(),
                            )
                        };
                        current_node = new_parent;
                        self.storage
                            .insert(current_node.hash(), &current_node.as_ref().into())?;
                    }
                }
            }
        }

        // Merge side nodes
        for (side_node, old_parent) in side_nodes_iter.zip(path_nodes_iter) {
            let new_parent = if old_parent.bytes_lo() == side_node {
                Node::create_node_from_hashes(
                    *side_node,
                    *current_node.hash(),
                    old_parent.height(),
                )
            } else {
                Node::create_node_from_hashes(
                    *current_node.hash(),
                    *side_node,
                    old_parent.height(),
                )
            };

            current_node = new_parent;
            self.storage
                .insert(current_node.hash(), &current_node.as_ref().into())?;
        }

        self.set_root_node(current_node);

        Ok(())
    }
}

impl<TableType, StorageType, StorageError> MerkleTree<TableType, StorageType>
where
    TableType: Mappable<Key = Bytes32, Value = Primitive, OwnedValue = Primitive>,
    StorageType: StorageInspect<TableType, Error = StorageError>,
{
    pub fn generate_proof(
        &self,
        key: &MerkleTreeKey,
    ) -> Result<Proof, MerkleTreeError<StorageError>> {
        let path = key.as_ref();
        let (path_nodes, side_nodes) = self.path_set(path)?;
        // Identify the closest leaf that is included in the tree to the
        // requested leaf. The closest leaf, as returned by the path set
        // corresponding to the requested leaf, will be the requested leaf
        // itself, a different leaf than requested, or a placeholder.
        //
        // If the closest leaf is the requested leaf, then the requested leaf is
        // included in the tree, and we are requesting an inclusion proof.
        // Otherwise (i.e, the closest leaf is either another leaf or a
        // placeholder), the requested leaf is not in the tree, and we are
        // requesting an exclusion proof.
        //
        let actual_leaf = &path_nodes[0];
        let proof_set = side_nodes;
        let proof = if !actual_leaf.is_placeholder() && actual_leaf.leaf_key() == path {
            // If the requested key is part of the tree, build an inclusion
            // proof.
            let inclusion_proof = InclusionProof { proof_set };
            Proof::Inclusion(inclusion_proof)
        } else {
            // If the requested key is not part of the tree, we are verifying
            // that the given key is a placeholder, and we must build an
            // exclusion proof. When building an exclusion proof, the requested
            // leaf is unset and is currently a placeholder. The path to this
            // placeholder is designated by the requested leaf's key.
            //
            // If the closest leaf is a real leaf, and not a placeholder, we can
            // build the root upwards using this leaf's key and value. If the
            // closest leaf is a placeholder, it has a leaf key and a
            // placeholder value (the zero sum). The leaf key of this
            // placeholder leaf is unknown (since placeholders do not store
            // their leaf key), and by extension, the path from the root to the
            // placeholder is also unknown.
            //
            // However, in both cases, the path defined by the requested
            // placeholder is sufficiently close: All branches stemming from the
            // point where the paths of the requested placeholder and closest
            // leaf diverge are saturated with the closest leaf's hash. In the
            // case where the closest leaf is a placeholder, this hash is simply
            // the zero sum. The hash of any placeholder under this point of
            // divergence equates to this hash.
            //
            let leaf = if actual_leaf.is_placeholder() {
                ExclusionLeaf::Placeholder
            } else {
                ExclusionLeaf::Leaf(ExclusionLeafData {
                    leaf_key: *actual_leaf.leaf_key(),
                    leaf_value: *actual_leaf.leaf_data(),
                })
            };

            let exclusion_proof = ExclusionProof { proof_set, leaf };
            Proof::Exclusion(exclusion_proof)
        };
        Ok(proof)
    }
}

#[cfg(test)]
#[allow(non_snake_case)]
mod test {
    use super::Node;
    use crate::{
        common::{
            sum,
            Bytes32,
            StorageMap,
        },
        sparse::{
            empty_sum,
            MerkleTree,
            MerkleTreeError,
            MerkleTreeKey,
            Primitive,
        },
    };
    use fuel_storage::Mappable;
    use hex;

    fn random_bytes32<R>(rng: &mut R) -> Bytes32
    where
        R: rand::Rng + ?Sized,
    {
        let mut bytes = [0u8; 32];
        rng.fill(bytes.as_mut());
        bytes
    }

    #[derive(Debug)]
    struct TestTable;

    impl Mappable for TestTable {
        type Key = Self::OwnedKey;
        type OwnedKey = Bytes32;
        type OwnedValue = Primitive;
        type Value = Self::OwnedValue;
    }

    fn key<B: AsRef<[u8]>>(data: B) -> MerkleTreeKey {
        MerkleTreeKey::new(data.as_ref())
    }

    #[test]
    fn test_empty_root() {
        let mut storage = StorageMap::<TestTable>::new();
        let tree = MerkleTree::new(&mut storage);
        let root = tree.root();
        let expected_root =
            "0000000000000000000000000000000000000000000000000000000000000000";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_1() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();

        let root = tree.root();
        let expected_root =
            "39f36a7cb4dfb1b46f03d044265df6a491dffc1034121bc1071a34ddce9bb14b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_2() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();

        let root = tree.root();
        let expected_root =
            "8d0ae412ca9ca0afcb3217af8bcd5a673e798bd6fd1dfacad17711e883f494cb";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_3() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();

        let root = tree.root();
        let expected_root =
            "52295e42d8de2505fdc0cc825ff9fead419cbcf540d8b30c7c4b9c9b94c268b7";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_5() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x03"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();

        let root = tree.root();
        let expected_root =
            "108f731f2414e33ae57e584dc26bd276db07874436b2264ca6e520c658185c6b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_10() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..10 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        let root = tree.root();
        let expected_root =
            "21ca4917e99da99a61de93deaf88c400d4c082991cb95779e444d43dd13e8849";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_100() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..100 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        let root = tree.root();
        let expected_root =
            "82bf747d455a55e2f7044a03536fc43f1f55d43b855e72c0110c986707a23e4d";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_with_repeated_inputs() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();

        let root = tree.root();
        let expected_root =
            "39f36a7cb4dfb1b46f03d044265df6a491dffc1034121bc1071a34ddce9bb14b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_overwrite_key() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x00"), b"CHANGE").unwrap();

        let root = tree.root();
        let expected_root =
            "dd97174c80e5e5aa3a31c61b05e279c1495c8a07b2a08bca5dbc9fb9774f9457";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_overwrite_key_2() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..10 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        let root_hash_before = tree.root();

        for i in 3_u32..7 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA_2").unwrap();
        }

        for i in 3_u32..7 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        let root_hash_after = tree.root();

        assert_eq!(root_hash_before, root_hash_after);
    }

    #[test]
    fn test_update_union() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..5 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 10_u32..15 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 20_u32..25 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        let root = tree.root();
        let expected_root =
            "7e6643325042cfe0fc76626c043b97062af51c7e9fc56665f12b479034bce326";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_sparse_union() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x06"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x08"), b"DATA").unwrap();

        let root = tree.root();
        let expected_root =
            "e912e97abc67707b2e6027338292943b53d01a7fbd7b244674128c7e468dd696";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_with_empty_data_does_not_change_root() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"").unwrap();

        let root = tree.root();
        let expected_root =
            "0000000000000000000000000000000000000000000000000000000000000000";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_with_empty_data_performs_delete() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x00"), b"").unwrap();

        let root = tree.root();
        let expected_root =
            "0000000000000000000000000000000000000000000000000000000000000000";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_1_delete_1() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.delete(key(b"\x00\x00\x00\x00")).unwrap();

        let root = tree.root();
        let expected_root =
            "0000000000000000000000000000000000000000000000000000000000000000";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_2_delete_1() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
        tree.delete(key(b"\x00\x00\x00\x01")).unwrap();

        let root = tree.root();
        let expected_root =
            "39f36a7cb4dfb1b46f03d044265df6a491dffc1034121bc1071a34ddce9bb14b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_10_delete_5() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..10 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 5_u32..10 {
            let key = key(i.to_be_bytes());
            tree.delete(key).unwrap();
        }

        let root = tree.root();
        let expected_root =
            "108f731f2414e33ae57e584dc26bd276db07874436b2264ca6e520c658185c6b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_delete_non_existent_key() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x03"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();
        tree.delete(key(b"\x00\x00\x04\x00")).unwrap();

        let root = tree.root();
        let expected_root =
            "108f731f2414e33ae57e584dc26bd276db07874436b2264ca6e520c658185c6b";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_interleaved_update_delete() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..10 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 5_u32..15 {
            let key = key(i.to_be_bytes());
            tree.delete(key).unwrap();
        }

        for i in 10_u32..20 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 15_u32..25 {
            let key = key(i.to_be_bytes());
            tree.delete(key).unwrap();
        }

        for i in 20_u32..30 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 25_u32..35 {
            let key = key(i.to_be_bytes());
            tree.delete(key).unwrap();
        }

        let root = tree.root();
        let expected_root =
            "7e6643325042cfe0fc76626c043b97062af51c7e9fc56665f12b479034bce326";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_update_removes_old_entries() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);
        let tenth_index = 9u32;

        for i in 0_u32..tenth_index {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }
        let size_before_tenth = tree.storage().len();
        let tenth_key = key(tenth_index.to_be_bytes());

        // Given
        tree.update(tenth_key, b"DATA").unwrap();
        let size_after_tenth = tree.storage().len();
        assert_ne!(size_after_tenth, size_before_tenth);

        // When
        tree.update(tenth_key, b"ANOTHER_DATA").unwrap();

        // Then
        assert_eq!(tree.storage().len(), size_after_tenth);
    }

    #[test]
    fn test_update_with_the_same_value_does_not_remove_old_entries() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);
        let tenth_index = 9u32;

        for i in 0_u32..tenth_index {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }
        let size_before_tenth = tree.storage().len();
        let tenth_key = key(tenth_index.to_be_bytes());

        // Given
        tree.update(tenth_key, b"DATA").unwrap();
        let size_after_tenth = tree.storage().len();
        assert_ne!(size_after_tenth, size_before_tenth);

        // When
        tree.update(tenth_key, b"DATA").unwrap();

        // Then
        assert_eq!(tree.storage().len(), size_after_tenth);
    }

    #[test]
    fn test_delete_removes_path_entries() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);
        let tenth_index = 9u32;

        for i in 0_u32..tenth_index {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }
        let size_before_tenth = tree.storage().len();
        let tenth_key = key(tenth_index.to_be_bytes());

        // Given
        tree.update(tenth_key, b"DATA").unwrap();
        let size_after_tenth = tree.storage().len();
        assert_ne!(size_after_tenth, size_before_tenth);

        // When
        tree.delete(tenth_key).unwrap();

        // Then
        assert_eq!(tree.storage().len(), size_before_tenth);
    }

    #[test]
    fn test_delete_sparse_union() {
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        for i in 0_u32..10 {
            let key = key(i.to_be_bytes());
            tree.update(key, b"DATA").unwrap();
        }

        for i in 0_u32..5 {
            let key = key((i * 2 + 1).to_be_bytes());
            tree.delete(key).unwrap();
        }

        let root = tree.root();
        let expected_root =
            "e912e97abc67707b2e6027338292943b53d01a7fbd7b244674128c7e468dd696";
        assert_eq!(hex::encode(root), expected_root);
    }

    #[test]
    fn test_override_hash_key() {
        use fuel_storage::StorageInspect;
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        let leaf_1_key = key(b"\x00\x00\x00\x00");
        let leaf_1_data = b"DATA_1";
        let leaf_1 = Node::create_leaf(&leaf_1_key.0, leaf_1_data);

        let leaf_2_key = MerkleTreeKey::new_without_hash(*leaf_1.hash());
        let leaf_2_data = b"DATA_2";
        let leaf_2 = Node::create_leaf(&leaf_2_key.0, leaf_2_data);

        tree.update(leaf_2_key, leaf_2_data).unwrap();
        tree.update(leaf_1_key, leaf_1_data).unwrap();
        assert_eq!(
            tree.storage
                .get(leaf_2.hash())
                .unwrap()
                .unwrap()
                .into_owned(),
            leaf_2.as_ref().into()
        );
        assert_eq!(
            tree.storage
                .get(leaf_1.hash())
                .unwrap()
                .unwrap()
                .into_owned(),
            leaf_1.as_ref().into()
        );
    }

    #[test]
    fn test_load_returns_a_valid_tree() {
        // Instantiate a new key-value storage backing and populate it using a sparse
        // Merkle tree. The root of the Merkle tree is the key that maps to the buffer
        // of the root node in the storage. When loading a Merkle tree from storage, we
        // need a reference to the storage object, as well as the root that allows us to
        // look up the buffer of the root node. We will later use this storage backing
        // and root to load a Merkle tree.
        let (mut storage_to_load, root_to_load) = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x03"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();
            let root = tree.root();
            (storage, root)
        };

        // Generate an expected root for this test by using both the set of `update`
        // data used when generating the loadable storage above and an additional set of
        // `update` data.
        let expected_root = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x03"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x05"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x06"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x07"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x08"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x09"), b"DATA").unwrap();
            tree.root()
        };

        let root = {
            // Create a Merkle tree by loading the generated storage and root.
            let mut tree = MerkleTree::load(&mut storage_to_load, &root_to_load).unwrap();
            // Build up the loaded tree using the additional set of `update` data so its
            // root matches the expected root. This verifies that the loaded tree has
            // successfully wrapped the given storage backing and assumed the correct
            // state so that future updates can be made seamlessly.
            tree.update(key(b"\x00\x00\x00\x05"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x06"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x07"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x08"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x09"), b"DATA").unwrap();
            tree.root()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn test_load_returns_an_empty_tree_for_empty_sum_root() {
        let mut storage = StorageMap::<TestTable>::new();
        let tree = MerkleTree::load(&mut storage, empty_sum()).unwrap();
        let root = tree.root();

        assert_eq!(root, *empty_sum());
    }

    #[test]
    fn test_load_returns_a_load_error_if_the_storage_is_not_valid_for_the_root() {
        let mut storage = StorageMap::<TestTable>::new();

        {
            let mut tree = MerkleTree::new(&mut storage);
            tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x03"), b"DATA").unwrap();
            tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();
        }

        let root = &sum(b"\xff\xff\xff\xff");
        let err = MerkleTree::load(&mut storage, root)
            .expect_err("Expected load() to return Error; got Ok");
        assert!(matches!(err, MerkleTreeError::LoadError(_)));
    }

    #[test]
    fn test_load_returns_a_deserialize_error_if_the_storage_is_corrupted() {
        use fuel_storage::StorageMutate;

        let mut storage = StorageMap::<TestTable>::new();

        let mut tree = MerkleTree::new(&mut storage);
        tree.update(key(b"\x00\x00\x00\x00"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x01"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x02"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x03"), b"DATA").unwrap();
        tree.update(key(b"\x00\x00\x00\x04"), b"DATA").unwrap();
        let root = tree.root();

        // Overwrite the root key-value with an invalid primitive to create a
        // DeserializeError.
        let primitive = (0xff, 0xff, [0xff; 32], [0xff; 32]);
        storage.insert(&root, &primitive).unwrap();

        let err = MerkleTree::load(&mut storage, &root)
            .expect_err("Expected load() to return Error; got Ok");
        assert!(matches!(err, MerkleTreeError::DeserializeError(_)));
    }

    #[test]
    fn test_from_set_yields_expected_root() {
        let rng = &mut rand::thread_rng();
        let gen = || {
            Some((
                MerkleTreeKey::new_without_hash(random_bytes32(rng)),
                random_bytes32(rng),
            ))
        };
        let data = std::iter::from_fn(gen).take(1_000).collect::<Vec<_>>();

        let expected_root = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            let input = data.clone();
            for (key, value) in input.into_iter() {
                tree.update(key, &value).unwrap();
            }
            tree.root()
        };

        let root = {
            let mut storage = StorageMap::<TestTable>::new();
            let tree = MerkleTree::from_set(&mut storage, data.into_iter()).unwrap();
            tree.root()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn test_from_empty_set_yields_expected_root() {
        let rng = &mut rand::thread_rng();
        let gen = || {
            Some((
                MerkleTreeKey::new_without_hash(random_bytes32(rng)),
                random_bytes32(rng),
            ))
        };
        let data = std::iter::from_fn(gen).take(0).collect::<Vec<_>>();

        let expected_root = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            let input = data.clone();
            for (key, value) in input.into_iter() {
                tree.update(key, &value).unwrap();
            }
            tree.root()
        };

        let root = {
            let mut storage = StorageMap::<TestTable>::new();
            let tree = MerkleTree::from_set(&mut storage, data.into_iter()).unwrap();
            tree.root()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn test_from_unit_set_yields_expected_root() {
        let rng = &mut rand::thread_rng();
        let gen = || {
            Some((
                MerkleTreeKey::new_without_hash(random_bytes32(rng)),
                random_bytes32(rng),
            ))
        };
        let data = std::iter::from_fn(gen).take(1).collect::<Vec<_>>();

        let expected_root = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            let input = data.clone();
            for (key, value) in input.into_iter() {
                tree.update(key, &value).unwrap();
            }
            tree.root()
        };

        let root = {
            let mut storage = StorageMap::<TestTable>::new();
            let tree = MerkleTree::from_set(&mut storage, data.into_iter()).unwrap();
            tree.root()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn test_from_set_with_duplicate_keys_yields_expected_root() {
        let rng = &mut rand::thread_rng();
        let keys = [
            key(b"\x00\x00\x00\x00"),
            key(b"\x00\x00\x00\x01"),
            key(b"\x00\x00\x00\x02"),
        ];
        let data = [
            (keys[0], random_bytes32(rng)),
            (keys[1], random_bytes32(rng)),
            (keys[2], random_bytes32(rng)),
            (keys[0], random_bytes32(rng)),
            (keys[1], random_bytes32(rng)),
            (keys[2], random_bytes32(rng)),
        ];

        let expected_root = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            let input = data;
            for (key, value) in input.into_iter() {
                tree.update(key, &value).unwrap();
            }
            tree.root()
        };

        let root = {
            let mut storage = StorageMap::<TestTable>::new();
            let tree = MerkleTree::from_set(&mut storage, data.into_iter()).unwrap();
            tree.root()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn test_from_set_with_empty_data_yields_expected_root() {
        let rng = &mut rand::thread_rng();
        let keys = [
            key(b"\x00\x00\x00\x00"),
            key(b"\x00\x00\x00\x01"),
            key(b"\x00\x00\x00\x02"),
        ];
        let data = [
            (keys[0], random_bytes32(rng).to_vec()),
            (keys[1], random_bytes32(rng).to_vec()),
            (keys[2], random_bytes32(rng).to_vec()),
            (keys[0], b"".to_vec()),
            (keys[1], b"".to_vec()),
            (keys[2], b"".to_vec()),
        ];

        let expected_root = {
            let mut storage = StorageMap::<TestTable>::new();
            let mut tree = MerkleTree::new(&mut storage);
            let input = data.clone();
            for (key, value) in input.into_iter() {
                tree.update(key, &value).unwrap();
            }
            tree.root()
        };

        let root = {
            let mut storage = StorageMap::<TestTable>::new();
            let tree = MerkleTree::from_set(&mut storage, data.into_iter()).unwrap();
            tree.root()
        };

        assert_eq!(root, expected_root);
    }

    #[test]
    fn merkle_tree__generate_proof__returns_proof_with_proof_set_for_given_key() {
        // Given
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32];
        let v0 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k0), &v0)
            .expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let v1 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k1), &v1)
            .expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let v2 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k2), &v2)
            .expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let v3 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k3), &v3)
            .expect("Expected successful update");

        let l0 = Node::create_leaf(&k0, v0);
        let l1 = Node::create_leaf(&k1, v1);
        let l2 = Node::create_leaf(&k2, v2);
        let l3 = Node::create_leaf(&k3, v3);
        let n0 = Node::create_node(&l1, &l3, 252);
        let n1 = Node::create_node(&n0, &Node::create_placeholder(), 253);
        let n2 = Node::create_node(&n1, &l2, 254);
        let n3 = Node::create_node(&l0, &n2, 255);

        {
            // When
            let proof = tree.generate_proof(&k0.into()).expect("Expected proof");
            let expected_proof_set = [*n2.hash(), *Node::create_placeholder().hash()];

            // Then
            assert_eq!(*proof.proof_set(), expected_proof_set);
        }

        {
            // When
            let proof = tree.generate_proof(&k1.into()).expect("Expected proof");
            let expected_proof_set = [
                *l3.hash(),
                *Node::create_placeholder().hash(),
                *l2.hash(),
                *l0.hash(),
                *Node::create_placeholder().hash(),
            ];

            // Then
            assert_eq!(*proof.proof_set(), expected_proof_set);
        }

        {
            // When
            let proof = tree.generate_proof(&k2.into()).expect("Expected proof");
            let expected_proof_set =
                [*n1.hash(), *l0.hash(), *Node::create_placeholder().hash()];

            // Then
            assert_eq!(*proof.proof_set(), expected_proof_set);
        }

        {
            // When
            let proof = tree.generate_proof(&k3.into()).expect("Expected proof");
            let expected_proof_set = [
                *l1.hash(),
                *Node::create_placeholder().hash(),
                *l2.hash(),
                *l0.hash(),
                *Node::create_placeholder().hash(),
            ];

            // Then
            assert_eq!(*proof.proof_set(), expected_proof_set);
        }

        {
            // Test that supplying an arbitrary leaf "outside" the range of
            // leaves produces a valid proof set

            // When
            let key = [255u8; 32];
            let proof = tree.generate_proof(&key.into()).expect("Expected proof");
            let expected_proof_set = [*n3.hash()];

            // Then
            assert_eq!(*proof.proof_set(), expected_proof_set);
        }
    }

    #[test]
    fn merkle_tree__generate_proof__returns_inclusion_proof_for_included_key() {
        // Given
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32];
        let v0 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k0), &v0)
            .expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let v1 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k1), &v1)
            .expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let v2 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k2), &v2)
            .expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let v3 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k3), &v3)
            .expect("Expected successful update");

        // When
        let proof = tree.generate_proof(&k1.into()).expect("Expected proof");

        // Then
        assert!(proof.is_inclusion());
    }

    #[test]
    fn merkle_tree__generate_proof__returns_exclusion_proof_for_excluded_key() {
        // Given
        let mut storage = StorageMap::<TestTable>::new();
        let mut tree = MerkleTree::new(&mut storage);

        // 256:           N4
        //               /  \
        // 255:         N3   \
        //             /  \   \
        // 254:       /   N2   \
        //           /   /  \   \
        // 253:     /   N1   \   \
        //         /   /  \   \   \
        // 252:   /   N0   \   \   \
        // ...   /   /  \   \   \   \
        //   0: L0  L1  L3  P1  L2  P0
        //      K0  K1  K3      K2

        let k0 = [0u8; 32];
        let v0 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k0), &v0)
            .expect("Expected successful update");

        let mut k1 = [0u8; 32];
        k1[0] = 0b01000000;
        let v1 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k1), &v1)
            .expect("Expected successful update");

        let mut k2 = [0u8; 32];
        k2[0] = 0b01100000;
        let v2 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k2), &v2)
            .expect("Expected successful update");

        let mut k3 = [0u8; 32];
        k3[0] = 0b01001000;
        let v3 = sum(b"DATA");
        tree.update(MerkleTreeKey::new_without_hash(k3), &v3)
            .expect("Expected successful update");

        // When
        let key = [255u8; 32];
        let proof = tree.generate_proof(&key.into()).expect("Expected proof");

        // Then
        assert!(proof.is_exclusion());
    }
}

/home/marten/fuel/fuel-vm/fuel-merkle/src/sparse/hash.rs

Source
use crate::common::{
    sum_iter,
    Bytes32,
    Prefix,
};

pub const fn zero_sum() -> &'static Bytes32 {
    const ZERO_SUM: Bytes32 = [0; 32];

    &ZERO_SUM
}

pub fn calculate_hash(
    prefix: &Prefix,
    bytes_lo: &Bytes32,
    bytes_hi: &Bytes32,
) -> Bytes32 {
    let input = [prefix.as_ref(), bytes_lo.as_ref(), bytes_hi.as_ref()];
    sum_iter(input)
}

pub fn calculate_leaf_hash(leaf_key: &Bytes32, leaf_value: &Bytes32) -> Bytes32 {
    calculate_hash(&Prefix::Leaf, leaf_key, leaf_value)
}

pub fn calculate_node_hash(left_child: &Bytes32, right_child: &Bytes32) -> Bytes32 {
    calculate_hash(&Prefix::Node, left_child, right_child)
}

/home/marten/fuel/fuel-vm/fuel-types/src/canonical.rs

Source
//! Canonical serialization and deserialization of Fuel types.
//!
//! This module provides the `Serialize` and `Deserialize` traits, which
//! allow for automatic serialization and deserialization of Fuel types.

#![allow(unsafe_code)]

#[cfg(feature = "alloc")]
use alloc::vec::Vec;
use core::fmt;

use core::mem::MaybeUninit;
pub use fuel_derive::{
    Deserialize,
    Serialize,
};

/// Error when serializing or deserializing.
#[derive(Debug, Eq, PartialEq)]
#[non_exhaustive]
pub enum Error {
    /// The buffer is to short for writing or reading.
    BufferIsTooShort,
    /// Got unknown enum's discriminant.
    UnknownDiscriminant,
    /// Struct prefix (set with `#[canonical(prefix = ...)]`) was invalid.
    InvalidPrefix,
    /// Allocation too large to be correct.
    AllocationLimit,
    /// Unknown error.
    Unknown(&'static str),
}

impl Error {
    pub(crate) fn as_str(&self) -> &'static str {
        match self {
            Error::BufferIsTooShort => "buffer is too short",
            Error::UnknownDiscriminant => "unknown discriminant",
            Error::InvalidPrefix => {
                "prefix set with #[canonical(prefix = ...)] was invalid"
            }
            Error::AllocationLimit => "allocation too large",
            Error::Unknown(str) => str,
        }
    }
}

impl fmt::Display for Error {
    /// Shows a human-readable description of the `Error`.
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.write_str(self.as_str())
    }
}

/// Allows writing of data.
pub trait Output {
    /// Write bytes to the output buffer.
    fn write(&mut self, bytes: &[u8]) -> Result<(), Error>;

    /// Write a single byte to the output buffer.
    fn push_byte(&mut self, byte: u8) -> Result<(), Error> {
        self.write(&[byte])
    }
}

/// Allows serialize the type into the `Output`.
/// https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/tx_format.md#transaction
pub trait Serialize {
    /// !INTERNAL USAGE ONLY!
    /// Array of bytes that are now aligned by themselves.
    #[doc(hidden)]
    const UNALIGNED_BYTES: bool = false;

    /// Size of the static part of the serialized object, in bytes.
    /// Saturates to usize::MAX on overflow.
    fn size_static(&self) -> usize;

    /// Size of the dynamic part, in bytes.
    /// Saturates to usize::MAX on overflow.
    fn size_dynamic(&self) -> usize;

    /// Total size of the serialized object, in bytes.
    /// Saturates to usize::MAX on overflow.
    fn size(&self) -> usize {
        self.size_static().saturating_add(self.size_dynamic())
    }

    /// Encodes `Self` into the `buffer`.
    ///
    /// It is better to not implement this function directly, instead implement
    /// `encode_static` and `encode_dynamic`.
    fn encode<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        self.encode_static(buffer)?;
        self.encode_dynamic(buffer)
    }

    /// Encodes staticly-sized part of `Self`.
    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error>;

    /// Encodes dynamically-sized part of `Self`.
    /// The default implementation does nothing. Dynamically-sized contains should
    /// override this.
    fn encode_dynamic<O: Output + ?Sized>(&self, _buffer: &mut O) -> Result<(), Error> {
        Ok(())
    }

    /// Encodes `Self` into bytes vector. Required known size.
    #[cfg(feature = "alloc")]
    fn to_bytes(&self) -> Vec<u8> {
        let mut vec = Vec::with_capacity(self.size());
        self.encode(&mut vec).expect("Unable to encode self");
        vec
    }
}

/// Allows reading of data into a slice.
pub trait Input {
    /// Returns the remaining length of the input data.
    fn remaining(&mut self) -> usize;

    /// Peek the exact number of bytes required to fill the given buffer.
    fn peek(&self, buf: &mut [u8]) -> Result<(), Error>;

    /// Read the exact number of bytes required to fill the given buffer.
    fn read(&mut self, buf: &mut [u8]) -> Result<(), Error>;

    /// Peek a single byte from the input.
    fn peek_byte(&mut self) -> Result<u8, Error> {
        let mut buf = [0u8];
        self.peek(&mut buf[..])?;
        Ok(buf[0])
    }

    /// Read a single byte from the input.
    fn read_byte(&mut self) -> Result<u8, Error> {
        let mut buf = [0u8];
        self.read(&mut buf[..])?;
        Ok(buf[0])
    }

    /// Skips next `n` bytes.
    fn skip(&mut self, n: usize) -> Result<(), Error>;
}

/// Allows deserialize the type from the `Input`.
/// https://github.com/FuelLabs/fuel-specs/blob/master/specs/protocol/tx_format.md#transaction
pub trait Deserialize: Sized {
    /// !INTERNAL USAGE ONLY!
    /// Array of bytes that are now aligned by themselves.
    #[doc(hidden)]
    const UNALIGNED_BYTES: bool = false;

    /// Decodes `Self` from the `buffer`.
    ///
    /// It is better to not implement this function directly, instead implement
    /// `decode_static` and `decode_dynamic`.
    fn decode<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error> {
        let mut object = Self::decode_static(buffer)?;
        object.decode_dynamic(buffer)?;
        Ok(object)
    }

    /// Decodes static part of `Self` from the `buffer`.
    fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error>;

    /// Decodes dynamic part of the information from the `buffer` to fill `Self`.
    /// The default implementation does nothing. Dynamically-sized contains should
    /// override this.
    fn decode_dynamic<I: Input + ?Sized>(
        &mut self,
        _buffer: &mut I,
    ) -> Result<(), Error> {
        Ok(())
    }

    /// Helper method for deserializing `Self` from bytes.
    fn from_bytes(mut buffer: &[u8]) -> Result<Self, Error> {
        Self::decode(&mut buffer)
    }
}

/// The data of each field should be aligned to 64 bits.
pub const ALIGN: usize = 8;

/// The number of padding bytes required to align the given length correctly.
#[allow(clippy::arithmetic_side_effects)] // Safety: (a % b) < b
const fn alignment_bytes(len: usize) -> usize {
    let modulo = len % ALIGN;
    if modulo == 0 {
        0
    } else {
        ALIGN - modulo
    }
}

/// Size after alignment. Saturates on overflow.
pub const fn aligned_size(len: usize) -> usize {
    len.saturating_add(alignment_bytes(len))
}

macro_rules! impl_for_primitives {
    ($t:ident, $unpadded:literal) => {
        impl Serialize for $t {
            const UNALIGNED_BYTES: bool = $unpadded;

            #[inline(always)]
            fn size_static(&self) -> usize {
                aligned_size(::core::mem::size_of::<$t>())
            }

            #[inline(always)]
            fn size_dynamic(&self) -> usize {
                0
            }

            #[inline(always)]
            fn encode_static<O: Output + ?Sized>(
                &self,
                buffer: &mut O,
            ) -> Result<(), Error> {
                // Primitive types are zero-padded on left side to a 8-byte boundary.
                // The resulting value is always well-aligned.
                let bytes = <$t>::to_be_bytes(*self);
                for _ in 0..alignment_bytes(bytes.len()) {
                    // Zero-pad
                    buffer.push_byte(0)?;
                }
                buffer.write(bytes.as_ref())?;
                Ok(())
            }
        }

        impl Deserialize for $t {
            const UNALIGNED_BYTES: bool = $unpadded;

            fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error> {
                let mut asset = [0u8; ::core::mem::size_of::<$t>()];
                buffer.skip(alignment_bytes(asset.len()))?; // Skip zero-padding
                buffer.read(asset.as_mut())?;
                Ok(<$t>::from_be_bytes(asset))
            }
        }
    };
}

impl_for_primitives!(u8, true);
impl_for_primitives!(u16, false);
impl_for_primitives!(u32, false);
impl_for_primitives!(usize, false);
impl_for_primitives!(u64, false);
impl_for_primitives!(u128, false);

// Empty tuple `()`, i.e. the unit type takes up no space.
impl Serialize for () {
    fn size_static(&self) -> usize {
        0
    }

    #[inline(always)]
    fn size_dynamic(&self) -> usize {
        0
    }

    #[inline(always)]
    fn encode_static<O: Output + ?Sized>(&self, _buffer: &mut O) -> Result<(), Error> {
        Ok(())
    }
}

impl Deserialize for () {
    fn decode_static<I: Input + ?Sized>(_buffer: &mut I) -> Result<Self, Error> {
        Ok(())
    }
}

/// To protect against malicious large inputs, vector size is limited when decoding.
pub const VEC_DECODE_LIMIT: usize = 100 * (1 << 20); // 100 MiB

#[cfg(feature = "alloc")]
impl<T: Serialize> Serialize for Vec<T> {
    fn size_static(&self) -> usize {
        8
    }

    #[inline(always)]
    fn size_dynamic(&self) -> usize {
        if T::UNALIGNED_BYTES {
            aligned_size(self.len())
        } else {
            aligned_size(
                self.iter()
                    .map(|e| e.size())
                    .reduce(usize::saturating_add)
                    .unwrap_or_default(),
            )
        }
    }

    #[inline(always)]
    // Encode only the size of the vector. Elements will be encoded in the
    // `encode_dynamic` method.
    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        if self.len() > VEC_DECODE_LIMIT {
            return Err(Error::AllocationLimit)
        }
        let len: u64 = self.len().try_into().expect("msg.len() > u64::MAX");
        len.encode(buffer)
    }

    fn encode_dynamic<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        // Bytes - Vec<u8> it a separate case without padding for each element.
        // It should padded at the end if is not % ALIGN
        if T::UNALIGNED_BYTES {
            // SAFETY: `UNALIGNED_BYTES` only set for `u8`.
            let bytes = unsafe { ::core::mem::transmute::<&Vec<T>, &Vec<u8>>(self) };
            buffer.write(bytes.as_slice())?;
            for _ in 0..alignment_bytes(self.len()) {
                buffer.push_byte(0)?;
            }
        } else {
            for e in self.iter() {
                e.encode(buffer)?;
            }
        }
        Ok(())
    }
}

#[cfg(feature = "alloc")]
impl<T: Deserialize> Deserialize for Vec<T> {
    // Decode only the capacity of the vector. Elements will be decoded in the
    // `decode_dynamic` method. The capacity is needed for iteration there.
    fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error> {
        let cap = u64::decode(buffer)?;
        let cap: usize = cap.try_into().map_err(|_| Error::AllocationLimit)?;
        if cap > VEC_DECODE_LIMIT {
            return Err(Error::AllocationLimit)
        }
        Ok(Vec::with_capacity(cap))
    }

    fn decode_dynamic<I: Input + ?Sized>(&mut self, buffer: &mut I) -> Result<(), Error> {
        for _ in 0..self.capacity() {
            // Bytes - Vec<u8> it a separate case without unpadding for each element.
            // It should unpadded at the end if is not % ALIGN
            if T::UNALIGNED_BYTES {
                let byte = buffer.read_byte()?;
                // SAFETY: `UNALIGNED_BYTES` implemented set for `u8`.
                let _self =
                    unsafe { ::core::mem::transmute::<&mut Vec<T>, &mut Vec<u8>>(self) };
                _self.push(byte);
            } else {
                self.push(T::decode(buffer)?);
            }
        }

        if T::UNALIGNED_BYTES {
            buffer.skip(alignment_bytes(self.capacity()))?;
        }

        Ok(())
    }
}

impl<const N: usize, T: Serialize> Serialize for [T; N] {
    fn size_static(&self) -> usize {
        if T::UNALIGNED_BYTES {
            aligned_size(N)
        } else {
            aligned_size(
                self.iter()
                    .map(|e| e.size_static())
                    .reduce(usize::saturating_add)
                    .unwrap_or_default(),
            )
        }
    }

    #[inline(always)]
    fn size_dynamic(&self) -> usize {
        if T::UNALIGNED_BYTES {
            0
        } else {
            aligned_size(
                self.iter()
                    .map(|e| e.size_dynamic())
                    .reduce(usize::saturating_add)
                    .unwrap_or_default(),
            )
        }
    }

    #[inline(always)]
    fn encode_static<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        // Bytes - [u8; N] it a separate case without padding for each element.
        // It should padded at the end if is not % ALIGN
        if T::UNALIGNED_BYTES {
            // SAFETY: `Type::U8` implemented only for `u8`.
            let bytes = unsafe { ::core::mem::transmute::<&[T; N], &[u8; N]>(self) };
            buffer.write(bytes.as_slice())?;
            for _ in 0..alignment_bytes(N) {
                buffer.push_byte(0)?;
            }
        } else {
            for e in self.iter() {
                e.encode_static(buffer)?;
            }
        }
        Ok(())
    }

    fn encode_dynamic<O: Output + ?Sized>(&self, buffer: &mut O) -> Result<(), Error> {
        for e in self.iter() {
            e.encode_dynamic(buffer)?;
        }

        Ok(())
    }
}

impl<const N: usize, T: Deserialize> Deserialize for [T; N] {
    fn decode_static<I: Input + ?Sized>(buffer: &mut I) -> Result<Self, Error> {
        if T::UNALIGNED_BYTES {
            let mut bytes: [u8; N] = [0; N];
            buffer.read(bytes.as_mut())?;
            buffer.skip(alignment_bytes(N))?;
            let ref_typed: &[T; N] = unsafe { core::mem::transmute(&bytes) };
            let typed: [T; N] = unsafe { core::ptr::read(ref_typed) };
            Ok(typed)
        } else {
            // Spec doesn't say how to deserialize arrays with unaligned
            // primitives(as `u16`, `u32`, `usize`), so unpad them.
            // SAFETY: `uninit`` is an array of `MaybUninit`, which do not require
            // initialization
            let mut uninit: [MaybeUninit<T>; N] =
                unsafe { MaybeUninit::uninit().assume_init() };
            // The following line coerces the pointer to the array to a pointer
            // to the first array element which is equivalent.
            for i in 0..N {
                match T::decode_static(buffer) {
                    Err(e) => {
                        for item in uninit.iter_mut().take(i) {
                            // SAFETY: all elements up to index i (excluded have been
                            // initialised)
                            unsafe {
                                item.assume_init_drop();
                            }
                        }
                        return Err(e)
                    }
                    Ok(decoded) => {
                        // SAFETY: `uninit[i]` is a MaybeUninit which can be
                        // safely overwritten.
                        uninit[i].write(decoded);

                        // SAFETY: Point to the next element after every iteration.
                        //     We do this N times therefore this is safe.
                    }
                }
            }

            // SAFETY: All array elements have been initialized above.
            let init = uninit.map(|v| unsafe { v.assume_init() });
            Ok(init)
        }
    }

    fn decode_dynamic<I: Input + ?Sized>(&mut self, buffer: &mut I) -> Result<(), Error> {
        for e in self.iter_mut() {
            e.decode_dynamic(buffer)?;
        }
        Ok(())
    }
}

#[cfg(feature = "alloc")]
impl Output for Vec<u8> {
    fn write(&mut self, bytes: &[u8]) -> Result<(), Error> {
        self.extend_from_slice(bytes);
        Ok(())
    }
}

impl<'a> Output for &'a mut [u8] {
    fn write(&mut self, from: &[u8]) -> Result<(), Error> {
        if from.len() > self.len() {
            return Err(Error::BufferIsTooShort)
        }
        let len = from.len();
        self[..len].copy_from_slice(from);
        // We need to reduce the inner slice by `len`, because we already filled them.
        let reduced = &mut self[len..];

        // Compiler is not clever enough to allow it.
        // https://stackoverflow.com/questions/25730586/how-can-i-create-my-own-data-structure-with-an-iterator-that-returns-mutable-ref
        *self = unsafe { &mut *(reduced as *mut [u8]) };
        Ok(())
    }
}

impl<'a> Input for &'a [u8] {
    fn remaining(&mut self) -> usize {
        self.len()
    }

    fn peek(&self, into: &mut [u8]) -> Result<(), Error> {
        if into.len() > self.len() {
            return Err(Error::BufferIsTooShort)
        }

        let len = into.len();
        into.copy_from_slice(&self[..len]);
        Ok(())
    }

    fn read(&mut self, into: &mut [u8]) -> Result<(), Error> {
        if into.len() > self.len() {
            return Err(Error::BufferIsTooShort)
        }

        let len = into.len();
        into.copy_from_slice(&self[..len]);
        *self = &self[len..];
        Ok(())
    }

    fn skip(&mut self, n: usize) -> Result<(), Error> {
        if n > self.len() {
            return Err(Error::BufferIsTooShort)
        }

        *self = &self[n..];
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn validate<T: Serialize + Deserialize + Eq + core::fmt::Debug>(t: T) {
        let bytes = t.to_bytes();
        let t2 = T::from_bytes(&bytes).expect("Roundtrip failed");
        assert_eq!(t, t2);
        assert_eq!(t.to_bytes(), t2.to_bytes());

        let mut vec = Vec::new();
        t.encode_static(&mut vec).expect("Encode failed");
        assert_eq!(vec.len(), t.size_static());
    }

    fn validate_enum<T: Serialize + Deserialize + Eq + fmt::Debug>(t: T) {
        let bytes = t.to_bytes();
        let t2 = T::from_bytes(&bytes).expect("Roundtrip failed");
        assert_eq!(t, t2);
        assert_eq!(t.to_bytes(), t2.to_bytes());

        let mut vec = Vec::new();
        t.encode_static(&mut vec).expect("Encode failed");
        assert_eq!(vec.len(), t.size_static());
        t.encode_dynamic(&mut vec).expect("Encode failed");
        assert_eq!(vec.len(), t.size());

        let mut vec2 = Vec::new();
        t.encode_dynamic(&mut vec2).expect("Encode failed");
        assert_eq!(vec2.len(), t.size_dynamic());
    }

    #[test]
    fn test_canonical_encode_decode() {
        validate(());
        validate(123u8);
        validate(u8::MAX);
        validate(123u16);
        validate(u16::MAX);
        validate(123u32);
        validate(u32::MAX);
        validate(123u64);
        validate(u64::MAX);
        validate(123u128);
        validate(u128::MAX);
        validate(Vec::<u8>::new());
        validate(Vec::<u16>::new());
        validate(Vec::<u32>::new());
        validate(Vec::<u64>::new());
        validate(Vec::<u128>::new());
        validate(vec![1u8]);
        validate(vec![1u16]);
        validate(vec![1u32]);
        validate(vec![1u64]);
        validate(vec![1u128]);
        validate(vec![1u8, 2u8]);
        validate(vec![1u16, 2u16]);
        validate(vec![1u32, 2u32]);
        validate(vec![1u64, 2u64]);
        validate(vec![1u128, 2u128]);

        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
        struct TestStruct1 {
            a: u8,
            b: u16,
        }

        let t = TestStruct1 { a: 123, b: 456 };
        assert_eq!(t.size_static(), 16);
        assert_eq!(t.size(), 16);
        validate(t);

        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
        struct TestStruct2 {
            a: u8,
            v: Vec<u8>,
            b: u16,
            arr0: [u8; 0],
            arr1: [u8; 2],
            arr2: [u16; 3],
            arr3: [u64; 4],
        }

        validate(TestStruct2 {
            a: 123,
            v: vec![1, 2, 3],
            b: 456,
            arr0: [],
            arr1: [1, 2],
            arr2: [1, 2, u16::MAX],
            arr3: [0, 3, 1111, u64::MAX],
        });

        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
        #[repr(transparent)]
        struct TestStruct3([u8; 64]);

        let t = TestStruct3([1; 64]);
        assert_eq!(t.size_static(), 64);
        assert_eq!(t.size(), 64);
        validate(t);

        #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
        #[canonical(prefix = 1u64)]
        struct Prefixed1 {
            a: [u8; 3],
            b: Vec<u8>,
        }
        validate(Prefixed1 {
            a: [1, 2, 3],
            b: vec![4, 5, 6],
        });

        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
        #[repr(u8)]
        enum TestEnum1 {
            A,
            B,
            C = 0x13,
            D,
        }

        validate(TestEnum1::A);
        validate(TestEnum1::B);
        validate(TestEnum1::C);
        validate(TestEnum1::D);

        #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
        enum TestEnum2 {
            A(u8),
            B([u8; 3]),
            C(Vec<u8>),
        }

        validate_enum(TestEnum2::A(2));
        validate_enum(TestEnum2::B([1, 2, 3]));
        validate_enum(TestEnum2::C(vec![1, 2, 3]));

        #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
        #[canonical(prefix = 2u64)]
        struct Prefixed2(u16);
        validate(Prefixed2(u16::MAX));

        assert_eq!(
            &Prefixed1 {
                a: [1, 2, 3],
                b: vec![4, 5]
            }
            .to_bytes()[..8],
            &[0u8, 0, 0, 0, 0, 0, 0, 1]
        );
        assert_eq!(
            Prefixed2(u16::MAX).to_bytes(),
            [0u8, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0xff, 0xff]
        );
    }
}

/home/marten/fuel/fuel-vm/fuel-types/src/bytes.rs

Source
use crate::Word;

/// Size of a word, in bytes
pub const WORD_SIZE: usize = core::mem::size_of::<Word>();

/// Return the word-padded length of the buffer.
/// Returns None if the length is too large to be represented as usize.
pub const fn padded_len(bytes: &[u8]) -> Option<usize> {
    padded_len_usize(bytes.len())
}

/// Return the word-padded length of an arbitrary length.
/// Returns None if the length is too large to be represented as usize.
#[allow(clippy::arithmetic_side_effects)] // Safety: (a % b) < b
pub const fn padded_len_usize(len: usize) -> Option<usize> {
    let modulo = len % WORD_SIZE;
    if modulo == 0 {
        Some(len)
    } else {
        let padding = WORD_SIZE - modulo;
        len.checked_add(padding)
    }
}

/// Return the word-padded length of an arbitrary length.
/// Returns None if the length is too large to be represented as `Word`.
#[allow(clippy::arithmetic_side_effects)] // Safety: (a % b) < b
pub const fn padded_len_word(len: Word) -> Option<Word> {
    let modulo = len % WORD_SIZE as Word;
    if modulo == 0 {
        Some(len)
    } else {
        let padding = WORD_SIZE as Word - modulo;
        len.checked_add(padding)
    }
}

#[cfg(feature = "unsafe")]
#[allow(unsafe_code)]
/// Add a conversion from arbitrary slices into arrays
///
/// # Safety
///
/// This function will not panic if the length of the slice is smaller than `N`. Instead,
/// it will cause undefined behavior and read random disowned bytes.
pub unsafe fn from_slice_unchecked<const N: usize>(buf: &[u8]) -> [u8; N] {
    let ptr = buf.as_ptr() as *const [u8; N];

    // Static assertions are not applicable to runtime length check (e.g. slices).
    // This is safe if the size of `bytes` is consistent to `N`
    *ptr
}

#[test]
#[allow(clippy::erasing_op)]
#[allow(clippy::identity_op)]
fn padded_len_returns_multiple_of_word_len() {
    assert_eq!(Some(WORD_SIZE * 0), padded_len(&[]));
    assert_eq!(Some(WORD_SIZE * 1), padded_len(&[0]));
    assert_eq!(Some(WORD_SIZE * 1), padded_len(&[0; WORD_SIZE]));
    assert_eq!(Some(WORD_SIZE * 2), padded_len(&[0; WORD_SIZE + 1]));
    assert_eq!(Some(WORD_SIZE * 2), padded_len(&[0; WORD_SIZE * 2]));
}

#[test]
fn padded_len_usize_returns_multiple_of_word_len() {
    assert_eq!(padded_len_usize(0), Some(0));
    assert_eq!(padded_len_usize(1), Some(8));
    assert_eq!(padded_len_usize(2), Some(8));
    assert_eq!(padded_len_usize(7), Some(8));
    assert_eq!(padded_len_usize(8), Some(8));
    assert_eq!(padded_len_usize(9), Some(16));
}

#[test]
fn padded_len_usize_handles_overflow() {
    for i in 0..7 {
        assert_eq!(padded_len_usize(usize::MAX - i), None);
    }
    assert_eq!(padded_len_usize(usize::MAX - 7), Some(usize::MAX - 7));
}

/home/marten/fuel/fuel-vm/fuel-types/src/fmt.rs

Source
use alloc::vec::Vec;
use core::{
    fmt,
    fmt::Formatter,
};

/// Formatting utility to truncate a vector of bytes to a hex string of max length `N`
pub fn fmt_truncated_hex<const N: usize>(data: &[u8], f: &mut Formatter) -> fmt::Result {
    let formatted = if data.len() > N {
        let mut s = hex::encode(&data[0..N.saturating_sub(3)]);
        s.push_str("...");
        s
    } else {
        hex::encode(data)
    };
    f.write_str(formatted.as_str())
}

/// Formatting utility to truncate a optional vector of bytes to a hex string of max
/// length `N`
pub fn fmt_option_truncated_hex<const N: usize>(
    data: &Option<Vec<u8>>,
    f: &mut Formatter,
) -> fmt::Result {
    if let Some(data) = data {
        let formatted = if data.len() > N {
            let mut s = hex::encode(&data[0..N.saturating_sub(3)]);
            s.push_str("...");
            s
        } else {
            hex::encode(data)
        };
        f.write_str("Some(")?;
        f.write_str(formatted.as_str())?;
        f.write_str(")")
    } else {
        f.write_str("None")
    }
}

/home/marten/fuel/fuel-vm/fuel-types/src/numeric_types.rs

Source
use core::{
    array::TryFromSliceError,
    borrow::{
        Borrow,
        BorrowMut,
    },
    convert::TryFrom,
    fmt,
    ops::{
        Deref,
        DerefMut,
    },
    str,
};

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

#[cfg(all(feature = "alloc", feature = "typescript"))]
use alloc::vec::Vec;

macro_rules! key {
    ($i:ident, $t:ty) => {
        #[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
        /// FuelVM atomic numeric type.
        #[repr(transparent)]
        #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
        #[cfg_attr(feature = "serde", serde(transparent))]
        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        #[derive(
            fuel_types::canonical::Serialize, fuel_types::canonical::Deserialize,
        )]
        pub struct $i($t);

        key_methods!($i, $t);

        #[cfg(feature = "random")]
        impl Distribution<$i> for Standard {
            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $i {
                $i(rng.gen())
            }
        }
    };
}

macro_rules! key_methods {
    ($i:ident, $t:ty) => {
        const _: () = {
            const SIZE: usize = core::mem::size_of::<$t>();

            impl $i {
                /// Number constructor.
                pub const fn new(number: $t) -> Self {
                    Self(number)
                }

                /// Convert to array of big endian bytes.
                pub fn to_bytes(self) -> [u8; SIZE] {
                    self.0.to_be_bytes()
                }
            }

            #[cfg(feature = "typescript")]
            #[wasm_bindgen::prelude::wasm_bindgen]
            impl $i {
                #[wasm_bindgen::prelude::wasm_bindgen(constructor)]
                /// Number constructor.
                pub fn from_number(number: $t) -> Self {
                    Self(number)
                }

                /// Convert to array of big endian bytes.
                #[wasm_bindgen(js_name = to_bytes)]
                pub fn to_bytes_typescript(self) -> Vec<u8> {
                    self.to_bytes().to_vec()
                }

                /// Convert to usize.
                #[wasm_bindgen(js_name = as_usize)]
                pub fn as_usize_typescript(&self) -> usize {
                    usize::try_from(self.0).expect("Cannot convert to usize")
                }
            }

            #[cfg(feature = "random")]
            impl rand::Fill for $i {
                fn try_fill<R: rand::Rng + ?Sized>(
                    &mut self,
                    rng: &mut R,
                ) -> Result<(), rand::Error> {
                    let number = rng.gen();
                    *self = $i(number);

                    Ok(())
                }
            }

            impl Deref for $i {
                type Target = $t;

                fn deref(&self) -> &$t {
                    &self.0
                }
            }

            impl Borrow<$t> for $i {
                fn borrow(&self) -> &$t {
                    &self.0
                }
            }

            impl BorrowMut<$t> for $i {
                fn borrow_mut(&mut self) -> &mut $t {
                    &mut self.0
                }
            }

            impl DerefMut for $i {
                fn deref_mut(&mut self) -> &mut $t {
                    &mut self.0
                }
            }

            impl From<[u8; SIZE]> for $i {
                fn from(bytes: [u8; SIZE]) -> Self {
                    Self(<$t>::from_be_bytes(bytes))
                }
            }

            impl From<$t> for $i {
                fn from(value: $t) -> Self {
                    Self(value)
                }
            }

            impl From<$i> for [u8; SIZE] {
                fn from(salt: $i) -> [u8; SIZE] {
                    salt.0.to_be_bytes()
                }
            }

            impl From<$i> for $t {
                fn from(salt: $i) -> $t {
                    salt.0
                }
            }

            impl TryFrom<&[u8]> for $i {
                type Error = TryFromSliceError;

                fn try_from(bytes: &[u8]) -> Result<$i, TryFromSliceError> {
                    <[u8; SIZE]>::try_from(bytes).map(|b| b.into())
                }
            }

            impl fmt::LowerHex for $i {
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    if f.alternate() {
                        write!(f, "0x")?
                    }

                    let bytes = self.0.to_be_bytes();
                    match f.width() {
                        Some(w) if w > 0 => {
                            bytes.chunks(2 * bytes.len() / w).try_for_each(|c| {
                                write!(f, "{:02x}", c.iter().fold(0u8, |acc, x| acc ^ x))
                            })
                        }

                        _ => bytes.iter().try_for_each(|b| write!(f, "{:02x}", &b)),
                    }
                }
            }

            impl fmt::UpperHex for $i {
                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                    if f.alternate() {
                        write!(f, "0x")?
                    }

                    let bytes = self.0.to_be_bytes();
                    match f.width() {
                        Some(w) if w > 0 => {
                            bytes.chunks(2 * bytes.len() / w).try_for_each(|c| {
                                write!(f, "{:02X}", c.iter().fold(0u8, |acc, x| acc ^ x))
                            })
                        }

                        _ => bytes.iter().try_for_each(|b| write!(f, "{:02X}", &b)),
                    }
                }
            }

            impl fmt::Debug for $i {
                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                    <Self as fmt::LowerHex>::fmt(&self, f)
                }
            }

            impl fmt::Display for $i {
                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                    <Self as fmt::LowerHex>::fmt(&self, f)
                }
            }

            impl str::FromStr for $i {
                type Err = &'static str;

                fn from_str(s: &str) -> Result<Self, Self::Err> {
                    const ERR: &str = concat!("Invalid encoded byte in ", stringify!($i));
                    let mut ret = <[u8; SIZE]>::default();
                    let s = s.strip_prefix("0x").unwrap_or(s);
                    hex::decode_to_slice(&s, &mut ret).map_err(|_| ERR)?;
                    Ok(ret.into())
                }
            }
        };
    };
}

key!(BlockHeight, u32);
key!(ChainId, u64);

impl BlockHeight {
    /// Successor, i.e. next block after this
    pub fn succ(self) -> Option<BlockHeight> {
        Some(Self(self.0.checked_add(1)?))
    }

    /// Predecessor, i.e. previous block before this
    pub fn pred(self) -> Option<BlockHeight> {
        Some(Self(self.0.checked_sub(1)?))
    }
}

/home/marten/fuel/fuel-vm/fuel-types/src/array_types.rs

Source
// serde-big-array doesn't allow documentation of its generated structure
#![allow(missing_docs)]
use core::{
    array::TryFromSliceError,
    borrow::{
        Borrow,
        BorrowMut,
    },
    convert::TryFrom,
    fmt,
    ops::{
        Deref,
        DerefMut,
    },
    str,
};

#[cfg(feature = "random")]
use rand::{
    distributions::{
        Distribution,
        Standard,
    },
    Rng,
};

#[cfg(all(feature = "alloc", feature = "typescript"))]
use alloc::format;

macro_rules! key {
    ($i:ident, $s:expr) => {
        /// FuelVM atomic array type.
        #[derive(Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
        #[repr(transparent)]
        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        #[derive(
            fuel_types::canonical::Serialize, fuel_types::canonical::Deserialize,
        )]
        pub struct $i([u8; $s]);

        key_methods!($i, $s);

        #[cfg(feature = "random")]
        impl Distribution<$i> for Standard {
            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $i {
                $i(rng.gen())
            }
        }
    };
}

macro_rules! key_with_big_array {
    ($i:ident, $s:expr) => {
        /// FuelVM atomic type.
        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
        #[repr(transparent)]
        #[cfg_attr(feature = "typescript", wasm_bindgen::prelude::wasm_bindgen)]
        #[derive(
            fuel_types::canonical::Serialize, fuel_types::canonical::Deserialize,
        )]
        pub struct $i([u8; $s]);

        key_methods!($i, $s);

        impl Default for $i {
            fn default() -> $i {
                $i([0u8; $s])
            }
        }

        #[cfg(feature = "random")]
        impl Distribution<$i> for Standard {
            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $i {
                let mut bytes = $i::default();

                rng.fill_bytes(bytes.as_mut());

                bytes
            }
        }
    };
}

macro_rules! key_methods {
    ($i:ident, $s:expr) => {
        impl $i {
            /// Memory length of the type
            pub const LEN: usize = $s;

            /// Bytes constructor.
            pub const fn new(bytes: [u8; $s]) -> Self {
                Self(bytes)
            }

            /// Zeroes bytes constructor.
            pub const fn zeroed() -> $i {
                $i([0; $s])
            }

            #[cfg(feature = "unsafe")]
            #[allow(unsafe_code)]
            /// Add a conversion from arbitrary slices into owned
            ///
            /// # Safety
            ///
            /// This function will not panic if the length of the slice is smaller than
            /// `Self::LEN`. Instead, it will cause undefined behavior and read random
            /// disowned bytes
            pub unsafe fn from_slice_unchecked(bytes: &[u8]) -> Self {
                $i($crate::bytes::from_slice_unchecked(bytes))
            }

            /// Copy-free reference cast
            /// # Safety
            /// Assumes the type is `repr[transparent]`.
            pub fn from_bytes_ref_checked(bytes: &[u8]) -> Option<&Self> {
                let bytes: &[u8; $s] = bytes.get(..$s)?.try_into().ok()?;
                Some(Self::from_bytes_ref(bytes))
            }

            /// Copy-free reference cast
            /// # Safety
            /// Assumes the type is `repr[transparent]`.
            pub fn from_bytes_ref(bytes: &[u8; $s]) -> &Self {
                // The interpreter will frequently make references to keys and values
                // using logically checked slices.
                //
                // This function will save unnecessary copy to owned slices for the
                // interpreter access
                #[allow(unsafe_code)]
                unsafe {
                    &*(bytes.as_ptr() as *const Self)
                }
            }

            /// The memory size of the type by the method.
            pub const fn size(&self) -> usize {
                Self::LEN
            }
        }

        #[cfg(feature = "typescript")]
        #[wasm_bindgen::prelude::wasm_bindgen]
        impl $i {
            /// Bytes constructor.
            ///
            /// # Panics
            ///
            /// This function will panic if the length of `buf` is smaller than
            /// `Self::LEN`.
            #[wasm_bindgen(js_name = from_bytes)]
            pub fn from_bytes_typescript(bytes: &[u8]) -> Self {
                Self(bytes.try_into().expect(
                    format!("The size of the arrays it not {} size", $s).as_str(),
                ))
            }

            /// Zeroes bytes constructor.
            #[wasm_bindgen(js_name = zeroed)]
            pub fn zeroed_typescript() -> $i {
                Self::zeroed()
            }

            /// The memory size of the type by the method.
            #[wasm_bindgen(js_name = size)]
            pub fn size_typescript(&self) -> usize {
                self.size()
            }
        }

        #[cfg(feature = "random")]
        impl rand::Fill for $i {
            fn try_fill<R: rand::Rng + ?Sized>(
                &mut self,
                rng: &mut R,
            ) -> Result<(), rand::Error> {
                rng.fill_bytes(self.as_mut());

                Ok(())
            }
        }

        impl Deref for $i {
            type Target = [u8; $s];

            fn deref(&self) -> &[u8; $s] {
                &self.0
            }
        }

        impl Borrow<[u8; $s]> for $i {
            fn borrow(&self) -> &[u8; $s] {
                &self.0
            }
        }

        impl BorrowMut<[u8; $s]> for $i {
            fn borrow_mut(&mut self) -> &mut [u8; $s] {
                &mut self.0
            }
        }

        impl DerefMut for $i {
            fn deref_mut(&mut self) -> &mut [u8; $s] {
                &mut self.0
            }
        }

        impl AsRef<[u8]> for $i {
            fn as_ref(&self) -> &[u8] {
                &self.0
            }
        }

        impl AsMut<[u8]> for $i {
            fn as_mut(&mut self) -> &mut [u8] {
                &mut self.0
            }
        }

        impl From<[u8; $s]> for $i {
            fn from(bytes: [u8; $s]) -> Self {
                Self(bytes)
            }
        }

        impl From<$i> for [u8; $s] {
            fn from(salt: $i) -> [u8; $s] {
                salt.0
            }
        }

        impl TryFrom<&[u8]> for $i {
            type Error = TryFromSliceError;

            fn try_from(bytes: &[u8]) -> Result<$i, TryFromSliceError> {
                <[u8; $s]>::try_from(bytes).map(|b| b.into())
            }
        }

        impl fmt::LowerHex for $i {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                if f.alternate() {
                    write!(f, "0x")?
                }

                if let Some(w) = f
                    .width()
                    .and_then(|w| Self::LEN.saturating_mul(2).checked_div(w))
                {
                    self.0.chunks(w).try_for_each(|c| {
                        write!(f, "{:02x}", c.iter().fold(0u8, |acc, x| acc ^ x))
                    })
                } else {
                    self.0.iter().try_for_each(|b| write!(f, "{:02x}", &b))
                }
            }
        }

        impl fmt::UpperHex for $i {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                if f.alternate() {
                    write!(f, "0x")?
                }

                if let Some(w) = f
                    .width()
                    .and_then(|w| Self::LEN.saturating_mul(2).checked_div(w))
                {
                    self.0.chunks(w).try_for_each(|c| {
                        write!(f, "{:02X}", c.iter().fold(0u8, |acc, x| acc ^ x))
                    })
                } else {
                    self.0.iter().try_for_each(|b| write!(f, "{:02X}", &b))
                }
            }
        }

        impl fmt::Debug for $i {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                <Self as fmt::LowerHex>::fmt(&self, f)
            }
        }

        impl fmt::Display for $i {
            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                <Self as fmt::LowerHex>::fmt(&self, f)
            }
        }

        impl str::FromStr for $i {
            type Err = &'static str;

            fn from_str(s: &str) -> Result<Self, Self::Err> {
                const ERR: &str = concat!("Invalid encoded byte in ", stringify!($i));
                let mut ret = $i::zeroed();
                let s = s.strip_prefix("0x").unwrap_or(s);
                hex::decode_to_slice(&s, &mut ret.0).map_err(|_| ERR)?;
                Ok(ret)
            }
        }

        #[cfg(feature = "serde")]
        impl serde::Serialize for $i {
            #[inline(always)]
            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
            where
                S: serde::Serializer,
            {
                use alloc::format;
                use serde::ser::SerializeTuple;
                if serializer.is_human_readable() {
                    serializer.serialize_str(&format!("{:x}", &self))
                } else {
                    // Fixed-size arrays are tuples in serde data model
                    let mut arr = serializer.serialize_tuple($s)?;
                    for elem in &self.0 {
                        arr.serialize_element(elem)?;
                    }
                    arr.end()
                }
            }
        }

        #[cfg(feature = "serde")]
        impl<'de> serde::Deserialize<'de> for $i {
            #[inline(always)]
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: serde::Deserializer<'de>,
            {
                use serde::de::Error;
                if deserializer.is_human_readable() {
                    let s: alloc::string::String =
                        serde::Deserialize::deserialize(deserializer)?;
                    s.parse().map_err(D::Error::custom)
                } else {
                    deserializer.deserialize_tuple($s, ArrayVisitor).map(Self)
                }
            }
        }
    };
}

key!(Address, 32);
key!(AssetId, 32);
key!(BlobId, 32);
key!(ContractId, 32);
key!(TxId, 32);
key!(Bytes4, 4);
key!(Bytes8, 8);
key!(Bytes20, 20);
key!(Bytes32, 32);
key!(Nonce, 32);
key!(MessageId, 32);
key!(Salt, 32);

key_with_big_array!(Bytes64, 64);

impl ContractId {
    /// Seed for the calculation of the contract id from its code.
    ///
    /// <https://github.com/FuelLabs/fuel-specs/blob/master/src/identifiers/contract-id.md>
    pub const SEED: [u8; 4] = 0x4655454C_u32.to_be_bytes();
}

impl AssetId {
    pub const BASE: AssetId = AssetId::zeroed();
}

impl From<u64> for Nonce {
    fn from(value: u64) -> Self {
        let mut default = [0u8; 32];
        default[..8].copy_from_slice(&value.to_be_bytes());
        default.into()
    }
}

/// A visitor for deserializing a fixed-size byte array.
#[cfg(feature = "serde")]
struct ArrayVisitor<const S: usize>;

#[cfg(feature = "serde")]
impl<'de, const S: usize> serde::de::Visitor<'de> for ArrayVisitor<S> {
    type Value = [u8; S];

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(formatter, "an array of {S} bytes")
    }

    #[inline(always)]
    fn visit_borrowed_bytes<E>(self, items: &'de [u8]) -> Result<Self::Value, E> {
        let mut result = [0u8; S];
        result.copy_from_slice(items);
        Ok(result)
    }

    #[cfg(feature = "alloc")]
    #[inline(always)]
    fn visit_byte_buf<E>(self, v: alloc::vec::Vec<u8>) -> Result<Self::Value, E>
    where
        E: serde::de::Error,
    {
        self.visit_borrowed_bytes(v.as_slice())
    }

    #[inline(always)]
    fn visit_seq<A>(self, mut value: A) -> Result<Self::Value, A::Error>
    where
        A: serde::de::SeqAccess<'de>,
    {
        let mut arr = [0u8; S];
        for (i, elem) in arr.iter_mut().enumerate() {
            *elem = value
                .next_element()?
                .ok_or_else(|| serde::de::Error::invalid_length(i, &self))?;
        }
        Ok(arr)
    }
}

/// Roundtrip serde encode/decode tests
#[cfg(all(test, feature = "serde"))]
mod tests_serde {
    use rand::{
        rngs::StdRng,
        SeedableRng,
    };

    use super::*;

    /// serde_json uses human-readable serialization by default
    #[test]
    fn test_human_readable() {
        let rng = &mut StdRng::seed_from_u64(8586);
        let original: Address = rng.gen();
        let serialized = serde_json::to_string(&original).expect("Serialization failed");
        assert_eq!(
            serialized,
            "\"7bbd8a4ea06e94461b959ab18d35802bbac3cf47e2bf29195f7db2ce41630cd7\""
        );
        let recreated: Address =
            serde_json::from_str(&serialized).expect("Deserialization failed");
        assert_eq!(original, recreated);
    }

    /// postcard uses non-human-readable serialization
    #[test]
    fn test_not_human_readable() {
        let rng = &mut StdRng::seed_from_u64(8586);
        let original: Address = rng.gen();
        let serialized = postcard::to_stdvec(&original).expect("Serialization failed");
        let expected_vec = original.0.to_vec();
        assert_eq!(&serialized, &expected_vec);
        let recreated: Address =
            postcard::from_bytes(&serialized).expect("Deserialization failed");
        assert_eq!(original, recreated);
    }

    /// postcard uses non-human-readable serialization
    #[test]
    fn test_not_human_readable_incorrect_deser() {
        let rng = &mut StdRng::seed_from_u64(8586);
        let original: Address = rng.gen();
        let mut serialized =
            postcard::to_stdvec(&original).expect("Serialization failed");
        serialized.pop();
        let res: Result<Address, _> = postcard::from_bytes(&serialized);
        res.expect_err("Deserialization should have failed");
    }

    /// bincode uses non-human-readable serialization
    #[test]
    fn test_bincode() {
        let rng = &mut StdRng::seed_from_u64(8586);
        let original: Address = rng.gen();
        let serialized = bincode::serialize(&original).expect("Serialization failed");
        let recreated: Address =
            bincode::deserialize(&serialized).expect("Deserialization failed");
        assert_eq!(original, recreated);
    }
}