Host function generic_hash() with blake2b/blake3 support.

execution_engine/Cargo.toml

@@ -14,6 +14,7 @@ license = "Apache-2.0"
 anyhow = "1.0.33"
 base16 = "0.2.1"
 bincode = "1.3.1"
+blake3 = "1.5.0"
 casper-hashing = { version = "2.0.0", path = "../hashing" }
 casper-types = { version = "3.0.0", path = "../types", default-features = false, features = ["datasize", "gens", "json-schema"] }
 casper-wasm = { version = "0.46.0", default-features = false }

execution_engine/src/core/resolvers/v1_function_index.rs

@@ -60,6 +60,7 @@ pub(crate) enum FunctionIndex {
     RandomBytes,
     DictionaryReadFuncIndex,
     EnableContractVersion,
+    GenericHash,
 }
 
 impl From<FunctionIndex> for usize {

execution_engine/src/core/resolvers/v1_resolver.rs

@@ -245,6 +245,10 @@ impl ModuleImportResolver for RuntimeModuleImportResolver {
                 Signature::new(&[ValueType::I32; 4][..], Some(ValueType::I32)),
                 FunctionIndex::EnableContractVersion.into(),
             ),
+            "casper_generic_hash" => FuncInstance::alloc_host(
+                Signature::new(&[ValueType::I32; 5][..], Some(ValueType::I32)),
+                FunctionIndex::GenericHash.into(),
+            ),
             _ => {
                 return Err(InterpreterError::Function(format!(
                     "host module doesn't export function with name {}",

execution_engine/src/core/runtime/crypto.rs

@@ -0,0 +1,15 @@
+/// The number of bytes in a Blake3 hash.
+/// NOTE: It does not make sense to use different lengths.
+const BLAKE3_DIGEST_LENGTH: usize = 32;
+
+#[doc(hidden)]
+pub fn blake3<T: AsRef<[u8]>>(data: T) -> [u8; BLAKE3_DIGEST_LENGTH] {
+    let mut result = [0; BLAKE3_DIGEST_LENGTH];
+    let mut hasher = blake3::Hasher::new();
+
+    hasher.update(data.as_ref());
+    let hash = hasher.finalize();
+    let hash_bytes: &[u8; BLAKE3_DIGEST_LENGTH] = hash.as_bytes();
+    result.copy_from_slice(hash_bytes);
+    result
+}

execution_engine/src/core/runtime/externals.rs

@@ -9,13 +9,13 @@ use casper_types::{
     contracts::{ContractPackageStatus, EntryPoints, NamedKeys},
     crypto,
     system::auction::EraInfo,
-    ApiError, ContractHash, ContractPackageHash, ContractVersion, EraId, Gas, Group, Key,
-    StoredValue, URef, U512, UREF_SERIALIZED_LENGTH,
+    ApiError, ContractHash, ContractPackageHash, ContractVersion, EraId, Gas, Group, HashAlgoType,
+    Key, StoredValue, URef, U512, UREF_SERIALIZED_LENGTH,
 };
 
 use super::{args::Args, Error, Runtime};
 use crate::{
-    core::resolvers::v1_function_index::FunctionIndex,
+    core::{resolvers::v1_function_index::FunctionIndex, runtime::crypto as core_crypto},
     shared::host_function_costs::{Cost, HostFunction, DEFAULT_HOST_FUNCTION_NEW_DICTIONARY},
     storage::global_state::StateReader,
 };
@@ -1097,6 +1097,49 @@ where
 
                 Ok(Some(RuntimeValue::I32(api_error::i32_from(result))))
             }
+
+            FunctionIndex::GenericHash => {
+                // args(0) = pointer to input in Wasm memory
+                // args(1) = size of input in Wasm memory
+                // args(2) = integer representation of HashAlgoType enum variant
+                // args(3) = pointer to output pointer in Wasm memory
+                // args(4) = size of output
+                let (in_ptr, in_size, hash_algo_type, out_ptr, out_size) = Args::parse(args)?;
+                self.charge_host_function_call(
+                    &host_function_costs.generic_hash,
+                    [in_ptr, in_size, hash_algo_type, out_ptr, out_size],
+                )?;
+                let hash_algo_type = match HashAlgoType::try_from(hash_algo_type as u8) {
+                    Ok(v) => v,
+                    Err(_e) => {
+                        return Ok(Some(RuntimeValue::I32(api_error::i32_from(Err(
+                            ApiError::InvalidArgument,
+                        )))))
+                    }
+                };
+
+                let digest =
+                    self.checked_memory_slice(in_ptr as usize, in_size as usize, |input| {
+                        match hash_algo_type {
+                            HashAlgoType::Blake2b => crypto::blake2b(input),
+                            HashAlgoType::Blake3 => core_crypto::blake3(input),
+                        }
+                    })?;
+
+                let result = if digest.len() > out_size as usize {
+                    Err(ApiError::BufferTooSmall)
+                } else {
+                    Ok(())
+                };
+                if result.is_err() {
+                    return Ok(Some(RuntimeValue::I32(api_error::i32_from(result))));
+                }
+
+                self.try_get_memory()?
+                    .set(out_ptr, &digest)
+                    .map_err(|error| Error::Interpreter(error.into()))?;
+                Ok(Some(RuntimeValue::I32(0)))
+            }
         }
     }
 }

execution_engine/src/core/runtime/mod.rs

@@ -1,6 +1,7 @@
 //! This module contains executor state of the WASM code.
 mod args;
 mod auction_internal;
+mod crypto;
 mod externals;
 mod handle_payment_internal;
 mod host_function_flag;

execution_engine/src/shared/host_function_costs.rs

@@ -288,6 +288,8 @@ pub struct HostFunctionCosts {
     pub random_bytes: HostFunction<[Cost; 2]>,
     /// Cost of calling the `enable_contract_version` host function.
     pub enable_contract_version: HostFunction<[Cost; 4]>,
+    /// Cost of calling the `generic_hash` host function.
+    pub generic_hash: HostFunction<[Cost; 5]>,
 }
 
 impl Default for HostFunctionCosts {
@@ -420,6 +422,7 @@ impl Default for HostFunctionCosts {
             blake2b: HostFunction::default(),
             random_bytes: HostFunction::default(),
             enable_contract_version: HostFunction::default(),
+            generic_hash: HostFunction::default(),
         }
     }
 }
@@ -471,6 +474,7 @@ impl ToBytes for HostFunctionCosts {
         ret.append(&mut self.blake2b.to_bytes()?);
         ret.append(&mut self.random_bytes.to_bytes()?);
         ret.append(&mut self.enable_contract_version.to_bytes()?);
+        ret.append(&mut self.generic_hash.to_bytes()?);
         Ok(ret)
     }
 
@@ -519,6 +523,7 @@ impl ToBytes for HostFunctionCosts {
             + self.blake2b.serialized_length()
             + self.random_bytes.serialized_length()
             + self.enable_contract_version.serialized_length()
+            + self.generic_hash.serialized_length()
     }
 }
 
@@ -568,6 +573,7 @@ impl FromBytes for HostFunctionCosts {
         let (blake2b, rem) = FromBytes::from_bytes(rem)?;
         let (random_bytes, rem) = FromBytes::from_bytes(rem)?;
         let (enable_contract_version, rem) = FromBytes::from_bytes(rem)?;
+        let (generic_hash, rem) = FromBytes::from_bytes(rem)?;
         Ok((
             HostFunctionCosts {
                 read_value,
@@ -614,6 +620,7 @@ impl FromBytes for HostFunctionCosts {
                 blake2b,
                 random_bytes,
                 enable_contract_version,
+                generic_hash,
             },
             rem,
         ))
@@ -667,6 +674,7 @@ impl Distribution<HostFunctionCosts> for Standard {
             blake2b: rng.gen(),
             random_bytes: rng.gen(),
             enable_contract_version: rng.gen(),
+            generic_hash: rng.gen(),
         }
     }
 }
@@ -728,6 +736,7 @@ pub mod gens {
             blake2b in host_function_cost_arb(),
             random_bytes in host_function_cost_arb(),
             enable_contract_version in host_function_cost_arb(),
+            generic_hash in host_function_cost_arb(),
         ) -> HostFunctionCosts {
             HostFunctionCosts {
                 read_value,
@@ -774,6 +783,7 @@ pub mod gens {
                 blake2b,
                 random_bytes,
                 enable_contract_version,
+                generic_hash,
             }
         }
     }

execution_engine_testing/tests/src/test/storage_costs.rs

@@ -139,6 +139,7 @@ static NEW_HOST_FUNCTION_COSTS: Lazy<HostFunctionCosts> = Lazy::new(|| HostFunct
     blake2b: HostFunction::fixed(0),
     random_bytes: HostFunction::fixed(0),
     enable_contract_version: HostFunction::fixed(0),
+    generic_hash: HostFunction::fixed(0),
 });
 static STORAGE_COSTS_ONLY: Lazy<WasmConfig> = Lazy::new(|| {
     WasmConfig::new(

execution_engine_testing/tests/src/test/system_costs.rs

@@ -979,6 +979,7 @@ fn should_verify_wasm_add_bid_wasm_cost_is_not_recursive() {
         blake2b: HostFunction::fixed(0),
         random_bytes: HostFunction::fixed(0),
         enable_contract_version: HostFunction::fixed(0),
+        generic_hash: HostFunction::fixed(0),
     };
 
     let new_wasm_config = WasmConfig::new(

node/src/types/chainspec.rs

@@ -363,6 +363,7 @@ mod tests {
             blake2b: HostFunction::new(133, [0, 1, 2, 3]),
             random_bytes: HostFunction::new(123, [0, 1]),
             enable_contract_version: HostFunction::new(142, [0, 1, 2, 3]),
+            generic_hash: HostFunction::new(152, [0, 1, 2, 3, 4]),
         });
     static EXPECTED_GENESIS_WASM_COSTS: Lazy<WasmConfig> = Lazy::new(|| {
         WasmConfig::new(

resources/local/chainspec.toml.in

@@ -243,6 +243,7 @@ transfer_to_account = { cost = 2_500_000_000, arguments = [0, 0, 0, 0, 0, 0, 0]
 update_associated_key = { cost = 4_200, arguments = [0, 0, 0] }
 write = { cost = 14_000, arguments = [0, 0, 0, 980] }
 dictionary_put = { cost = 9_500, arguments = [0, 1_800, 0, 520] }
+generic_hash = { cost = 200, arguments = [0, 0, 0, 0, 0] }
 
 [system_costs]
 wasmless_transfer_cost = 100_000_000

resources/production/chainspec.toml

@@ -254,6 +254,7 @@ update_associated_key = { cost = 4_200, arguments = [0, 0, 0] }
 write = { cost = 14_000, arguments = [0, 0, 0, 980] }
 dictionary_put = { cost = 9_500, arguments = [0, 1_800, 0, 520] }
 enable_contract_version = { cost = 200, arguments = [0, 0, 0, 0] }
+generic_hash = { cost = 200, arguments = [0, 0, 0, 0, 0] }
 
 [system_costs]
 wasmless_transfer_cost = 100_000_000

resources/test/valid/0_9_0/chainspec.toml

@@ -141,6 +141,7 @@ update_associated_key = { cost = 139, arguments = [0, 1, 2] }
 write = { cost = 140,  arguments = [0, 1, 0, 2] }
 dictionary_put = { cost = 141, arguments = [0, 1, 2, 3] }
 enable_contract_version = { cost = 142, arguments = [0, 1, 2, 3] }
+generic_hash = { cost = 152, arguments = [0, 1, 2, 3, 4] }
 
 [system_costs]
 wasmless_transfer_cost = 100_000_000

resources/test/valid/0_9_0_unordered/chainspec.toml

@@ -139,6 +139,7 @@ update_associated_key = { cost = 139, arguments = [0, 1, 2] }
 write = { cost = 140,  arguments = [0, 1, 0, 2] }
 dictionary_put = { cost = 141, arguments = [0, 1, 2, 3] }
 enable_contract_version = { cost = 142, arguments = [0, 1, 2, 3] }
+generic_hash = { cost = 152, arguments = [0, 1, 2, 3, 4] }
 
 [system_costs]
 wasmless_transfer_cost = 100_000_000

resources/test/valid/1_0_0/chainspec.toml

@@ -142,6 +142,7 @@ update_associated_key = { cost = 139, arguments = [0, 1, 2] }
 write = { cost = 140,  arguments = [0, 1, 0, 2] }
 dictionary_put = { cost = 141, arguments = [0, 1, 2, 3] }
 enable_contract_version = { cost = 142, arguments = [0, 1, 2, 3] }
+generic_hash = { cost = 152, arguments = [0, 1, 2, 3, 4] }
 
 [system_costs]
 wasmless_transfer_cost = 100_000_000

smart_contracts/contract/CHANGELOG.md

@@ -15,6 +15,7 @@ All notable changes to this project will be documented in this file.  The format
 
 ### Added
 * Add `storage::enable_contract_version` for enabling a specific version of a contract.
+* Add `crypto::generic_hash` with blake2b and blake3 support.
 
 
 

smart_contracts/contract/src/contract_api/crypto.rs

@@ -0,0 +1,22 @@
+//! Functions with cryptographic utils.
+
+use casper_types::{api_error, HashAlgoType, BLAKE2B_DIGEST_LENGTH};
+
+use crate::{ext_ffi, unwrap_or_revert::UnwrapOrRevert};
+
+/// Computes digest hash, using provided algorithm type.
+pub fn generic_hash<T: AsRef<[u8]>>(input: T, algo: HashAlgoType) -> [u8; 32] {
+    let mut ret = [0; 32];
+
+    let result = unsafe {
+        ext_ffi::casper_generic_hash(
+            input.as_ref().as_ptr(),
+            input.as_ref().len(),
+            algo as u8,
+            ret.as_mut_ptr(),
+            BLAKE2B_DIGEST_LENGTH,
+        )
+    };
+    api_error::result_from(result).unwrap_or_revert();
+    ret
+}

smart_contracts/contract/src/contract_api/mod.rs

@@ -1,6 +1,7 @@
 //! Contains support for writing smart contracts.
 
 pub mod account;
+pub mod crypto;
 pub mod runtime;
 pub mod storage;
 pub mod system;

smart_contracts/contract/src/ext_ffi.rs

@@ -805,4 +805,20 @@ extern "C" {
         contract_hash_ptr: *const u8,
         contract_hash_size: usize,
     ) -> i32;
+    /// Computes digest hash, using provided algorithm type.
+    ///
+    /// # Arguments
+    ///
+    /// * `in_ptr` - pointer to the location where argument bytes will be copied from the host side
+    /// * `in_size` - size of output pointer
+    /// * `hash_algo_type` - integer representation of HashAlgoType enum variant
+    /// * `out_ptr` - pointer to the location where argument bytes will be copied to the host side
+    /// * `out_size` - size of output pointer
+    pub fn casper_generic_hash(
+        in_ptr: *const u8,
+        in_size: usize,
+        hash_algo_type: u8,
+        out_ptr: *const u8,
+        out_size: usize,
+    ) -> i32;
 }