Merge remote-tracking branch 'origin/main' into devnet-ready

Author: sam0x17

Cargo.lock

@@ -255,3 +255,100 @@ pub fn get_single_u8(data: &[u8], index: usize) -> Result<u8, PrecompileFailure>
         })
     }
 }
+
+pub fn get_pubkey(data: &[u8]) -> Result<(AccountId32, vec::Vec<u8>), PrecompileFailure> {
+    let mut pubkey = [0u8; 32];
+    pubkey.copy_from_slice(get_slice(data, 0, 32)?);
+
+    Ok((
+        pubkey.into(),
+        data.get(32..)
+            .map_or_else(vec::Vec::new, |slice| slice.to_vec()),
+    ))
+}
+
+fn parse_netuid(data: &[u8], offset: usize) -> Result<u16, PrecompileFailure> {
+    if data.len() < offset + 2 {
+        return Err(PrecompileFailure::Error {
+            exit_status: ExitError::InvalidRange,
+        });
+    }
+
+    let mut netuid_bytes = [0u8; 2];
+    netuid_bytes.copy_from_slice(get_slice(data, offset, offset + 2)?);
+    let netuid: u16 = netuid_bytes[1] as u16 | ((netuid_bytes[0] as u16) << 8u16);
+
+    Ok(netuid)
+}
+
+fn contract_to_origin(contract: &[u8; 32]) -> Result<RawOrigin<AccountId32>, PrecompileFailure> {
+    let (account_id, _) = get_pubkey(contract)?;
+    Ok(RawOrigin::Signed(account_id))
+}
+
+/// Dispatches a runtime call, but also checks and records the gas costs.
+fn try_dispatch_runtime_call(
+    handle: &mut impl PrecompileHandle,
+    call: impl Into<RuntimeCall>,
+    origin: RawOrigin<AccountId32>,
+) -> PrecompileResult {
+    let call = Into::<RuntimeCall>::into(call);
+    let info = call.get_dispatch_info();
+
+    let target_gas = handle.gas_limit();
+    if let Some(gas) = target_gas {
+        let valid_weight =
+            <Runtime as pallet_evm::Config>::GasWeightMapping::gas_to_weight(gas, false).ref_time();
+        if info.weight.ref_time() > valid_weight {
+            return Err(PrecompileFailure::Error {
+                exit_status: ExitError::OutOfGas,
+            });
+        }
+    }
+
+    handle.record_external_cost(
+        Some(info.weight.ref_time()),
+        Some(info.weight.proof_size()),
+        None,
+    )?;
+
+    match call.dispatch(origin.into()) {
+        Ok(post_info) => {
+            if post_info.pays_fee(&info) == Pays::Yes {
+                let actual_weight = post_info.actual_weight.unwrap_or(info.weight);
+                let cost =
+                    <Runtime as pallet_evm::Config>::GasWeightMapping::weight_to_gas(actual_weight);
+                handle.record_cost(cost)?;
+
+                handle.refund_external_cost(
+                    Some(
+                        info.weight
+                            .ref_time()
+                            .saturating_sub(actual_weight.ref_time()),
+                    ),
+                    Some(
+                        info.weight
+                            .proof_size()
+                            .saturating_sub(actual_weight.proof_size()),
+                    ),
+                );
+            }
+
+            log::info!("Dispatch succeeded. Post info: {:?}", post_info);
+
+            Ok(PrecompileOutput {
+                exit_status: ExitSucceed::Returned,
+                output: Default::default(),
+            })
+        }
+        Err(e) => {
+            log::error!("Dispatch failed. Error: {:?}", e);
+            log::warn!("Returning error PrecompileFailure::Error");
+            Err(PrecompileFailure::Error {
+                exit_status: ExitError::Other(
+                    format!("dispatch execution failed: {}", <&'static str>::from(e)).into(),
+                ),
+            })
+        }
+    }
+}