Introduce the management of balances within Ethereum contracts.

Author: MathieuDutSik

Cargo.toml

@@ -73,7 +73,7 @@ edition = "2021"
 
 [workspace.dependencies]
 alloy = { version = "1.0.5", default-features = false }
-alloy-primitives = { version = "1.1.0", default-features = false, features = [
+alloy-primitives = { version = "1.3.0", default-features = false, features = [
     "serde",
     "k256",
 ] }

examples/Cargo.lock

@@ -24,7 +24,7 @@ members = [
 ]
 
 [workspace.dependencies]
-alloy-primitives = { version = "1.0.0", default-features = false }
+alloy-primitives = { version = "1.3.0", default-features = false }
 alloy-sol-types = { version = "1.0.0", default-features = false }
 anyhow = "1.0.80"
 assert_matches = "1.5.0"

examples/Cargo.toml

@@ -8,7 +8,7 @@ use alloy_sol_types::{sol, SolCall};
 use call_evm_counter::{CallCounterAbi, CallCounterOperation};
 use linera_sdk::{
     abis::evm::EvmAbi,
-    linera_base_types::{ApplicationId, WithContractAbi},
+    linera_base_types::{get_evm_mutation, Amount, ApplicationId, WithContractAbi},
     Contract, ContractRuntime,
 };
 
@@ -55,15 +55,17 @@ impl Contract for CallCounterContract {
         }
         match operation {
             CallCounterOperation::Increment(increment) => {
-                let operation = incrementCall { input: increment };
-                let operation = operation.abi_encode();
-                self.process_operation(operation)
+                let mutation = incrementCall { input: increment };
+                let mutation =
+                    get_evm_mutation(Amount::ZERO, mutation.abi_encode()).expect("A mutation");
+                self.process_operation(mutation)
             }
             CallCounterOperation::TestCallAddress => {
                 let remote_address = address!("0000000000000000000000000000000000000000");
-                let operation = call_from_wasmCall { remote_address };
-                let operation = operation.abi_encode();
-                self.process_operation(operation)
+                let mutation = call_from_wasmCall { remote_address };
+                let mutation =
+                    get_evm_mutation(Amount::ZERO, mutation.abi_encode()).expect("A mutation");
+                self.process_operation(mutation)
             }
         }
     }

examples/call-evm-counter/src/contract.rs

@@ -87,6 +87,25 @@ impl From<Amount> for U256 {
     }
 }
 
+/// 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 value = u128::try_from(&value).map_err(|_| AmountConversionError(value))?;
+        Ok(Amount(value))
+    }
+}
+
 /// A block height to identify blocks in a chain.
 #[derive(
     Eq,
@@ -1596,6 +1615,7 @@ mod tests {
 
     use super::{Amount, BlobContent};
     use crate::identifiers::BlobType;
+    use alloy_primitives::U256;
 
     #[test]
     fn display_amount() {
@@ -1653,4 +1673,12 @@ mod tests {
         assert_eq!(hash1, hash2, "Hashes should be equal for same content");
         assert_eq!(blob1.bytes(), blob2.bytes(), "Byte content should be equal");
     }
+
+    #[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/data_types.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 {
@@ -407,7 +415,12 @@ impl GenericApplicationId {
 
 impl<A> From<ApplicationId<A>> for AccountOwner {
     fn from(app_id: ApplicationId<A>) -> Self {
-        AccountOwner::Address32(app_id.application_description_hash)
+        if app_id.is_evm() {
+            let hash_bytes = app_id.application_description_hash.as_bytes();
+            AccountOwner::Address20(hash_bytes[..20].try_into().unwrap())
+        } else {
+            AccountOwner::Address32(app_id.application_description_hash)
+        }
     }
 }
 
@@ -951,6 +964,14 @@ impl<A> ApplicationId<A> {
     }
 }
 
+impl<A> ApplicationId<A> {
+    /// Returns whether the `ApplicationId` is the one of an EVM application.
+    pub fn is_evm(&self) -> bool {
+        let bytes = self.application_description_hash.as_bytes();
+        bytes.0[20..] == [0; 12]
+    }
+}
+
 #[cfg(with_revm)]
 impl<A> ApplicationId<A> {
     /// Converts the `ApplicationId` into an Ethereum Address.
@@ -964,18 +985,6 @@ impl<A> ApplicationId<A> {
     pub fn bytes32(&self) -> B256 {
         *self.application_description_hash.as_bytes()
     }
-
-    /// Returns whether the `ApplicationId` is the one of an EVM application.
-    pub fn is_evm(&self) -> bool {
-        let bytes = self.application_description_hash.as_bytes();
-        let bytes = bytes.0.as_ref();
-        for byte in &bytes[20..] {
-            if byte != &0 {
-                return false;
-            }
-        }
-        true
-    }
 }
 
 #[derive(Serialize, Deserialize)]

linera-base/src/identifiers.rs

@@ -11,6 +11,8 @@ use linera_witty::{WitLoad, WitStore, WitType};
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+use crate::data_types::Amount;
+
 #[derive(
     Clone,
     Copy,
@@ -65,3 +67,32 @@ pub enum EvmQuery {
     /// A request to schedule an operation that can mutate the application state.
     Mutation(Vec<u8>),
 }
+
+/// An EVM mutation containing a value and argument data
+#[derive(Default, Serialize, Deserialize)]
+pub struct EvmMutation {
+    /// The amount being transferred
+    pub value: alloy_primitives::U256,
+    /// The encoded argument data
+    pub argument: Vec<u8>,
+}
+
+/// Creates an internal mutation from value and argument data
+pub fn get_evm_mutation(
+    amount: crate::data_types::Amount,
+    argument: Vec<u8>,
+) -> Result<Vec<u8>, bcs::Error> {
+    let value = amount.into();
+    let evm_mutation = EvmMutation { value, argument };
+    bcs::to_bytes(&evm_mutation)
+}
+
+/// The instantiation argument to EVM smart contracts.
+/// `value` is the amount being transferred.
+#[derive(Default, Serialize, Deserialize)]
+pub struct EvmInstantiation {
+    /// The initial value put in the instantiation of the contract.
+    pub value: Amount,
+    /// The input to the `fn instantiate` of the EVM smart contract.
+    pub argument: Vec<u8>,
+}