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

@@ -20,7 +20,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::{Amount, ApplicationId, EvmOperation, 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 = EvmOperation::new(Amount::ZERO, operation.abi_encode());
+                let operation = operation.to_bytes().unwrap();
                 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 = EvmOperation::new(Amount::ZERO, operation.abi_encode());
+                let operation = operation.to_bytes().unwrap();
                 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,
@@ -1617,6 +1636,8 @@ mod metrics {
 mod tests {
     use std::str::FromStr;
 
+    use alloy_primitives::U256;
+
     use super::{Amount, BlobContent};
     use crate::identifiers::BlobType;
 
@@ -1676,4 +1697,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

@@ -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,
@@ -63,7 +65,43 @@ 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>),
     /// A request to schedule operations that can mutate the application state.
-    Mutations(Vec<Vec<u8>>),
+    Operations(Vec<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>,
+}
+
+impl EvmOperation {
+    pub fn new(amount: Amount, argument: Vec<u8>) -> Self {
+        Self {
+            value: amount.into(),
+            argument,
+        }
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, bcs::Error> {
+        bcs::to_bytes(&self)
+    }
+
+    pub fn to_evm_query(&self) -> Result<EvmQuery, bcs::Error> {
+        Ok(EvmQuery::Operation(self.to_bytes()?))
+    }
+}
+
+/// 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>,
 }