implementing BLAKE3 opcode

Cargo.toml

@@ -27,6 +27,7 @@ paste = "1"
 strict_encoding = { version = "2.7.0-beta.1", default-features = false, features = ["float", "derive"] }
 strict_types = { version = "2.7.0-beta.2", optional = true }
 sha2 = "0.10.8"
+blake3 = "1.5.1"
 ripemd = "0.1.3"
 baid58 = "0.4.4"
 secp256k1 = { version = "0.28.2", optional = true, features = ["global-context"] }

src/isa/bytecode.rs

@@ -1299,6 +1299,7 @@
             DigestOp::Ripemd(_, _) => INSTR_RIPEMD,
             DigestOp::Sha256(_, _) => INSTR_SHA256,
             DigestOp::Sha512(_, _) => INSTR_SHA512,
+            DigestOp::Blake3(_, _) => INSTR_BLAKE3,
         }
     }
 
@@ -1309,6 +1310,7 @@
         match self {
             DigestOp::Ripemd(src, dst)
             | DigestOp::Sha256(src, dst)
+            | DigestOp::Blake3(src, dst)
             | DigestOp::Sha512(src, dst) => {
                 writer.write_u4(src)?;
                 writer.write_u4(dst)?;
@@ -1328,6 +1330,7 @@
         Ok(match instr {
             INSTR_RIPEMD => Self::Ripemd(src, dst),
             INSTR_SHA256 => Self::Sha256(src, dst),
+            INSTR_BLAKE3 => Self::Blake3(src, dst),
             INSTR_SHA512 => Self::Sha512(src, dst),
             x => unreachable!("instruction {:#010b} classified as digest operation", x),
         })

src/isa/exec.rs

@@ -1372,6 +1372,7 @@
         match self {
             DigestOp::Ripemd(src, _dst)
             | DigestOp::Sha256(src, _dst)
+            | DigestOp::Blake3(src, _dst)
             | DigestOp::Sha512(src, _dst) => bset![Reg::S(*src)],
         }
     }
@@ -1380,6 +1381,7 @@
         match self {
             DigestOp::Ripemd(_src, dst) => bset![Reg::new(RegR::R160, *dst)],
             DigestOp::Sha256(_src, dst) => bset![Reg::new(RegR::R256, *dst)],
+            DigestOp::Blake3(_src, dst) => bset![Reg::new(RegR::R256, *dst)],
             DigestOp::Sha512(_src, dst) => bset![Reg::new(RegR::R512, *dst)],
         }
     }
@@ -1407,6 +1409,12 @@
                 let hash: Option<[u8; 32]> = s.map(|s| sha2::Sha256::digest(s.as_ref()).into());
                 regs.set_n(RegR::R256, dst, hash);
             }
+            DigestOp::Blake3(src, dst) => {
+                let s = regs.get_s(*src);
+                none = s.is_none();
+                let hash: Option<[u8; 32]> = s.map(|s| blake3::hash(s.as_ref()).into());
+                regs.set_n(RegR::R256, dst, hash);
+            }
             DigestOp::Sha512(src, dst) => {
                 let s = regs.get_s(*src);
                 none = s.is_none();

src/isa/instr.rs

@@ -883,6 +883,16 @@ pub enum DigestOp {
         /** Index of string register */ RegS,
         /** Index of `r512` register to save result to */ Reg16,
     ),
+
+    /// Computes BLAKE3 hash value
+    ///
+    /// Sets `st0` to `false` and destination register to `None` if the source register does not
+    /// contain a value
+    #[display("blake3  {0},r256{1}")]
+    Blake3(
+        /** Index of string register */ RegS,
+        /** Index of `r256` register to save result to */ Reg16,
+    ),
 }
 
 /// Operations on Secp256k1 elliptic curve

src/isa/macros.rs

@@ -842,6 +842,9 @@ macro_rules! instr {
     (sha2 s16[$idx1:literal],r256[$idx2:literal]) => {
         Instr::Digest(DigestOp::Sha256(RegS::from($idx1), $crate::_reg_idx16!($idx2)))
     };
+    (blake3 s16[$idx1:literal],r256[$idx2:literal]) => {
+        Instr::Digest(DigestOp::Blake3(RegS::from($idx1), $crate::_reg_idx16!($idx2)))
+    };
     (sha2 s16[$idx1:literal],r512[$idx2:literal]) => {
         Instr::Digest(DigestOp::Sha512(RegS::from($idx1), $crate::_reg_idx16!($idx2)))
     };

src/isa/opcodes.rs

@@ -117,6 +117,7 @@ pub const INSTR_RESV_TO: u8 = 0b01_111_111;
 pub const INSTR_RIPEMD: u8 = 0b10_000_000;
 pub const INSTR_SHA256: u8 = 0b10_000_001;
 pub const INSTR_SHA512: u8 = 0b10_000_010;
+pub const INSTR_BLAKE3: u8 = 0b10_000_100;
 
 // ### Secp256k1 operations (SECP256K1)