Introduce the management of balances within Ethereum contracts.

Author: MathieuDutSik

linera-base/src/data_types.rs

@@ -17,6 +17,7 @@ use std::{
     str::FromStr,
 };
 
+use alloy_primitives::U256;
 use async_graphql::{InputObject, SimpleObject};
 use custom_debug_derive::Debug;
 use linera_witty::{WitLoad, WitStore, WitType};
@@ -79,6 +80,38 @@ impl<'de> Deserialize<'de> for Amount {
     }
 }
 
+impl From<Amount> for U256 {
+    fn from(amount: Amount) -> U256 {
+        U256::from(amount.0)
+    }
+}
+
+/// Converting amount from U256 to Amount can fail since
+/// Amount is a u128.
+#[derive(Error, Debug)]
+pub struct AmountConversionError(U256);
+
+impl fmt::Display for AmountConversionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Amount conversion error for {}", self.0)
+    }
+}
+
+impl TryFrom<U256> for Amount {
+    type Error = AmountConversionError;
+    fn try_from(value: U256) -> Result<Amount, Self::Error> {
+        let vec: [u8; 32] = value.to_be_bytes();
+        for val in vec.iter().take(16) {
+            if *val != 0 {
+                return Err(AmountConversionError(value));
+            }
+        }
+        let value: [u8; 16] = vec[16..].try_into().expect("value should be of length 16");
+        let value = u128::from_be_bytes(value);
+        Ok(Amount(value))
+    }
+}
+
 /// A block height to identify blocks in a chain.
 #[derive(
     Eq,
@@ -1572,6 +1605,8 @@ mod metrics {
 mod tests {
     use std::str::FromStr;
 
+    use alloy_primitives::U256;
+
     use super::Amount;
 
     #[test]
@@ -1599,4 +1634,12 @@ mod tests {
             format!("{:~^+9.1}", Amount::from_str("12.34").unwrap())
         );
     }
+
+    #[test]
+    fn test_conversion_amount_u256() {
+        let value_amount = Amount::from_tokens(15656565652209004332);
+        let value_u256: U256 = value_amount.into();
+        let value_amount_rev = Amount::try_from(value_u256).expect("Failed conversion");
+        assert_eq!(value_amount, value_amount_rev);
+    }
 }

linera-base/src/identifiers.rs

@@ -70,6 +70,14 @@ impl AccountOwner {
     }
 }
 
+#[cfg(with_revm)]
+impl From<Address> for AccountOwner {
+    fn from(address: Address) -> Self {
+        let address = address.into_array();
+        AccountOwner::Address20(address)
+    }
+}
+
 #[cfg(with_testing)]
 impl From<CryptoHash> for AccountOwner {
     fn from(address: CryptoHash) -> Self {

linera-execution/src/evm/database.rs

@@ -9,7 +9,10 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use linera_base::vm::VmRuntime;
+use linera_base::{
+    identifiers::{Account, AccountOwner},
+    vm::VmRuntime,
+};
 use linera_views::common::from_bytes_option;
 use revm::{primitives::keccak256, Database, DatabaseCommit, DatabaseRef};
 use revm_context::BlockEnv;
@@ -18,7 +21,11 @@ use revm_database::{AccountState, DBErrorMarker};
 use revm_primitives::{address, Address, B256, U256};
 use revm_state::{AccountInfo, Bytecode, EvmState};
 
-use crate::{ApplicationId, BaseRuntime, Batch, ContractRuntime, ExecutionError, ServiceRuntime};
+use crate::{
+    evm::{read_amount, inputs::ZERO_ADDRESS},
+    BaseRuntime, Batch, ContractRuntime, EvmExecutionError, ExecutionError,
+    ServiceRuntime,
+};
 
 // The runtime costs are not available in service operations.
 // We need to set a limit to gas usage in order to avoid blocking
@@ -74,19 +81,28 @@ pub(crate) struct DatabaseRuntime<Runtime> {
     /// This is the EVM address of the contract.
     /// At the creation, it is set to `Address::ZERO` and then later set to the correct value.
     pub contract_address: Address,
+    /// The caller to the smart contract
+    pub caller: Address,
+    /// The value of the smart contract
+    pub value: U256,
     /// The runtime of the contract.
     pub runtime: Arc<Mutex<Runtime>>,
     /// The uncommitted changes to the contract.
     pub changes: EvmState,
+    /// The error that can occur during runtime.
+    pub error: Arc<Mutex<Option<String>>>,
 }
 
 impl<Runtime> Clone for DatabaseRuntime<Runtime> {
     fn clone(&self) -> Self {
         Self {
             storage_stats: self.storage_stats.clone(),
             contract_address: self.contract_address,
+            caller: self.caller,
+            value: self.value,
             runtime: self.runtime.clone(),
             changes: self.changes.clone(),
+            error: self.error.clone(),
         }
     }
 }
@@ -98,23 +114,17 @@ pub enum KeyCategory {
     Storage,
 }
 
-fn application_id_to_address(application_id: ApplicationId) -> Address {
-    let application_id: [u64; 4] = <[u64; 4]>::from(application_id.application_description_hash);
-    let application_id: [u8; 32] = linera_base::crypto::u64_array_to_be_bytes(application_id);
-    Address::from_slice(&application_id[0..20])
-}
-
 impl<Runtime: BaseRuntime> DatabaseRuntime<Runtime> {
     /// Encode the `index` of the EVM storage associated to the smart contract
     /// in a linera key.
-    fn get_linera_key(key_prefix: &[u8], index: U256) -> Result<Vec<u8>, ExecutionError> {
+    fn get_linera_key(key_prefix: &[u8], index: U256) -> Vec<u8> {
         let mut key = key_prefix.to_vec();
-        bcs::serialize_into(&mut key, &index)?;
-        Ok(key)
+        key.extend(index.as_le_slice());
+        key
     }
 
     /// Returns the tag associated to the contract.
-    fn get_address_key(&self, prefix: u8, address: Address) -> Vec<u8> {
+    fn get_address_key(prefix: u8, address: Address) -> Vec<u8> {
         let mut key = vec![prefix];
         key.extend(address);
         key
@@ -129,8 +139,11 @@ impl<Runtime: BaseRuntime> DatabaseRuntime<Runtime> {
         Self {
             storage_stats: Arc::new(Mutex::new(storage_stats)),
             contract_address: Address::ZERO,
+            caller: Address::ZERO,
+            value: U256::ZERO,
             runtime: Arc::new(Mutex::new(runtime)),
             changes: HashMap::new(),
+            error: Arc::new(Mutex::new(None)),
         }
     }
 
@@ -144,6 +157,23 @@ impl<Runtime: BaseRuntime> DatabaseRuntime<Runtime> {
         *storage_stats_read = StorageStats::default();
         storage_stats
     }
+
+    /// Insert error into the database
+    pub fn insert_error(&self, exec_error: ExecutionError) {
+        let mut error = self.error.lock().expect("The lock should be possible");
+        *error = Some(format!("Runtime error {:?}", exec_error));
+    }
+
+    /// Process the error.
+    pub fn process_any_error(&self) -> Result<(), EvmExecutionError> {
+        let error = self.error.lock().expect("The lock should be possible");
+        if error.is_some() {
+            if let Some(error) = error.clone() {
+                return Err(EvmExecutionError::RuntimeError(error));
+            }
+        }
+        Ok(())
+    }
 }
 
 impl DBErrorMarker for ExecutionError {}
@@ -192,11 +222,42 @@ where
             return Ok(Some(account.info.clone()));
         }
         let mut runtime = self.runtime.lock().expect("The lock should be possible");
-        let key_info = self.get_address_key(KeyCategory::AccountInfo as u8, address);
+        let account_owner = if address == self.contract_address {
+            let application_id = runtime.application_id()?;
+            application_id.into()
+        } else {
+            address.into()
+        };
+        // The balances being used are the ones of Linera. So, we need to
+        // access them at first.
+        let balance = runtime.read_owner_balance(account_owner)?;
+
+        let balance: U256 = balance.into();
+        let key_info = Self::get_address_key(KeyCategory::AccountInfo as u8, address);
         let promise = runtime.read_value_bytes_new(key_info)?;
         let result = runtime.read_value_bytes_wait(&promise)?;
-        let account_info = from_bytes_option::<AccountInfo>(&result)?;
-        Ok(account_info)
+        let mut account_info = match result {
+            None => AccountInfo::default(),
+            Some(bytes) => bcs::from_bytes(&bytes)?,
+        };
+        // The funds have been immediately deposited in deposit_funds.
+        // The EVM will do the same before even the execution of
+        // the constructor or function.
+        // Therefore, we need to adjust the values.
+        // This will ensure that at any time the balances in EVM
+        // and Linera are exactly matching during the execution.
+        let start_balance = if self.caller == address {
+            balance + self.value
+        } else if self.contract_address == address {
+            balance - self.value
+        } else {
+            balance
+        };
+        account_info.balance = start_balance;
+        // The balance is non-zero. Therefore, the account exists.đ
+        // However, the state is None. Therefore, we need to create
+        // a default account first.
+        Ok(Some(account_info))
     }
 
     fn code_by_hash_ref(&self, _code_hash: B256) -> Result<Bytecode, ExecutionError> {
@@ -211,8 +272,8 @@ where
                 Some(slot) => slot.present_value(),
             });
         }
-        let key_prefix = self.get_address_key(KeyCategory::Storage as u8, address);
-        let key = Self::get_linera_key(&key_prefix, index)?;
+        let key_prefix = Self::get_address_key(KeyCategory::Storage as u8, address);
+        let key = Self::get_linera_key(&key_prefix, index);
         {
             let mut storage_stats = self
                 .storage_stats
@@ -249,9 +310,9 @@ where
             if !account.is_touched() {
                 continue;
             }
-            let key_prefix = self.get_address_key(KeyCategory::Storage as u8, *address);
-            let key_info = self.get_address_key(KeyCategory::AccountInfo as u8, *address);
-            let key_state = self.get_address_key(KeyCategory::AccountState as u8, *address);
+            let key_prefix = Self::get_address_key(KeyCategory::Storage as u8, *address);
+            let key_info = Self::get_address_key(KeyCategory::AccountInfo as u8, *address);
+            let key_state = Self::get_address_key(KeyCategory::AccountState as u8, *address);
             if account.is_selfdestructed() {
                 batch.delete_key_prefix(key_prefix);
                 batch.put_key_value(key_info, &AccountInfo::default())?;
@@ -278,7 +339,7 @@ where
                     if value.present_value() == value.original_value() {
                         storage_stats.key_no_operation += 1;
                     } else {
-                        let key = Self::get_linera_key(&key_prefix, *index)?;
+                        let key = Self::get_linera_key(&key_prefix, *index);
                         if value.original_value() == U256::ZERO {
                             batch.put_key_value(key, &value.present_value())?;
                             storage_stats.key_set += 1;
@@ -317,7 +378,7 @@ where
     pub fn set_contract_address(&mut self) -> Result<(), ExecutionError> {
         let mut runtime = self.runtime.lock().expect("The lock should be possible");
         let application_id = runtime.application_id()?;
-        self.contract_address = application_id_to_address(application_id);
+        self.contract_address = application_id.evm_address();
         Ok(())
     }
 
@@ -326,7 +387,7 @@ where
     pub fn is_initialized(&self) -> Result<bool, ExecutionError> {
         let mut runtime = self.runtime.lock().expect("The lock should be possible");
         let evm_address = runtime.application_id()?.evm_address();
-        let key_info = self.get_address_key(KeyCategory::AccountInfo as u8, evm_address);
+        let key_info = Self::get_address_key(KeyCategory::AccountInfo as u8, evm_address);
         let promise = runtime.contains_key_new(key_info)?;
         let result = runtime.contains_key_wait(&promise)?;
         Ok(result)
@@ -394,6 +455,25 @@ where
         block_env.gas_limit = gas_limit;
         Ok(block_env)
     }
+
+    pub fn deposit_funds(&self) -> Result<(), ExecutionError> {
+        if self.value != U256::ZERO {
+            let mut runtime = self.runtime.lock().expect("The lock should be possible");
+            if self.caller == ZERO_ADDRESS {
+                let error = EvmExecutionError::UnknownSigner;
+                return Err(error.into());
+            }
+            let source: AccountOwner = self.caller.into();
+            let chain_id = runtime.chain_id()?;
+            let application_id = runtime.application_id()?;
+            let owner: AccountOwner = application_id.into();
+            let destination = Account { chain_id, owner };
+            let amount = read_amount(self.value)?;
+
+            runtime.transfer(source, destination, amount)?;
+        }
+        Ok(())
+    }
 }
 
 impl<Runtime> DatabaseRuntime<Runtime>