Cross-VM payable calls & XVM tests

chain-extensions/types/xvm/src/lib.rs

@@ -18,7 +18,7 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use astar_primitives::xvm::CallError;
+use astar_primitives::{xvm::CallError, Balance};
 use parity_scale_codec::{Decode, Encode};
 use sp_std::vec::Vec;
 
@@ -41,8 +41,7 @@ impl From<CallError> for XvmExecutionResult {
             SameVmCallNotAllowed => 2,
             InvalidTarget => 3,
             InputTooLarge => 4,
-            BadOrigin => 5,
-            ExecutionFailed(_) => 6,
+            ExecutionFailed(_) => 5,
         };
         Self::Err(error_code)
     }
@@ -65,4 +64,6 @@ pub struct XvmCallArgs {
     pub to: Vec<u8>,
     /// Encoded call params
     pub input: Vec<u8>,
+    /// Value to transfer
+    pub value: Balance,
 }

chain-extensions/xvm/src/lib.rs

@@ -18,19 +18,15 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
-use astar_primitives::xvm::{CallError, Context, VmId, XvmCall};
+use astar_primitives::xvm::{Context, VmId, XvmCall};
 use frame_support::dispatch::Encode;
-use pallet_contracts::{
-    chain_extension::{ChainExtension, Environment, Ext, InitState, RetVal},
-    Origin,
-};
+use pallet_contracts::chain_extension::{ChainExtension, Environment, Ext, InitState, RetVal};
 use sp_runtime::DispatchError;
 use sp_std::marker::PhantomData;
 use xvm_chain_extension_types::{XvmCallArgs, XvmExecutionResult};
 
 enum XvmFuncId {
     Call,
-    // TODO: expand with other calls too
 }
 
 impl TryFrom<u16> for XvmFuncId {
@@ -76,28 +72,22 @@ where
                 // So we will charge a 32KB dummy value as a temporary replacement.
                 let charged_weight = env.charge_weight(weight_limit.set_proof_size(32 * 1024))?;
 
-                let caller = match env.ext().caller().clone() {
-                    Origin::Signed(address) => address,
-                    Origin::Root => {
-                        log::trace!(
-                            target: "xvm-extension::xvm_call",
-                            "root origin not supported"
-                        );
-                        return Ok(RetVal::Converging(
-                            XvmExecutionResult::from(CallError::BadOrigin).into(),
-                        ));
-                    }
-                };
+                let XvmCallArgs {
+                    vm_id,
+                    to,
+                    input,
+                    value,
+                } = env.read_as_unbounded(env.in_len())?;
 
-                let XvmCallArgs { vm_id, to, input } = env.read_as_unbounded(env.in_len())?;
+                // Similar to EVM behavior, the `source` should be (limited to) the
+                // contract address. Otherwise contracts would be able to do arbitrary
+                // things on behalf of the caller via XVM.
+                let source = env.ext().address();
 
-                let _origin_address = env.ext().address().clone();
-                let _value = env.ext().value_transferred();
                 let xvm_context = Context {
                     source_vm_id: VmId::Wasm,
                     weight_limit,
                 };
-
                 let vm_id = {
                     match TryInto::<VmId>::try_into(vm_id) {
                         Ok(id) => id,
@@ -108,7 +98,7 @@ where
                         }
                     }
                 };
-                let call_result = XC::call(xvm_context, vm_id, caller, to, input);
+                let call_result = XC::call(xvm_context, vm_id, source.clone(), to, input, value);
 
                 let actual_weight = match call_result {
                     Ok(ref info) => info.used_weight,

pallets/ethereum-checked/src/benchmarking.rs

@@ -18,7 +18,7 @@
 
 use super::*;
 
-use astar_primitives::ethereum_checked::MAX_ETHEREUM_TX_INPUT_SIZE;
+use astar_primitives::ethereum_checked::EthereumTxInput;
 use frame_benchmarking::v2::*;
 
 #[benchmarks]
@@ -31,7 +31,7 @@ mod benchmarks {
         let target =
             H160::from_slice(&hex::decode("dfb975d018f03994a3b943808e3aa0964bd78463").unwrap());
         // Calling `store(3)`
-        let input = BoundedVec::<u8, ConstU32<MAX_ETHEREUM_TX_INPUT_SIZE>>::try_from(
+        let input = EthereumTxInput::try_from(
             hex::decode("6057361d0000000000000000000000000000000000000000000000000000000000000003")
                 .unwrap(),
         )

pallets/ethereum-checked/src/mock.rs

@@ -294,7 +294,7 @@ impl ExtBuilder {
             assert_ok!(Evm::create2(
                 RuntimeOrigin::root(),
                 ALICE_H160,
-                hex::decode(STORAGE_CONTRACT).unwrap(),
+                hex::decode(STORAGE_CONTRACT).expect("invalid code hex"),
                 H256::zero(),
                 U256::zero(),
                 1_000_000,

pallets/ethereum-checked/src/tests.rs

@@ -21,14 +21,14 @@
 use super::*;
 use mock::*;
 
-use astar_primitives::ethereum_checked::MAX_ETHEREUM_TX_INPUT_SIZE;
+use astar_primitives::ethereum_checked::EthereumTxInput;
 use ethereum::{ReceiptV3, TransactionV2 as Transaction};
-use frame_support::{assert_noop, assert_ok, traits::ConstU32};
+use frame_support::{assert_noop, assert_ok};
 use sp_runtime::DispatchError;
 
-fn bounded_input(data: &'static str) -> BoundedVec<u8, ConstU32<MAX_ETHEREUM_TX_INPUT_SIZE>> {
-    BoundedVec::<u8, ConstU32<MAX_ETHEREUM_TX_INPUT_SIZE>>::try_from(hex::decode(data).unwrap())
-        .unwrap()
+fn bounded_input(data: &'static str) -> EthereumTxInput {
+    EthereumTxInput::try_from(hex::decode(data).expect("invalid input hex"))
+        .expect("input too large")
 }
 
 #[test]

pallets/xvm/Cargo.toml

@@ -33,6 +33,7 @@ astar-primitives = { workspace = true }
 
 [dev-dependencies]
 fp-evm = { workspace = true }
+hex = { workspace = true }
 pallet-balances = { workspace = true, features = ["std"] }
 pallet-insecure-randomness-collective-flip = { workspace = true, features = ["std"] }
 pallet-timestamp = { workspace = true, features = ["std"] }

pallets/xvm/src/benchmarking.rs

@@ -24,7 +24,11 @@ use parity_scale_codec::Encode;
 use sp_core::H160;
 use sp_runtime::MultiAddress;
 
-#[benchmarks]
+use astar_primitives::Balance;
+
+#[benchmarks(
+    where <T as pallet_contracts::Config>::Currency: Currency<T::AccountId, Balance = Balance>,
+)]
 mod benchmarks {
     use super::*;
 
@@ -38,10 +42,12 @@ mod benchmarks {
         let source = whitelisted_caller();
         let target = H160::repeat_byte(1).encode();
         let input = vec![1, 2, 3];
+        let value = 1_000_000u128;
 
         #[block]
         {
-            Pallet::<T>::call_without_execution(context, vm_id, source, target, input).unwrap();
+            Pallet::<T>::call_without_execution(context, vm_id, source, target, input, value)
+                .unwrap();
         }
     }
 
@@ -55,10 +61,12 @@ mod benchmarks {
         let source = whitelisted_caller();
         let target = MultiAddress::<T::AccountId, ()>::Id(whitelisted_caller()).encode();
         let input = vec![1, 2, 3];
+        let value = 1_000_000u128;
 
         #[block]
         {
-            Pallet::<T>::call_without_execution(context, vm_id, source, target, input).unwrap();
+            Pallet::<T>::call_without_execution(context, vm_id, source, target, input, value)
+                .unwrap();
         }
     }