[2.11.1] Implement blake libfunc

src/libfuncs.rs

@@ -45,6 +45,7 @@ use std::{
 };
 
 mod array;
+mod blake;
 mod r#bool;
 mod bounded_int;
 mod r#box;
@@ -191,7 +192,9 @@ impl LibfuncBuilder for CoreConcreteLibfunc {
             Self::IntRange(selector) => self::int_range::build(
                 context, registry, entry, location, helper, metadata, selector,
             ),
-            Self::Blake(_) => native_panic!("Implement blake libfunc"),
+            Self::Blake(selector) => self::blake::build(
+                context, registry, entry, location, helper, metadata, selector,
+            ),
             Self::Mem(selector) => self::mem::build(
                 context, registry, entry, location, helper, metadata, selector,
             ),

src/libfuncs/blake.rs

@@ -0,0 +1,135 @@
+use cairo_lang_sierra::{
+    extensions::{
+        blake::BlakeConcreteLibfunc,
+        core::{CoreLibfunc, CoreType},
+        lib_func::SignatureOnlyConcreteLibfunc,
+    },
+    program_registry::ProgramRegistry,
+};
+use melior::{
+    helpers::{ArithBlockExt, BuiltinBlockExt},
+    ir::{Block, Location},
+    Context,
+};
+
+use crate::{
+    error::{panic::ToNativeAssertError, Result},
+    metadata::{runtime_bindings::RuntimeBindingsMeta, MetadataStorage},
+};
+
+use super::LibfuncHelper;
+
+pub fn build<'ctx, 'this>(
+    context: &'ctx Context,
+    registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+    entry: &'this Block<'ctx>,
+    location: Location<'ctx>,
+    helper: &LibfuncHelper<'ctx, 'this>,
+    metadata: &mut MetadataStorage,
+    selector: &BlakeConcreteLibfunc,
+) -> Result<()> {
+    match selector {
+        BlakeConcreteLibfunc::Blake2sCompress(info) => build_blake_operation(
+            context, registry, entry, location, helper, metadata, info, false,
+        ),
+        BlakeConcreteLibfunc::Blake2sFinalize(info) => build_blake_operation(
+            context, registry, entry, location, helper, metadata, info, true,
+        ),
+    }
+}
+
+/// Performs a blake2s compression.
+///
+/// `bytes_count`: total amount of bytes hashed after hashing the message.
+/// `finalize`: wether the libfunc call is a finalize or not.
+/// ```cairo
+/// pub extern fn blake2s_compress(
+///     state: Blake2sState, byte_count: u32, msg: Blake2sInput,
+/// ) -> Blake2sState nopanic;
+/// ```
+///
+/// Similar to `blake2s_compress`, but it marks the end of the compression
+/// ```cairo
+/// pub extern fn blake2s_finalize(
+///     state: Blake2sState, byte_count: u32, msg: Blake2sInput,
+/// ) -> Blake2sState nopanic;
+/// ```
+#[allow(clippy::too_many_arguments)]
+fn build_blake_operation<'ctx, 'this>(
+    context: &'ctx Context,
+    _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+    entry: &'this Block<'ctx>,
+    location: Location<'ctx>,
+    helper: &LibfuncHelper<'ctx, 'this>,
+    metadata: &mut MetadataStorage,
+    _info: &SignatureOnlyConcreteLibfunc,
+    finalize: bool,
+) -> Result<()> {
+    let state_ptr = entry.arg(0)?;
+    let bytes_count = entry.arg(1)?;
+    let message = entry.arg(2)?;
+    let k_finalize = entry.const_int(context, location, finalize as u8, 1)?;
+
+    let runtime_bindings = metadata
+        .get_mut::<RuntimeBindingsMeta>()
+        .to_native_assert_error("runtime library should be available")?;
+
+    runtime_bindings.libfunc_blake_compress(
+        context,
+        helper,
+        entry,
+        state_ptr,
+        message,
+        bytes_count,
+        k_finalize,
+        location,
+    )?;
+
+    helper.br(entry, 0, &[state_ptr], location)?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        utils::test::{jit_struct, load_cairo, run_program},
+        Value,
+    };
+
+    // This test is taken from the Blake2s-256 implementeation RFC-7693, Appendix B.
+    // https://www.rfc-editor.org/rfc/rfc7693#appendix-B.
+    #[test]
+    fn test_blake_3_bytes_compress() {
+        let program = load_cairo!(
+            use core::blake::{blake2s_compress, blake2s_finalize};
+
+            fn run_test() -> [u32; 8] nopanic {
+                let initial_state: Box<[u32; 8]> = BoxTrait::new([
+                    0x6B08E647, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19,
+                ]);
+                // This number represents the bytes for "abc" string.
+                let abc_bytes = 0x00636261;
+                let msg: Box<[u32; 16]>  = BoxTrait::new([abc_bytes, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+
+                blake2s_finalize(initial_state, 3, msg).unbox()
+            }
+        );
+
+        let result = run_program(&program, "run_test", &[]).return_value;
+
+        assert_eq!(
+            result,
+            jit_struct!(
+                Value::Uint32(0x8C5E8C50),
+                Value::Uint32(0xE2147C32),
+                Value::Uint32(0xA32BA7E1),
+                Value::Uint32(0x2F45EB4E),
+                Value::Uint32(0x208B4537),
+                Value::Uint32(0x293AD69E),
+                Value::Uint32(0x4C9B994D),
+                Value::Uint32(0x82596786),
+            )
+        );
+    }
+}

src/metadata/runtime_bindings.rs

@@ -45,6 +45,7 @@ enum RuntimeBinding {
     DictDrop,
     DictDup,
     GetCostsBuiltin,
+    BlakeCompress,
     DebugPrint,
     ExtendedEuclideanAlgorithm,
     CircuitArithOperation,
@@ -72,6 +73,7 @@ impl RuntimeBinding {
             RuntimeBinding::DictDrop => "cairo_native__dict_drop",
             RuntimeBinding::DictDup => "cairo_native__dict_dup",
             RuntimeBinding::GetCostsBuiltin => "cairo_native__get_costs_builtin",
+            RuntimeBinding::BlakeCompress => "cairo_native__libfunc__blake_compress",
             RuntimeBinding::ExtendedEuclideanAlgorithm => {
                 "cairo_native__extended_euclidean_algorithm"
             }
@@ -124,6 +126,9 @@ impl RuntimeBinding {
             RuntimeBinding::GetCostsBuiltin => {
                 crate::runtime::cairo_native__get_costs_builtin as *const ()
             }
+            RuntimeBinding::BlakeCompress => {
+                crate::runtime::cairo_native__libfunc__blake_compress as *const ()
+            }
             RuntimeBinding::ExtendedEuclideanAlgorithm => return None,
             RuntimeBinding::CircuitArithOperation => return None,
             #[cfg(feature = "with-cheatcode")]
@@ -377,6 +382,37 @@ impl RuntimeBindingsMeta {
         ))
     }
 
+    #[allow(clippy::too_many_arguments)]
+    pub fn libfunc_blake_compress<'c, 'a>(
+        &mut self,
+        context: &'c Context,
+        module: &Module,
+        block: &'a Block<'c>,
+        state: Value<'c, 'a>,
+        message: Value<'c, 'a>,
+        count_bytes: Value<'c, 'a>,
+        finalize: Value<'c, 'a>,
+        location: Location<'c>,
+    ) -> Result<OperationRef<'c, 'a>>
+    where
+        'c: 'a,
+    {
+        let function = self.build_function(
+            context,
+            module,
+            block,
+            location,
+            RuntimeBinding::BlakeCompress,
+        )?;
+
+        Ok(block.append_operation(
+            OperationBuilder::new("llvm.call", location)
+                .add_operands(&[function])
+                .add_operands(&[state, message, count_bytes, finalize])
+                .build()?,
+        ))
+    }
+
     /// Register if necessary, then invoke the `ec_point_from_x_nz()` function.
     pub fn libfunc_ec_point_from_x_nz<'c, 'a>(
         &mut self,
@@ -798,6 +834,7 @@ pub fn setup_runtime(find_symbol_ptr: impl Fn(&str) -> Option<*mut c_void>) {
         RuntimeBinding::DictDrop,
         RuntimeBinding::DictDup,
         RuntimeBinding::GetCostsBuiltin,
+        RuntimeBinding::BlakeCompress,
         RuntimeBinding::DebugPrint,
         #[cfg(feature = "with-cheatcode")]
         RuntimeBinding::VtableCheatcode,

src/runtime.rs

@@ -1,6 +1,6 @@
 #![allow(non_snake_case)]
 
-use crate::utils::BuiltinCosts;
+use crate::utils::{blake_utils, BuiltinCosts};
 use cairo_lang_sierra_gas::core_libfunc_cost::{
     DICT_SQUASH_REPEATED_ACCESS_COST, DICT_SQUASH_UNIQUE_KEY_COST,
 };
@@ -144,6 +144,24 @@ pub unsafe extern "C" fn cairo_native__libfunc__hades_permutation(
     *op2 = state[2].to_bytes_le();
 }
 
+pub unsafe extern "C" fn cairo_native__libfunc__blake_compress(
+    state: &mut [u32; 8],
+    message: &[u32; 16],
+    count_bytes: u32,
+    finalize: bool,
+) {
+    let new_state = blake_utils::blake2s_compress(
+        state,
+        message,
+        count_bytes,
+        0,
+        if finalize { 0xFFFFFFFF } else { 0 },
+        0,
+    );
+
+    *state = new_state;
+}
+
 /// Felt252 type used in cairo native runtime
 #[derive(Debug)]
 pub struct FeltDict {

src/types.rs

@@ -546,7 +546,8 @@ impl TypeBuilder for CoreTypeConcrete {
             CoreTypeConcrete::Circuit(info) => circuit::is_complex(info),
 
             CoreTypeConcrete::IntRange(_info) => false,
-            CoreTypeConcrete::Blake(_info) => native_panic!("Implement is_complex for Blake type"),
+
+            CoreTypeConcrete::Blake(_) => native_panic!("Implement is_complex for Blake type"),
             CoreTypeConcrete::QM31(_info) => native_panic!("Implement is_complex for QM31 type"),
             CoreTypeConcrete::GasReserve(_info) => native_panic!("Implement is_complex for GasReserve type"),
         })
@@ -633,7 +634,7 @@ impl TypeBuilder for CoreTypeConcrete {
                 let type_info = registry.get_type(&info.ty)?;
                 type_info.is_zst(registry)?
             }
-            CoreTypeConcrete::Blake(_info) => native_panic!("Implement is_zst for Blake type"),
+            CoreTypeConcrete::Blake(_) => native_panic!("Implement is_zst for Blake type"),
             CoreTypeConcrete::QM31(_info) => native_panic!("Implement is_zst for QM31 type"),
             CoreTypeConcrete::GasReserve(_info) => {
                 native_panic!("Implement is_zst for GasReserve type")
@@ -765,9 +766,6 @@ impl TypeBuilder for CoreTypeConcrete {
         // arguments.
         Ok(match self {
             CoreTypeConcrete::IntRange(_) => false,
-            CoreTypeConcrete::Blake(_info) => {
-                native_panic!("Implement is_memory_allocated for Blake type")
-            }
             CoreTypeConcrete::Array(_) => false,
             CoreTypeConcrete::Bitwise(_) => false,
             CoreTypeConcrete::Box(_) => false,
@@ -843,6 +841,9 @@ impl TypeBuilder for CoreTypeConcrete {
                 .is_memory_allocated(registry)?,
             CoreTypeConcrete::Coupon(_) => false,
             CoreTypeConcrete::Circuit(_) => false,
+            CoreTypeConcrete::Blake(_) => {
+                native_panic!("Implement is_memory_allocated for Blake type")
+            }
             CoreTypeConcrete::QM31(_) => native_panic!("Implement is_memory_allocated for QM31"),
             CoreTypeConcrete::GasReserve(_) => {
                 native_panic!("Implement is_memory_allocated for GasReserve")

src/utils.rs

@@ -31,6 +31,7 @@ use std::{
 };
 use thiserror::Error;
 
+pub mod blake_utils;
 pub mod mem_tracing;
 mod program_registry_ext;
 mod range_ext;