feat: add function for generating bytecode identifier

forc-util/Cargo.toml

@@ -16,13 +16,15 @@ clap = { workspace = true, features = ["cargo", "derive", "env"] }
 dirs.workspace = true
 fd-lock.workspace = true
 forc-tracing.workspace = true
+fuel-asm.workspace = true
 fuel-tx = { workspace = true, optional = true }
 hex.workspace = true
 paste.workspace = true
 regex.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
 serial_test.workspace = true
+sha2.workspace = true
 sway-core.workspace = true
 sway-error.workspace = true
 sway-types.workspace = true

forc-util/src/bytecode.rs

@@ -0,0 +1,170 @@
+use anyhow::anyhow;
+use sha2::{Digest, Sha256};
+use std::fs::File;
+use std::io::{BufReader, Read};
+use std::path::Path;
+
+// The index of the beginning of the half-word (4 bytes) that contains the configurables section offset.
+const CONFIGURABLES_OFFSET_INSTR_LO: usize = 4;
+// The index of the end of the half-word (4 bytes) that contains the configurables section offset.
+const CONFIGURABLES_OFFSET_INSTR_HI: usize = 5;
+// The count of the beginning half-words that contain the configurables section offset.
+const CONFIGURABLES_OFFSET_PREAMBLE: usize = CONFIGURABLES_OFFSET_INSTR_HI + 1;
+
+/// A tuple of an instruction and its corresponding bytes. Useful when needing to access the raw bytes
+/// of an instruction that is parsed as [fuel_asm::InvalidOpcode], such as metadata in the preamble.
+pub type InstructionWithBytes = (
+    Result<fuel_asm::Instruction, fuel_asm::InvalidOpcode>,
+    Vec<u8>,
+);
+
+/// An iterator over each [fuel_asm::Instruction] or [fuel_asm::InvalidOpcode] with its corresponding bytes.
+pub struct InstructionWithBytesIterator {
+    buf_reader: BufReader<File>,
+}
+
+impl InstructionWithBytesIterator {
+    /// Return a new iterator for each instruction parsed from raw bytes.
+    pub fn new(buf_reader: BufReader<File>) -> Self {
+        InstructionWithBytesIterator { buf_reader }
+    }
+}
+
+impl Iterator for InstructionWithBytesIterator {
+    type Item = InstructionWithBytes;
+
+    fn next(&mut self) -> Option<InstructionWithBytes> {
+        let mut buffer = [0; fuel_asm::Instruction::SIZE];
+        // Read the next instruction into the buffer
+        match self.buf_reader.read_exact(&mut buffer) {
+            Ok(_) => fuel_asm::from_bytes(buffer)
+                .next()
+                .map(|inst| (inst, buffer.to_vec())),
+            Err(_) => None,
+        }
+    }
+}
+
+/// Parses a bytecode file into an iterator of instructions and their corresponding bytes.
+pub fn parse_bytecode_to_instructions<P>(path: P) -> anyhow::Result<InstructionWithBytesIterator>
+where
+    P: AsRef<Path> + Clone,
+{
+    let f = File::open(path.clone())
+        .map_err(|_| anyhow!("{}: file not found", path.as_ref().to_string_lossy()))?;
+    let buf_reader = BufReader::new(f);
+
+    Ok(InstructionWithBytesIterator::new(buf_reader))
+}
+
+/// Gets the bytecode ID from a bytecode file. The bytecode ID is the hash of the bytecode after removing the
+/// condigurables section, if any.
+pub fn get_bytecode_id<P>(path: P) -> anyhow::Result<String>
+where
+    P: AsRef<Path> + Clone,
+{
+    let mut instructions = parse_bytecode_to_instructions(path.clone())?;
+
+    // Collect the first six instructions into a temporary vector
+    let mut first_six_instructions = Vec::with_capacity(CONFIGURABLES_OFFSET_PREAMBLE);
+    for _ in 0..CONFIGURABLES_OFFSET_PREAMBLE {
+        if let Some(instruction) = instructions.next() {
+            first_six_instructions.push(instruction);
+        } else {
+            return Err(anyhow!("Incomplete bytecode"));
+        }
+    }
+
+    let (lo_instr, low_raw) = &first_six_instructions[CONFIGURABLES_OFFSET_INSTR_LO];
+    let (hi_instr, hi_raw) = &first_six_instructions[CONFIGURABLES_OFFSET_INSTR_HI];
+
+    if let Err(fuel_asm::InvalidOpcode) = lo_instr {
+        if let Err(fuel_asm::InvalidOpcode) = hi_instr {
+            // Now assemble the configurables offset.
+            let configurables_offset = usize::from_be_bytes([
+                low_raw[0], low_raw[1], low_raw[2], low_raw[3], hi_raw[0], hi_raw[1], hi_raw[2],
+                hi_raw[3],
+            ]);
+
+            // Hash the first six instructions
+            let mut hasher = Sha256::new();
+            for (_, raw) in first_six_instructions {
+                hasher.update(raw);
+            }
+
+            // Continue hashing the remaining instructions up to the configurables section offset.
+            instructions
+                .take(
+                    configurables_offset / fuel_asm::Instruction::SIZE
+                        - CONFIGURABLES_OFFSET_PREAMBLE,
+                ) // Minus 6 because we already hashed the first six
+                .for_each(|(_, raw)| {
+                    hasher.update(raw);
+                });
+
+            let hash_result = hasher.finalize();
+            let bytecode_id = format!("{:x}", hash_result);
+            return Ok(bytecode_id);
+        }
+    }
+
+    Err(anyhow!("Configurables section offset not found"))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_get_bytecode_id_happy() {
+        let bytecode_id: String =
+            get_bytecode_id("tests/fixtures/bytecode/debug-counter.bin").expect("bytecode id");
+        assert_eq!(
+            bytecode_id,
+            "e65aa988cae1041b64dc2d85e496eed0e8a1d8105133bd313c17645a1859d53b".to_string()
+        );
+
+        let bytecode_id =
+            get_bytecode_id("tests/fixtures/bytecode/release-counter.bin").expect("bytecode id");
+        assert_eq!(
+            bytecode_id,
+            "42ae8352cbc892d7c7621f1d6fb42b072a08ba5968508d49f54991668d4ea141".to_string()
+        );
+
+        let bytecode_id =
+            get_bytecode_id("tests/fixtures/bytecode/debug-configurable_constants.bin")
+                .expect("bytecode id");
+        assert_eq!(
+            bytecode_id,
+            "babc3d9dcac8d48dee1e5aeb3340ff098d3c1ab8b0a28341d9291d8ff757199e".to_string()
+        );
+
+        let bytecode_id =
+            get_bytecode_id("tests/fixtures/bytecode/release-configurable_constants.bin")
+                .expect("bytecode id");
+        assert_eq!(
+            bytecode_id,
+            "2adfb515b66763fd29391bdba012921d045a0be83d89be5492bcaacc429695e9".to_string()
+        );
+    }
+
+    #[test]
+    fn test_get_bytecode_id_missing_configurable_offset() {
+        let result = get_bytecode_id(
+            "tests/fixtures/bytecode/debug-configurable_constants-missing-offset.bin",
+        );
+        assert_eq!(
+            result.unwrap_err().to_string().as_str(),
+            "Configurables section offset not found"
+        );
+    }
+
+    #[test]
+    fn test_get_bytecode_id_bad_path() {
+        let result = get_bytecode_id("tests/fixtures/bytecode/blahblahblahblah.bin");
+        assert_eq!(
+            result.unwrap_err().to_string().as_str(),
+            "tests/fixtures/bytecode/blahblahblahblah.bin: file not found"
+        );
+    }
+}

forc-util/src/lib.rs

@@ -23,6 +23,7 @@ use sway_error::{
 use sway_types::{LineCol, LineColRange, SourceEngine, Span};
 use sway_utils::constants;
 
+pub mod bytecode;
 pub mod fs_locking;
 pub mod restricted;
 

forc/src/cli/commands/parse_bytecode.rs

@@ -1,8 +1,6 @@
-use anyhow::anyhow;
 use clap::Parser;
+use forc_util::bytecode::parse_bytecode_to_instructions;
 use forc_util::ForcResult;
-use std::fs::{self, File};
-use std::io::Read;
 use term_table::row::Row;
 use term_table::table_cell::{Alignment, TableCell};
 use tracing::info;
@@ -21,15 +19,7 @@ pub(crate) struct Command {
 }
 
 pub(crate) fn exec(command: Command) -> ForcResult<()> {
-    let mut f = File::open(&command.file_path)
-        .map_err(|_| anyhow!("{}: file not found", command.file_path))?;
-    let metadata = fs::metadata(&command.file_path)
-        .map_err(|_| anyhow!("{}: file not found", command.file_path))?;
-    let mut buffer = vec![0; metadata.len() as usize];
-    f.read_exact(&mut buffer).expect("buffer overflow");
-
-    let instructions = fuel_asm::from_bytes(buffer.iter().cloned())
-        .zip(buffer.chunks(fuel_asm::Instruction::SIZE));
+    let instructions = parse_bytecode_to_instructions(&command.file_path)?;
 
     let mut table = term_table::Table::new();
     table.separate_rows = false;