refactor(executor): remove useless traits

poc/runtime/src/lib.rs

@@ -227,7 +227,7 @@ impl_runtime_apis! {
 
     impl xcq::XcqApi<Block> for Runtime {
         fn execute_query(query: Vec<u8>, input: Vec<u8>) -> xcq::XcqResult {
-            xcq::execute_query(query, input)
+            xcq::execute_query(&query, &input)
         }
         fn metadata() -> Vec<u8> {
             xcq::metadata().encode()

poc/runtime/src/xcq.rs

@@ -6,7 +6,7 @@ use frame::prelude::*;
 use xcq_extension::metadata::Metadata;
 pub use xcq_primitives::XcqResult;
 
-use xcq_extension::{impl_extensions, ExtensionsExecutor, Guest, Input, InvokeSource, Method};
+use xcq_extension::{impl_extensions, ExtensionsExecutor, InvokeSource};
 decl_runtime_apis! {
     pub trait XcqApi {
         fn execute_query(query: Vec<u8>, input: Vec<u8>) -> XcqResult;
@@ -49,38 +49,9 @@ impl_extensions! {
     }
 }
 
-// guest impls
-pub struct GuestImpl {
-    pub program: Vec<u8>,
-}
-
-impl Guest for GuestImpl {
-    fn program(&self) -> &[u8] {
-        &self.program
-    }
-}
-
-pub struct InputImpl {
-    pub method: Method,
-    pub args: Vec<u8>,
-}
-
-impl Input for InputImpl {
-    fn method(&self) -> Method {
-        self.method.clone()
-    }
-    fn args(&self) -> &[u8] {
-        &self.args
-    }
-}
-pub fn execute_query(query: Vec<u8>, input: Vec<u8>) -> XcqResult {
+pub fn execute_query(query: &[u8], input: &[u8]) -> XcqResult {
     let mut executor = ExtensionsExecutor::<Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let guest = GuestImpl { program: query };
-    let input = InputImpl {
-        method: "main".to_owned(),
-        args: input,
-    };
-    executor.execute_method(guest, input)
+    executor.execute_method(query, input)
 }
 
 pub fn metadata() -> Metadata {

xcq-executor/src/lib.rs

@@ -57,12 +57,7 @@ impl<Ctx: XcqExecutorContext> XcqExecutor<Ctx> {
         }
     }
 
-    pub fn execute(
-        &mut self,
-        raw_blob: &[u8],
-        method: &str,
-        input: &[u8],
-    ) -> Result<Vec<u8>, XcqExecutorError<Ctx::UserError>> {
+    pub fn execute(&mut self, raw_blob: &[u8], input: &[u8]) -> Result<Vec<u8>, XcqExecutorError<Ctx::UserError>> {
         let blob = ProgramBlob::parse(raw_blob.into()).map_err(polkavm::Error::from)?;
         let module = Module::from_blob(&self.engine, &Default::default(), blob)?;
         let instance_pre = self.linker.instantiate_pre(&module)?;
@@ -89,7 +84,7 @@ impl<Ctx: XcqExecutorContext> XcqExecutor<Ctx> {
 
         let res = instance.call_typed_and_get_result::<u64, (u32, u32)>(
             self.context.data(),
-            method,
+            "main",
             (input_ptr, input.len() as u32),
         )?;
         let res_size = (res >> 32) as u32;

xcq-extension/src/lib.rs

@@ -17,7 +17,7 @@ mod macros;
 pub use xcq_extension_procedural::{decl_extensions, impl_extensions};
 
 mod perm_controller;
-pub use perm_controller::{InvokeSource, PermController};
+pub use perm_controller::{InvokeSource, PermissionController};
 
 mod guest;
 pub use guest::{Guest, Input, Method};
@@ -32,13 +32,13 @@ pub trait CallDataTuple {
     fn return_ty(extension_id: ExtensionIdTy, call_index: u32) -> Result<Vec<u8>, ExtensionError>;
 }
 
-struct Context<C: CallDataTuple, P: PermController> {
+struct Context<C: CallDataTuple, P: PermissionController> {
     invoke_source: InvokeSource,
     user_data: (),
     _marker: PhantomData<(C, P)>,
 }
 
-impl<C: CallDataTuple, P: PermController> Context<C, P> {
+impl<C: CallDataTuple, P: PermissionController> Context<C, P> {
     pub fn new(invoke_source: InvokeSource) -> Self {
         Self {
             invoke_source,
@@ -48,7 +48,7 @@ impl<C: CallDataTuple, P: PermController> Context<C, P> {
     }
 }
 
-impl<C: CallDataTuple, P: PermController> XcqExecutorContext for Context<C, P> {
+impl<C: CallDataTuple, P: PermissionController> XcqExecutorContext for Context<C, P> {
     type UserData = ();
     type UserError = ExtensionError;
     fn data(&mut self) -> &mut Self::UserData {
@@ -118,10 +118,10 @@ impl<C: CallDataTuple, P: PermController> XcqExecutorContext for Context<C, P> {
     }
 }
 
-pub struct ExtensionsExecutor<C: CallDataTuple, P: PermController> {
+pub struct ExtensionsExecutor<C: CallDataTuple, P: PermissionController> {
     executor: XcqExecutor<Context<C, P>>,
 }
-impl<C: CallDataTuple, P: PermController> ExtensionsExecutor<C, P> {
+impl<C: CallDataTuple, P: PermissionController> ExtensionsExecutor<C, P> {
     #[allow(dead_code)]
     pub fn new(source: InvokeSource) -> Self {
         let context = Context::<C, P>::new(source);
@@ -130,9 +130,9 @@ impl<C: CallDataTuple, P: PermController> ExtensionsExecutor<C, P> {
     }
 
     #[allow(dead_code)]
-    pub fn execute_method<G: Guest, I: Input>(&mut self, guest: G, input: I) -> XcqResult {
+    pub fn execute_method(&mut self, query: &[u8], input: &[u8]) -> XcqResult {
         self.executor
-            .execute(guest.program(), &input.method(), input.args())
+            .execute(query, input)
             .map_err(|e| XcqError::Custom(format!("{:?}", e)))
     }
 }

xcq-extension/src/perm_controller.rs

@@ -1,9 +1,9 @@
 use crate::ExtensionIdTy;
-pub trait PermController {
+pub trait PermissionController {
     fn is_allowed(extension_id: ExtensionIdTy, call: &[u8], source: InvokeSource) -> bool;
 }
 
-impl PermController for () {
+impl PermissionController for () {
     fn is_allowed(_extension_id: ExtensionIdTy, _call: &[u8], _context: InvokeSource) -> bool {
         true
     }

xcq-extension/tests/with_associated_types_works.rs

@@ -1,6 +1,6 @@
 use parity_scale_codec::{Codec, Decode, Encode};
 use xcq_extension::metadata::Metadata;
-use xcq_extension::{decl_extensions, impl_extensions, ExtensionsExecutor, Guest, Input, InvokeSource, Method};
+use xcq_extension::{decl_extensions, impl_extensions, ExtensionsExecutor, InvokeSource};
 
 mod extension_core {
     use super::*;
@@ -69,31 +69,6 @@ impl extension_fungibles::Config for ExtensionImpl {
     type Balance = u64;
 }
 
-// guest impls
-pub struct GuestImpl {
-    pub program: Vec<u8>,
-}
-
-impl Guest for GuestImpl {
-    fn program(&self) -> &[u8] {
-        &self.program
-    }
-}
-
-pub struct InputImpl {
-    pub method: Method,
-    pub args: Vec<u8>,
-}
-
-impl Input for InputImpl {
-    fn method(&self) -> Method {
-        self.method.clone()
-    }
-    fn args(&self) -> &[u8] {
-        &self.args
-    }
-}
-
 #[derive(Encode, Decode)]
 enum CoreMethod {
     HasExtension { id: u64 },
@@ -108,22 +83,16 @@ enum FungiblesMethod {
 fn call_core_works() {
     let blob = include_bytes!("../../output/poc-guest-transparent-call.polkavm");
     let mut executor = ExtensionsExecutor::<Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let guest = GuestImpl { program: blob.to_vec() };
     let method = CoreMethod::HasExtension { id: 0 };
     let mut input_data = extension_core::EXTENSION_ID.encode();
     input_data.extend_from_slice(&method.encode());
-    let input = InputImpl {
-        method: "main".to_string(),
-        args: input_data,
-    };
-    let res = executor.execute_method(guest, input).unwrap();
+    let res = executor.execute_method(blob, &input_data).unwrap();
     assert_eq!(res, vec![1]);
 }
 #[test]
 fn multi_calls_works() {
     let blob = include_bytes!("../../output/poc-guest-sum-balance-percent.polkavm");
     let mut executor = ExtensionsExecutor::<Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let guest = GuestImpl { program: blob.to_vec() };
     let mut input_data = extension_fungibles::EXTENSION_ID.encode();
     input_data.extend_from_slice(&[2u8]);
     let method1 = FungiblesMethod::Balance {
@@ -143,19 +112,14 @@ fn multi_calls_works() {
     let method3_encoded = method3.encode();
     input_data.extend_from_slice(&[method3_encoded.len() as u8]);
     input_data.extend_from_slice(&method3_encoded);
-    let input = InputImpl {
-        method: "main".to_string(),
-        args: input_data,
-    };
-    let res = executor.execute_method(guest, input).unwrap();
+    let res = executor.execute_method(blob, &input_data).unwrap();
     assert_eq!(res, vec![100u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
 }
 
 #[test]
 fn calls_vec_works() {
     let blob = include_bytes!("../../output/poc-guest-sum-balance.polkavm");
     let mut executor = ExtensionsExecutor::<Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let guest = GuestImpl { program: blob.to_vec() };
     let mut input_data = extension_fungibles::EXTENSION_ID.encode();
     input_data.extend_from_slice(&vec![2u8]);
     let method1 = FungiblesMethod::Balance {
@@ -170,29 +134,20 @@ fn calls_vec_works() {
     };
     input_data.extend_from_slice(&method1_encoded);
     input_data.extend_from_slice(&method2.encode());
-    let input = InputImpl {
-        method: "main".to_string(),
-        args: input_data,
-    };
-    let res = executor.execute_method(guest, input).unwrap();
+    let res = executor.execute_method(blob, &input_data).unwrap();
     assert_eq!(res, vec![200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
 }
 
 #[test]
 fn single_call_works() {
     let blob = include_bytes!("../../output/poc-guest-total-supply.polkavm");
     let mut executor = ExtensionsExecutor::<Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let guest = GuestImpl { program: blob.to_vec() };
     let mut input_data = extension_fungibles::EXTENSION_ID.encode();
     let method1 = FungiblesMethod::TotalSupply { asset: 1 };
     let method1_encoded = method1.encode();
     input_data.extend_from_slice(&vec![method1_encoded.len() as u8]);
     input_data.extend_from_slice(&method1_encoded);
-    let input = InputImpl {
-        method: "main".to_string(),
-        args: input_data,
-    };
-    let res = executor.execute_method(guest, input).unwrap();
+    let res = executor.execute_method(blob, &input_data).unwrap();
     assert_eq!(res, vec![200u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
 }
 

xcq-test-runner/src/main.rs

@@ -1,7 +1,7 @@
 use clap::Parser;
 use parity_scale_codec::{Decode, Encode};
 use tracing_subscriber::prelude::*;
-use xcq_extension::{impl_extensions, ExtensionsExecutor, Guest, Input, InvokeSource, Method};
+use xcq_extension::{impl_extensions, ExtensionsExecutor, InvokeSource};
 
 #[derive(Parser, Debug)]
 #[command(version, about)]
@@ -27,7 +27,6 @@ fn main() {
 
     let blob = std::fs::read(cli.program).expect("Failed to read program");
     let mut executor = ExtensionsExecutor::<Extensions, ()>::new(InvokeSource::RuntimeAPI);
-    let guest = GuestImpl { program: blob.to_vec() };
     let mut input_data = xcq_extension_fungibles::EXTENSION_ID.encode();
     input_data.extend_from_slice(&[2u8]);
     let method1 = FungiblesMethod::Balance {
@@ -42,17 +41,8 @@ fn main() {
     };
     input_data.extend_from_slice(&method1_encoded);
     input_data.extend_from_slice(&method2.encode());
-    // input_data.extend_from_slice(&xcq_extension_fungibles::EXTENSION_ID.encode());
-    // let method3 = FungiblesMethod::TotalSupply { asset: 1 };
-    // let method3_encoded = method3.encode();
-    // input_data.extend_from_slice(&[method3_encoded.len() as u8]);
-    // input_data.extend_from_slice(&method3_encoded);
     tracing::info!("Input data: {:?}", input_data);
-    let input = InputImpl {
-        method: "main".to_string(),
-        args: input_data,
-    };
-    let res = executor.execute_method(guest, input).unwrap();
+    let res = executor.execute_method(&blob, &input_data).unwrap();
 
     tracing::info!("Result: {:?}", res);
 }
@@ -92,31 +82,6 @@ impl_extensions! {
         }
     }
 }
-// guest impls
-pub struct GuestImpl {
-    pub program: Vec<u8>,
-}
-
-impl Guest for GuestImpl {
-    fn program(&self) -> &[u8] {
-        &self.program
-    }
-}
-
-pub struct InputImpl {
-    pub method: Method,
-    pub args: Vec<u8>,
-}
-
-impl Input for InputImpl {
-    fn method(&self) -> Method {
-        self.method.clone()
-    }
-    fn args(&self) -> &[u8] {
-        &self.args
-    }
-}
-
 #[derive(Encode, Decode)]
 enum CoreMethod {
     HasExtension { id: u64 },