Move to the use of DataBlobHash. (#4367)

## Motivation

The `BaseRuntime` and `ContractRuntime` are a little bit disorganised
with their input and output:
* `read_data_blob` / `assert_data_blob_exists` are taking a `CryptoHash`
as input.
* `create_data_blob` is returning a `BlobId`.

## Proposal

The natural type is the `DataBlobHash` that is the natural type for
this.

Previous to this PR, it is in the `linera-sdk`. We are forced to move it
to `linera-base`.

## Test Plan

The CI.

## Release Plan

- Nothing to do / These changes follow the usual release cycle.

## Links

None.

Author: MathieuDutSik

examples/non-fungible/src/contract.rs

@@ -9,9 +9,9 @@ use std::collections::BTreeSet;
 
 use fungible::Account;
 use linera_sdk::{
-    linera_base_types::{AccountOwner, WithContractAbi},
+    linera_base_types::{AccountOwner, DataBlobHash, WithContractAbi},
     views::{RootView, View},
-    Contract, ContractRuntime, DataBlobHash,
+    Contract, ContractRuntime,
 };
 use non_fungible::{Message, Nft, NonFungibleTokenAbi, Operation, TokenId};
 

examples/non-fungible/src/lib.rs

@@ -9,8 +9,10 @@ use async_graphql::{InputObject, Request, Response, SimpleObject};
 use fungible::Account;
 use linera_sdk::{
     graphql::GraphQLMutationRoot,
-    linera_base_types::{AccountOwner, ApplicationId, ChainId, ContractAbi, ServiceAbi},
-    DataBlobHash, ToBcsBytes,
+    linera_base_types::{
+        AccountOwner, ApplicationId, ChainId, ContractAbi, DataBlobHash, ServiceAbi,
+    },
+    ToBcsBytes,
 };
 use serde::{Deserialize, Serialize};
 

examples/non-fungible/src/service.rs

@@ -14,9 +14,9 @@ use async_graphql::{EmptySubscription, Object, Request, Response, Schema};
 use base64::engine::{general_purpose::STANDARD_NO_PAD, Engine as _};
 use fungible::Account;
 use linera_sdk::{
-    linera_base_types::{AccountOwner, WithServiceAbi},
+    linera_base_types::{AccountOwner, DataBlobHash, WithServiceAbi},
     views::View,
-    DataBlobHash, Service, ServiceRuntime,
+    Service, ServiceRuntime,
 };
 use non_fungible::{NftOutput, Operation, TokenId};
 

linera-base/src/identifiers.rs

@@ -308,6 +308,18 @@ impl<'a> Deserialize<'a> for BlobId {
     }
 }
 
+/// Hash of a data blob.
+#[derive(
+    Eq, Hash, PartialEq, Debug, Serialize, Deserialize, Clone, Copy, WitType, WitLoad, WitStore,
+)]
+pub struct DataBlobHash(pub CryptoHash);
+
+impl From<DataBlobHash> for BlobId {
+    fn from(hash: DataBlobHash) -> BlobId {
+        BlobId::new(hash.0, BlobType::Data)
+    }
+}
+
 /// A unique identifier for a user application from a blob.
 #[derive(Debug, WitLoad, WitStore, WitType)]
 #[cfg_attr(with_testing, derive(Default, test_strategy::Arbitrary))]
@@ -1079,6 +1091,7 @@ impl From<ChainDescription> for ChainId {
 }
 
 bcs_scalar!(ApplicationId, "A unique identifier for a user application");
+doc_scalar!(DataBlobHash, "Hash of a Data Blob");
 doc_scalar!(
     GenericApplicationId,
     "A unique identifier for a user application or for the system application"

linera-execution/solidity/Linera.sol

@@ -383,7 +383,8 @@ library Linera {
     function read_data_blob(bytes32 hash) internal returns (bytes memory) {
         address precompile = address(0x0b);
         LineraTypes.CryptoHash memory hash2 = LineraTypes.CryptoHash(hash);
-        LineraTypes.BaseRuntimePrecompile memory base = LineraTypes.BaseRuntimePrecompile_case_read_data_blob(hash2);
+        LineraTypes.DataBlobHash memory hash3 = LineraTypes.DataBlobHash(hash2);
+        LineraTypes.BaseRuntimePrecompile memory base = LineraTypes.BaseRuntimePrecompile_case_read_data_blob(hash3);
         LineraTypes.RuntimePrecompile memory input1 = LineraTypes.RuntimePrecompile_case_base(base);
         bytes memory input2 = LineraTypes.bcs_serialize_RuntimePrecompile(input1);
         (bool success, bytes memory output) = precompile.call(input2);
@@ -394,7 +395,8 @@ library Linera {
     function assert_data_blob_exists(bytes32 hash) internal {
         address precompile = address(0x0b);
         LineraTypes.CryptoHash memory hash2 = LineraTypes.CryptoHash(hash);
-        LineraTypes.BaseRuntimePrecompile memory base = LineraTypes.BaseRuntimePrecompile_case_assert_data_blob_exists(hash2);
+        LineraTypes.DataBlobHash memory hash3 = LineraTypes.DataBlobHash(hash2);
+        LineraTypes.BaseRuntimePrecompile memory base = LineraTypes.BaseRuntimePrecompile_case_assert_data_blob_exists(hash3);
         LineraTypes.RuntimePrecompile memory input1 = LineraTypes.RuntimePrecompile_case_base(base);
         bytes memory input2 = LineraTypes.bcs_serialize_RuntimePrecompile(input1);
         (bool success, bytes memory output) = precompile.call(input2);

linera-execution/solidity/LineraTypes.sol

@@ -266,9 +266,9 @@ library LineraTypes {
         // choice=7 corresponds to ReadBalanceOwners
         // choice=8 corresponds to ChainOwnership
         // choice=9 corresponds to ReadDataBlob
-        CryptoHash read_data_blob;
+        DataBlobHash read_data_blob;
         // choice=10 corresponds to AssertDataBlobExists
-        CryptoHash assert_data_blob_exists;
+        DataBlobHash assert_data_blob_exists;
     }
 
     function BaseRuntimePrecompile_case_chain_id()
@@ -277,8 +277,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(0), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -288,8 +288,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(1), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -299,8 +299,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(2), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -310,8 +310,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(3), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -321,8 +321,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(4), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -331,8 +331,8 @@ library LineraTypes {
         pure
         returns (BaseRuntimePrecompile memory)
     {
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(5), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -342,8 +342,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(6), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -353,8 +353,8 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(7), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -364,28 +364,28 @@ library LineraTypes {
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory read_data_blob;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(8), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
-    function BaseRuntimePrecompile_case_read_data_blob(CryptoHash memory read_data_blob)
+    function BaseRuntimePrecompile_case_read_data_blob(DataBlobHash memory read_data_blob)
         internal
         pure
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory assert_data_blob_exists;
         return BaseRuntimePrecompile(uint8(9), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
-    function BaseRuntimePrecompile_case_assert_data_blob_exists(CryptoHash memory assert_data_blob_exists)
+    function BaseRuntimePrecompile_case_assert_data_blob_exists(DataBlobHash memory assert_data_blob_exists)
         internal
         pure
         returns (BaseRuntimePrecompile memory)
     {
         AccountOwner memory read_owner_balance;
-        CryptoHash memory read_data_blob;
+        DataBlobHash memory read_data_blob;
         return BaseRuntimePrecompile(uint8(10), read_owner_balance, read_data_blob, assert_data_blob_exists);
     }
 
@@ -398,10 +398,10 @@ library LineraTypes {
             return abi.encodePacked(input.choice, bcs_serialize_AccountOwner(input.read_owner_balance));
         }
         if (input.choice == 9) {
-            return abi.encodePacked(input.choice, bcs_serialize_CryptoHash(input.read_data_blob));
+            return abi.encodePacked(input.choice, bcs_serialize_DataBlobHash(input.read_data_blob));
         }
         if (input.choice == 10) {
-            return abi.encodePacked(input.choice, bcs_serialize_CryptoHash(input.assert_data_blob_exists));
+            return abi.encodePacked(input.choice, bcs_serialize_DataBlobHash(input.assert_data_blob_exists));
         }
         return abi.encodePacked(input.choice);
     }
@@ -418,13 +418,13 @@ library LineraTypes {
         if (choice == 5) {
             (new_pos, read_owner_balance) = bcs_deserialize_offset_AccountOwner(new_pos, input);
         }
-        CryptoHash memory read_data_blob;
+        DataBlobHash memory read_data_blob;
         if (choice == 9) {
-            (new_pos, read_data_blob) = bcs_deserialize_offset_CryptoHash(new_pos, input);
+            (new_pos, read_data_blob) = bcs_deserialize_offset_DataBlobHash(new_pos, input);
         }
-        CryptoHash memory assert_data_blob_exists;
+        DataBlobHash memory assert_data_blob_exists;
         if (choice == 10) {
-            (new_pos, assert_data_blob_exists) = bcs_deserialize_offset_CryptoHash(new_pos, input);
+            (new_pos, assert_data_blob_exists) = bcs_deserialize_offset_DataBlobHash(new_pos, input);
         }
         require(choice < 11);
         return (new_pos, BaseRuntimePrecompile(choice, read_owner_balance, read_data_blob, assert_data_blob_exists));
@@ -1160,6 +1160,41 @@ library LineraTypes {
         return value;
     }
 
+    struct DataBlobHash {
+        CryptoHash value;
+    }
+
+    function bcs_serialize_DataBlobHash(DataBlobHash memory input)
+        internal
+        pure
+        returns (bytes memory)
+    {
+        return bcs_serialize_CryptoHash(input.value);
+    }
+
+    function bcs_deserialize_offset_DataBlobHash(uint256 pos, bytes memory input)
+        internal
+        pure
+        returns (uint256, DataBlobHash memory)
+    {
+        uint256 new_pos;
+        CryptoHash memory value;
+        (new_pos, value) = bcs_deserialize_offset_CryptoHash(pos, input);
+        return (new_pos, DataBlobHash(value));
+    }
+
+    function bcs_deserialize_DataBlobHash(bytes memory input)
+        internal
+        pure
+        returns (DataBlobHash memory)
+    {
+        uint256 new_pos;
+        DataBlobHash memory value;
+        (new_pos, value) = bcs_deserialize_offset_DataBlobHash(0, input);
+        require(new_pos == input.length, "incomplete deserialization");
+        return value;
+    }
+
     struct GenericApplicationId {
         uint8 choice;
         // choice=0 corresponds to System

linera-execution/solidity/LineraTypes.yaml

@@ -75,6 +75,9 @@ CryptoHash:
     TUPLEARRAY:
       CONTENT: U8
       SIZE: 32
+DataBlobHash:
+  NEWTYPESTRUCT:
+    TYPENAME: CryptoHash
 BlockHeight:
   NEWTYPESTRUCT: U64
 ChainId:
@@ -126,11 +129,11 @@ BaseRuntimePrecompile:
     9:
       ReadDataBlob:
         NEWTYPE:
-          TYPENAME: CryptoHash
+          TYPENAME: DataBlobHash
     10:
       AssertDataBlobExists:
         NEWTYPE:
-          TYPENAME: CryptoHash
+          TYPENAME: DataBlobHash
 ContractRuntimePrecompile:
   ENUM:
     0:

linera-execution/src/evm/revm.rs

@@ -37,9 +37,9 @@ use crate::{
         data_types::AmountU256,
         database::{DatabaseRuntime, StorageStats, EVM_SERVICE_GAS_LIMIT},
     },
-    BaseRuntime, ContractRuntime, ContractSyncRuntimeHandle, EvmExecutionError, EvmRuntime,
-    ExecutionError, ServiceRuntime, ServiceSyncRuntimeHandle, UserContract, UserContractInstance,
-    UserContractModule, UserService, UserServiceInstance, UserServiceModule,
+    BaseRuntime, ContractRuntime, ContractSyncRuntimeHandle, DataBlobHash, EvmExecutionError,
+    EvmRuntime, ExecutionError, ServiceRuntime, ServiceSyncRuntimeHandle, UserContract,
+    UserContractInstance, UserContractModule, UserService, UserServiceInstance, UserServiceModule,
 };
 
 /// This is the selector of the `execute_message` that should be called
@@ -495,9 +495,9 @@ enum BaseRuntimePrecompile {
     /// Calling `chain_ownership` of `BaseRuntime`
     ChainOwnership,
     /// Calling `read_data_blob` of `BaseRuntime`
-    ReadDataBlob(CryptoHash),
+    ReadDataBlob(DataBlobHash),
     /// Calling `assert_data_blob_exists` of `BaseRuntime`
-    AssertDataBlobExists(CryptoHash),
+    AssertDataBlobExists(DataBlobHash),
 }
 
 /// Some functionalities from the ContractRuntime not in BaseRuntime
@@ -648,9 +648,9 @@ fn base_runtime_call<Runtime: BaseRuntime>(
             let chain_ownership = runtime.chain_ownership()?;
             Ok(bcs::to_bytes(&chain_ownership)?)
         }
-        BaseRuntimePrecompile::ReadDataBlob(hash) => runtime.read_data_blob(&hash),
+        BaseRuntimePrecompile::ReadDataBlob(hash) => runtime.read_data_blob(hash),
         BaseRuntimePrecompile::AssertDataBlobExists(hash) => {
-            runtime.assert_data_blob_exists(&hash)?;
+            runtime.assert_data_blob_exists(hash)?;
             Ok(Vec::new())
         }
     }

linera-execution/src/lib.rs

@@ -41,7 +41,7 @@ use linera_base::{
     },
     doc_scalar, hex_debug, http,
     identifiers::{
-        Account, AccountOwner, ApplicationId, BlobId, BlobType, ChainId, EventId,
+        Account, AccountOwner, ApplicationId, BlobId, BlobType, ChainId, DataBlobHash, EventId,
         GenericApplicationId, ModuleId, StreamName,
     },
     ownership::ChainOwnership,
@@ -668,10 +668,10 @@ pub trait BaseRuntime {
     fn assert_before(&mut self, timestamp: Timestamp) -> Result<(), ExecutionError>;
 
     /// Reads a data blob specified by a given hash.
-    fn read_data_blob(&mut self, hash: &CryptoHash) -> Result<Vec<u8>, ExecutionError>;
+    fn read_data_blob(&mut self, hash: DataBlobHash) -> Result<Vec<u8>, ExecutionError>;
 
     /// Asserts the existence of a data blob with the given hash.
-    fn assert_data_blob_exists(&mut self, hash: &CryptoHash) -> Result<(), ExecutionError>;
+    fn assert_data_blob_exists(&mut self, hash: DataBlobHash) -> Result<(), ExecutionError>;
 }
 
 pub trait ServiceRuntime: BaseRuntime {
@@ -803,8 +803,8 @@ pub trait ContractRuntime: BaseRuntime {
         required_application_ids: Vec<ApplicationId>,
     ) -> Result<ApplicationId, ExecutionError>;
 
-    /// Creates a new data blob and returns its ID.
-    fn create_data_blob(&mut self, bytes: Vec<u8>) -> Result<BlobId, ExecutionError>;
+    /// Creates a new data blob and returns its hash.
+    fn create_data_blob(&mut self, bytes: Vec<u8>) -> Result<DataBlobHash, ExecutionError>;
 
     /// Publishes a module with contract and service bytecode and returns the module ID.
     fn publish_module(