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

@@ -25,7 +25,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_operation, Amount, ApplicationId, WithContractAbi},
     Contract, ContractRuntime,
 };
 
@@ -56,13 +56,15 @@ impl Contract for CallCounterContract {
         match operation {
             CallCounterOperation::Increment(increment) => {
                 let operation = incrementCall { input: increment };
-                let operation = operation.abi_encode();
+                let operation =
+                    get_evm_operation(Amount::ZERO, operation.abi_encode()).expect("A mutation");
                 self.process_operation(operation)
             }
             CallCounterOperation::TestCallAddress => {
                 let remote_address = address!("0000000000000000000000000000000000000000");
                 let operation = call_from_wasmCall { remote_address };
-                let operation = operation.abi_encode();
+                let operation =
+                    get_evm_operation(Amount::ZERO, operation.abi_encode()).expect("A mutation");
                 self.process_operation(operation)
             }
         }

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

@@ -88,6 +88,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,
@@ -1606,6 +1625,8 @@ mod metrics {
 mod tests {
     use std::str::FromStr;
 
+    use alloy_primitives::U256;
+
     use super::{Amount, BlobContent};
     use crate::identifiers::BlobType;
 
@@ -1665,4 +1686,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

@@ -79,6 +79,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 {
@@ -416,7 +424,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)
+        }
     }
 }
 
@@ -960,6 +973,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 From<Address> for ApplicationId {
     fn from(address: Address) -> ApplicationId {
@@ -985,18 +1006,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)]
@@ -1261,4 +1270,18 @@ mod tests {
         let stream_id2 = StreamId::from_str(&format!("{stream_id1}")).unwrap();
         assert_eq!(stream_id1, stream_id2);
     }
+
+    #[cfg(with_revm)]
+    #[test]
+    fn test_address_account_owner() {
+        use alloy_primitives::Address;
+        let mut vec = Vec::new();
+        for i in 0..20 {
+            vec.push(i as u8);
+        }
+        let address1 = Address::from_slice(&vec);
+        let account_owner = AccountOwner::from(address1);
+        let address2 = account_owner.to_evm_address().unwrap();
+        assert_eq!(address1, address2);
+    }
 }

linera-base/src/identifiers.rs

@@ -63,5 +63,34 @@ pub enum EvmQuery {
     /// A read-only query.
     Query(Vec<u8>),
     /// A request to schedule an operation that can mutate the application state.
-    Mutation(Vec<u8>),
+    Operation(Vec<u8>),
+}
+
+/// An EVM operation containing a value and argument data.
+#[derive(Debug, Default, Serialize, Deserialize)]
+pub struct EvmOperation {
+    /// The amount being transferred.
+    pub value: alloy_primitives::U256,
+    /// The encoded argument data.
+    pub argument: Vec<u8>,
+}
+
+/// Creates an operation from value and argument data.
+pub fn get_evm_operation(
+    amount: crate::data_types::Amount,
+    argument: Vec<u8>,
+) -> Result<Vec<u8>, bcs::Error> {
+    let value = amount.into();
+    let evm_operation = EvmOperation { value, argument };
+    bcs::to_bytes(&evm_operation)
+}
+
+/// 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: alloy_primitives::U256,
+    /// The input to the `fn instantiate` of the EVM smart contract.
+    pub argument: Vec<u8>,
 }