[2.11.1] Implement blake libfunc

src/libfuncs.rs

@@ -33,6 +33,7 @@ use num_bigint::BigInt;
 use std::{cell::Cell, error::Error, ops::Deref};
 
 mod array;
+mod blake;
 mod r#bool;
 mod bounded_int;
 mod r#box;
@@ -179,7 +180,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,120 @@
+use cairo_lang_sierra::{
+    extensions::{
+        blake::BlakeConcreteLibfunc,
+        core::{CoreLibfunc, CoreType},
+        lib_func::SignatureOnlyConcreteLibfunc,
+    },
+    program_registry::ProgramRegistry,
+};
+use melior::{
+    ir::{Block, BlockLike, Location},
+    Context,
+};
+
+use crate::{
+    error::{panic::ToNativeAssertError, Result},
+    metadata::{runtime_bindings::RuntimeBindingsMeta, MetadataStorage},
+    utils::BlockExt,
+};
+
+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` is the total amount of bytes hashed after hashing the message.
+/// `finalize` is wether the libfunc call is a finalize or not.
+#[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, 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,
+    )?;
+
+    entry.append_operation(helper.br(0, &[state_ptr], location));
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        utils::test::{jit_struct, load_cairo, run_program},
+        Value,
+    };
+
+    #[test]
+    fn test_blake() {
+        let program = load_cairo!(
+            use core::blake::{blake2s_compress, blake2s_finalize};
+
+            fn run_test() -> [u32; 8] nopanic {
+                let state = BoxTrait::new([0_u32; 8]);
+                let msg = BoxTrait::new([0_u32; 16]);
+                let byte_count = 64_u32;
+
+                let _res = blake2s_compress(state, byte_count, msg).unbox();
+
+                blake2s_finalize(state, byte_count, msg).unbox()
+            }
+        );
+
+        let result = run_program(&program, "run_test", &[]).return_value;
+
+        assert_eq!(
+            result,
+            jit_struct!(
+                Value::Uint32(128291589),
+                Value::Uint32(1454945417),
+                Value::Uint32(3191583614),
+                Value::Uint32(1491889056),
+                Value::Uint32(794023379),
+                Value::Uint32(651000200),
+                Value::Uint32(3725903680),
+                Value::Uint32(1044330286),
+            )
+        );
+    }
+}

src/metadata/runtime_bindings.rs

@@ -40,6 +40,7 @@ enum RuntimeBinding {
     DictDrop,
     DictDup,
     GetCostsBuiltin,
+    BlakeCompress,
     DebugPrint,
     #[cfg(feature = "with-cheatcode")]
     VtableCheatcode,
@@ -65,6 +66,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",
             #[cfg(feature = "with-cheatcode")]
             RuntimeBinding::VtableCheatcode => "cairo_native__vtable_cheatcode",
         }
@@ -109,6 +111,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 ()
+            }
             #[cfg(feature = "with-cheatcode")]
             RuntimeBinding::VtableCheatcode => {
                 crate::starknet::cairo_native__vtable_cheatcode as *const ()
@@ -257,6 +262,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,
@@ -681,6 +717,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,