refactor(backend): refine approach of funcs forbidding

core-backend/src/funcs.rs

@@ -225,18 +225,22 @@ impl<F> RawSyscall<F> {
     }
 }
 
-impl<T, F, Caller> Syscall<Caller, T> for RawSyscall<F>
+impl<T, F, Caller, Ext> Syscall<Caller, T> for RawSyscall<F>
 where
     F: FnOnce(&mut CallerWrap<Caller>) -> Result<(Gas, T), HostError>,
+    Caller: AsContextExt<State = HostState<Ext, BackendMemory<ExecutorMemory>>>,
+    Ext: BackendExternalities + 'static,
 {
     type Context = ();
 
     fn execute(
         self,
         caller: &mut CallerWrap<Caller>,
         (): Self::Context,
-        _syscall_name: SyscallName,
+        syscall_name: SyscallName,
     ) -> Result<(Gas, T), HostError> {
+        caller.check_func_forbiddenness(syscall_name)?;
+
         (self.0)(caller)
     }
 }
@@ -291,7 +295,8 @@ where
     ) -> Result<(Gas, ()), HostError> {
         let Self { token, f, .. } = self;
         let FallibleSyscallContext { gas, res_ptr } = context;
-        caller.run_fallible::<T, _, E>(gas, res_ptr, token, syscall_name, f)
+        caller.check_func_forbiddenness(syscall_name)?;
+        caller.run_fallible::<T, _, E>(gas, res_ptr, token, f)
     }
 }
 
@@ -336,7 +341,8 @@ where
     ) -> Result<(Gas, T), HostError> {
         let Self { token, f } = self;
         let InfallibleSyscallContext { gas } = ctx;
-        caller.run_any::<T, _>(gas, token, syscall_name, f)
+        caller.check_func_forbiddenness(syscall_name)?;
+        caller.run_any::<T, _>(gas, token, f)
     }
 }
 

core-backend/src/mock.rs

@@ -32,7 +32,7 @@ use gear_core::{
     gas::{ChargeError, CounterType, CountersOwner, GasAmount, GasCounter, GasLeft},
     ids::{MessageId, ProgramId, ReservationId},
     memory::{Memory, MemoryInterval},
-    message::{HandlePacket, InitPacket, ReplyPacket},
+    message::{DispatchKind, HandlePacket, InitPacket, ReplyPacket},
     pages::WasmPage,
 };
 use gear_core_errors::{ReplyCode, SignalCode};
@@ -74,7 +74,6 @@ pub struct MockExt {
     reads: Vec<MemoryInterval>,
     writes: Vec<MemoryInterval>,
     _forbidden_funcs: BTreeSet<SyscallName>,
-    _endpoint_forbidden_funcs: BTreeSet<SyscallName>,
 }
 
 impl MockExt {
@@ -243,8 +242,8 @@ impl Externalities for MockExt {
     fn forbidden_funcs(&self) -> &BTreeSet<SyscallName> {
         &self._forbidden_funcs
     }
-    fn endpoint_forbidden_funcs(&self) -> &BTreeSet<SyscallName> {
-        &self._endpoint_forbidden_funcs
+    fn endpoint_dispatch_kind(&self) -> DispatchKind {
+        Default::default()
     }
     fn reserve_gas(
         &mut self,

core-backend/src/runtime.rs

@@ -79,30 +79,12 @@ where
     Ext: BackendExternalities + 'static,
 {
     #[track_caller]
-    pub fn run_any<U, F>(
-        &mut self,
-        gas: u64,
-        token: CostToken,
-        syscall_name: SyscallName,
-        f: F,
-    ) -> Result<(u64, U), HostError>
+    pub fn run_any<U, F>(&mut self, gas: u64, token: CostToken, f: F) -> Result<(u64, U), HostError>
     where
         F: FnOnce(&mut Self) -> Result<U, UndefinedTerminationReason>,
     {
         self.state_mut().ext.decrease_current_counter_to(gas);
 
-        if self.ext_mut().forbidden_funcs().contains(&syscall_name)
-            || self
-                .ext_mut()
-                .endpoint_forbidden_funcs()
-                .contains(&syscall_name)
-        {
-            self.set_termination_reason(
-                ActorTerminationReason::Trap(TrapExplanation::ForbiddenFunction).into(),
-            );
-            return Err(HostError);
-        }
-
         let run = || {
             self.state_mut().ext.charge_gas_for_token(token)?;
             f(self)
@@ -122,7 +104,6 @@ where
         gas: u64,
         res_ptr: u32,
         token: CostToken,
-        syscall_name: SyscallName,
         f: F,
     ) -> Result<(u64, ()), HostError>
     where
@@ -132,7 +113,6 @@ where
         self.run_any(
             gas,
             token,
-            syscall_name,
             |ctx: &mut Self| -> Result<_, UndefinedTerminationReason> {
                 let res = f(ctx);
                 let res = ctx.process_fallible_func_result(res)?;
@@ -184,4 +164,19 @@ where
             },
         }
     }
+
+    pub fn check_func_forbiddenness(&mut self, syscall_name: SyscallName) -> Result<(), HostError> {
+        let endpoint_forbidden_funcs = self.ext_mut().endpoint_dispatch_kind().forbidden_funcs();
+
+        if self.ext_mut().forbidden_funcs().contains(&syscall_name)
+            || endpoint_forbidden_funcs.contains(&syscall_name)
+        {
+            self.set_termination_reason(
+                ActorTerminationReason::Trap(TrapExplanation::ForbiddenFunction).into(),
+            );
+            return Err(HostError);
+        }
+
+        Ok(())
+    }
 }

core-processor/src/executor.rs

@@ -115,8 +115,6 @@ where
     );
     let value_counter = ValueCounter::new(value_available);
 
-    let endpoint_forbidden_funcs = kind.forbidden_funcs();
-
     let context = ProcessorContext {
         gas_counter,
         gas_allowance_counter,
@@ -130,13 +128,13 @@ where
         program_id: program.id,
         program_candidates_data: Default::default(),
         forbidden_funcs: settings.forbidden_funcs,
+        endpoint_dispatch_kind: kind,
         reserve_for: settings.reserve_for,
         random_data: settings.random_data,
         gas_multiplier: settings.gas_multiplier,
         existential_deposit: settings.existential_deposit,
         mailbox_threshold: settings.mailbox_threshold,
         costs: settings.ext_costs,
-        endpoint_forbidden_funcs,
     };
 
     // Creating externalities.
@@ -310,12 +308,6 @@ where
     )
     .ok_or("Incorrect message store context: out of outgoing bytes limit")?;
 
-    let endpoint_forbidden_funcs = function
-        .try_into_kind()
-        .as_mut()
-        .map(|kind| kind.forbidden_funcs())
-        .unwrap_or_default();
-
     let context = ProcessorContext {
         gas_counter: GasCounter::new(gas_limit),
         gas_allowance_counter: GasAllowanceCounter::new(gas_limit),
@@ -342,7 +334,7 @@ where
         existential_deposit: Default::default(),
         mailbox_threshold: Default::default(),
         costs: Default::default(),
-        endpoint_forbidden_funcs,
+        endpoint_dispatch_kind: function.try_into_kind().unwrap_or_default(),
     };
 
     // Creating externalities.

core-processor/src/ext.rs

@@ -88,8 +88,8 @@ pub struct ProcessorContext {
     pub program_candidates_data: BTreeMap<CodeId, Vec<(MessageId, ProgramId)>>,
     /// Functions forbidden to be called.
     pub forbidden_funcs: BTreeSet<SyscallName>,
-    /// Functions forbidden to be called with this endpoint
-    pub endpoint_forbidden_funcs: BTreeSet<SyscallName>,
+    /// Endpoint dispatch kind.
+    pub endpoint_dispatch_kind: DispatchKind,
     /// Reserve for parameter of scheduling.
     pub reserve_for: u32,
     /// Output from Randomness.
@@ -139,7 +139,7 @@ impl ProcessorContext {
             program_id: Default::default(),
             program_candidates_data: Default::default(),
             forbidden_funcs: Default::default(),
-            endpoint_forbidden_funcs: Default::default(),
+            endpoint_dispatch_kind: Default::default(),
             reserve_for: 0,
             random_data: ([0u8; 32].to_vec(), 0),
             gas_multiplier: gsys::GasMultiplier::from_value_per_gas(1),
@@ -1425,8 +1425,8 @@ impl<LP: LazyPagesInterface> Externalities for Ext<LP> {
         &self.context.forbidden_funcs
     }
 
-    fn endpoint_forbidden_funcs(&self) -> &BTreeSet<SyscallName> {
-        &self.context.endpoint_forbidden_funcs
+    fn endpoint_dispatch_kind(&self) -> DispatchKind {
+        self.context.endpoint_dispatch_kind
     }
 }
 

core/src/env.rs

@@ -22,7 +22,7 @@ use crate::{
     env_vars::EnvVars,
     ids::{MessageId, ProgramId, ReservationId},
     memory::Memory,
-    message::{HandlePacket, InitPacket, MessageContext, Payload, ReplyPacket},
+    message::{DispatchKind, HandlePacket, InitPacket, MessageContext, Payload, ReplyPacket},
     pages::WasmPage,
 };
 use alloc::collections::BTreeSet;
@@ -392,6 +392,6 @@ pub trait Externalities {
     /// Return the set of functions that are forbidden to be called.
     fn forbidden_funcs(&self) -> &BTreeSet<SyscallName>;
 
-    /// Return the set of functions that are forbidden to be called in this endpoint.
-    fn endpoint_forbidden_funcs(&self) -> &BTreeSet<SyscallName>;
+    /// Return the current dispatch kind.
+    fn endpoint_dispatch_kind(&self) -> DispatchKind;
 }