Add a few corrections and formatting.

Author: MathieuDutSik

linera-base/src/data_types.rs

@@ -88,17 +88,12 @@ impl From<Amount> for U256 {
     }
 }
 
-/// Converting amount from `U256` to Amount can fail since
-/// `Amount` is a `u128`.
+/// Error converting from `U256` to `Amount`.
+/// This can fail since `Amount` is a `u128`.
 #[derive(Error, Debug)]
+#[error("Failed to convert U256 to Amount. {0} has more than 128 bits")]
 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> {

linera-execution/solidity/LineraTypes.yaml

@@ -48,6 +48,12 @@ Amount:
     TUPLEARRAY:
       CONTENT: U8
       SIZE: 32
+Account:
+  STRUCT:
+    - chain_id:
+        TYPENAME: ChainId
+    - owner:
+        TYPENAME: AccountOwner
 AccountOwnerBalanceInner:
   STRUCT:
     - account_owner:
@@ -196,6 +202,13 @@ ContractRuntimePrecompile:
           - query: BYTES
     11:
       ValidationRound: UNIT
+    12:
+      Transfer:
+        STRUCT:
+          - account:
+              TYPENAME: Account
+          - amount:
+              TYPENAME: Amount
 ServiceRuntimePrecompile:
   ENUM:
     0:

linera-execution/src/evm/database.rs

@@ -77,9 +77,9 @@ 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
+    /// The caller to the smart contract.
     pub caller: Address,
-    /// The value of the smart contract
+    /// The value of the smart contract.
     pub value: U256,
     /// The runtime of the contract.
     pub runtime: Arc<Mutex<Runtime>>,
@@ -114,8 +114,8 @@ pub enum KeyCategory {
 }
 
 impl<Runtime: BaseRuntime> DatabaseRuntime<Runtime> {
-    /// Encode the `index` of the EVM storage associated to the smart contract
-    /// in a linera key.
+    /// Encodes the `index` of the EVM storage associated to the smart contract
+    /// in a Linera key.
     fn get_linera_key(key_prefix: &[u8], index: U256) -> Vec<u8> {
         let mut key = key_prefix.to_vec();
         key.extend(index.as_le_slice());
@@ -211,7 +211,7 @@ where
 {
     type Error = ExecutionError;
 
-    /// The `basic_ref` is the function for reading the state of
+    /// The `basic_ref` is the function for reading the state of the application.
     fn basic_ref(&self, address: Address) -> Result<Option<AccountInfo>, ExecutionError> {
         if address == FAUCET_ADDRESS {
             return Ok(Some(AccountInfo {
@@ -435,7 +435,7 @@ where
         let timestamp_linera = runtime.read_system_timestamp()?;
         let timestamp_evm = timestamp_linera.micros() / 1_000_000;
         // The basefee is the minimum feee for executing. We have no such
-        // concept in Linera
+        // concept in Linera.
         let basefee = 0;
         let chain_id = runtime.chain_id()?;
         let entry = format!("{}{}", chain_id, block_height_linera);

linera-execution/src/evm/revm.rs

@@ -18,7 +18,7 @@ use linera_base::{
         Amount, ApplicationDescription, Bytecode, Resources, SendMessageRequest, StreamUpdate,
     },
     ensure,
-    identifiers::{Account, AccountOwner, ApplicationId, ChainId, StreamName},
+    identifiers::{Account, AccountOwner, ApplicationId, ChainId, ModuleId, StreamName},
     vm::{EvmInstantiation, EvmOperation, EvmQuery, VmRuntime},
 };
 use revm::{primitives::Bytes, InspectCommitEvm, InspectEvm, Inspector};
@@ -350,10 +350,6 @@ fn get_precompile_argument<Ctx: ContextTr>(
     context: &mut Ctx,
     inputs: &InputsImpl,
 ) -> Result<Vec<u8>, ExecutionError> {
-    ensure!(
-        inputs.call_value == U256::ZERO,
-        EvmExecutionError::NoTransferInRuntimeCall
-    );
     Ok(get_argument(context, &inputs.input))
 }
 
@@ -764,6 +760,24 @@ impl<'a, Runtime: ContractRuntime> Inspector<Ctx<'a, Runtime>>
 }
 
 impl<Runtime: ContractRuntime> CallInterceptorContract<Runtime> {
+    /// Gets the expected `ApplicationId`.
+    fn get_expected_application_id(runtime: &mut Runtime, module_id: ModuleId) -> Result<ApplicationId, ExecutionError> {
+        let chain_id = runtime.chain_id()?;
+        let block_height = runtime.block_height()?;
+        let application_index = runtime.application_index()?;
+        let parameters = JSON_EMPTY_VECTOR.to_vec(); // No constructor
+        let required_application_ids = Vec::new();
+        let application_description = ApplicationDescription {
+            module_id,
+            creator_chain_id: chain_id,
+            block_height,
+            application_index,
+            parameters: parameters.clone(),
+            required_application_ids,
+        };
+        Ok(ApplicationId::from(&application_description))
+    }
+
     /// The function `fn create` of the inspector trait is called
     /// when a contract is going to be instantiated. Since the
     /// function can have some error case which are not supported
@@ -866,7 +880,10 @@ impl<Runtime: ContractRuntime> CallInterceptorContract<Runtime> {
         } else {
             if inputs.value != U256::ZERO {
                 // decrease the balance of the contract address by the expected amount.
-                // We put the address as
+                // We put the tokens in FAUCET_ADDRESS because we cannot transfer to
+                // a contract that do not yet exist.
+                // It is a common construction. We can see that in ERC20 contract code
+                // for example for burning and minting.
                 Self::revm_transfer(
                     context,
                     self.db.contract_address,
@@ -879,8 +896,6 @@ impl<Runtime: ContractRuntime> CallInterceptorContract<Runtime> {
             let mut runtime = context.db().0.runtime.lock().unwrap();
             let module_id = runtime.publish_module(contract, service, VmRuntime::Evm)?;
             let chain_id = runtime.chain_id()?;
-            let block_height = runtime.block_height()?;
-            let application_index = runtime.application_index()?;
             let application_id = runtime.application_id()?;
             let parameters = JSON_EMPTY_VECTOR.to_vec(); // No constructor
             let evm_call = EvmInstantiation {
@@ -889,15 +904,7 @@ impl<Runtime: ContractRuntime> CallInterceptorContract<Runtime> {
             };
             let argument = serde_json::to_vec(&evm_call)?;
             let required_application_ids = Vec::new();
-            let application_description = ApplicationDescription {
-                module_id,
-                creator_chain_id: chain_id,
-                block_height,
-                application_index,
-                parameters: parameters.clone(),
-                required_application_ids: Vec::new(),
-            };
-            let expected_application_id = ApplicationId::from(&application_description);
+            let expected_application_id = Self::get_expected_application_id(&mut runtime, module_id)?;
             if inputs.value != U256::ZERO {
                 let amount = Amount::try_from(inputs.value).map_err(EvmExecutionError::from)?;
                 let destination = Account {
@@ -969,18 +976,20 @@ impl<Runtime: ContractRuntime> CallInterceptorContract<Runtime> {
             let owner: AccountOwner = inputs.bytecode_address.into();
             if value != U256::ZERO {
                 // In Linera, only non-zero transfers matter
-                let mut runtime = context
-                    .db()
-                    .0
-                    .runtime
-                    .lock()
-                    .expect("The lock should be possible");
-                let amount = Amount::try_from(value).map_err(EvmExecutionError::from)?;
-                let chain_id = runtime.chain_id()?;
-                let destination = Account { chain_id, owner };
-                runtime.transfer(source, destination, amount)?;
+                {
+                    let mut runtime = context
+                        .db()
+                        .0
+                        .runtime
+                        .lock()
+                        .expect("The lock should be possible");
+                    let amount = Amount::try_from(value).map_err(EvmExecutionError::from)?;
+                    let chain_id = runtime.chain_id()?;
+                    let destination = Account { chain_id, owner };
+                    runtime.transfer(source, destination, amount)?;
+                }
+                Self::revm_transfer(context, inputs.caller, inputs.target_address, value)?;
             }
-            Self::revm_transfer(context, inputs.caller, inputs.target_address, value)?;
         }
         // Other smart contracts calls are handled by the runtime
         let target = address_to_user_application_id(inputs.target_address);
@@ -1027,13 +1036,11 @@ impl<Runtime: ContractRuntime> CallInterceptorContract<Runtime> {
         destination: Address,
         value: U256,
     ) -> Result<(), ExecutionError> {
-        if value != U256::ZERO {
-            // In Ethereum, all transfers matter
-            if let Some(error) = context.journal().transfer(source, destination, value)? {
-                let error = format!("{error:?}");
-                let error = EvmExecutionError::TransactError(error);
-                return Err(error.into());
-            }
+        // In Ethereum, all transfers matter
+        if let Some(error) = context.journal().transfer(source, destination, value)? {
+            let error = format!("{error:?}");
+            let error = EvmExecutionError::TransactError(error);
+            return Err(error.into());
         }
         Ok(())
     }

linera-execution/src/lib.rs

@@ -865,7 +865,8 @@ pub trait ContractRuntime: BaseRuntime {
         required_application_ids: Vec<ApplicationId>,
     ) -> Result<ApplicationId, ExecutionError>;
 
-    /// Returns the current application_index.
+    /// Returns the current application index, i.e. the number of new applications
+    /// created so far in this block.
     fn application_index(&mut self) -> Result<u32, ExecutionError>;
 
     /// Creates a new data blob and returns its hash.