Throw TypedEncoded out of engine

crates/engine/src/accounts.rs

@@ -16,7 +16,6 @@ use crate::test_api::Error;
 
 use super::{
     exec_context::OffChainError,
-    typed_encoded::TypedEncodedError,
     types::OffAccountId,
 };
 
@@ -25,7 +24,8 @@ use derive_more::From;
 /// Errors encountered upon interacting with the accounts database.
 #[derive(Debug, From, PartialEq, Eq)]
 pub enum AccountError {
-    TypedEncoded(TypedEncodedError),
+    // TODO Decoding(scale::Error),
+    DecodingFailed,
     #[from(ignore)]
     UnexpectedUserAccount,
     #[from(ignore)]
@@ -39,7 +39,7 @@ impl From<AccountError> for Error {
 }
 
 impl From<scale::Error> for AccountError {
-    fn from(err: scale::Error) -> Self {
-        AccountError::TypedEncoded(err.into())
+    fn from(_err: scale::Error) -> Self {
+        AccountError::DecodingFailed
     }
 }

crates/engine/src/exec_context.rs

@@ -14,7 +14,6 @@
 
 use super::{
     accounts::AccountError,
-    typed_encoded::TypedEncodedError,
     types::OffAccountId,
     Environment,
 };
@@ -24,7 +23,6 @@ use derive_more::From;
 #[derive(Debug, From, PartialEq, Eq)]
 pub enum OffChainError {
     Account(AccountError),
-    TypedEncoded(TypedEncodedError),
     #[from(ignore)]
     UninitializedBlocks,
     #[from(ignore)]
@@ -51,6 +49,14 @@ impl ExecContext {
     where
         T: Environment,
     {
-        self.callee.decode().map_err(Into::into)
+        // TODO type hell
+        let callee: Vec<u8> = self.callee.clone();
+        let res: std::result::Result<T::AccountId, scale::Error> =
+            scale::Decode::decode(&mut &callee[..]);
+        let res: std::result::Result<T::AccountId, AccountError> =
+            res.map_err(AccountError::from);
+        let res: std::result::Result<T::AccountId, OffChainError> =
+            res.map_err(Into::into);
+        res
     }
 }

crates/engine/src/ext.rs

@@ -47,10 +47,10 @@ thread_local!(
         EnvInstance {
             storage: HashMap::new(),
             emitted_events: Vec::new(),
-            caller: Vec::new(),
             exec_context: None,
             count_reads: 0,
             count_writes: 0,
+            caller: vec![0x01; 32],
         }
     )
 );
@@ -287,9 +287,14 @@ impl_seal_wrapper_for! {
 pub fn caller(output: &mut &mut [u8]) {
     ENV_INSTANCE.with(|instance| {
         let instance = &mut instance.borrow_mut();
-        let caller = instance.caller.clone();
+        let caller = instance
+            .exec_context
+            .as_ref()
+            .expect("uninitialized context")
+            .caller
+            .clone();
         output[..caller.len()].copy_from_slice(&caller[..]);
-        extract_from_slice(output, 32);
+        extract_from_slice(output, caller.len());
     });
 }
 

crates/engine/src/lib.rs

@@ -19,7 +19,6 @@ mod exec_context;
 pub mod ext;
 mod hashing;
 pub mod test_api;
-mod typed_encoded;
 mod types;
 
 pub use test_api::{

crates/engine/src/test_api.rs

@@ -21,7 +21,6 @@ use crate::{
     },
     ext,
     ext::ENV_INSTANCE,
-    typed_encoded::TypedEncoded,
     Environment,
 };
 
@@ -169,8 +168,8 @@ where
         let instance = &mut instance.borrow_mut();
         let alice: T::AccountId = default_accounts::<T>().expect("default").alice;
         instance.exec_context = Some(ExecContext {
-            callee: TypedEncoded::new(&alice),
-            caller: TypedEncoded::new(&alice),
+            callee: scale::Encode::encode(&alice),
+            caller: scale::Encode::encode(&alice),
         });
         instance.emitted_events = Vec::new();
         instance.count_reads = 0;
@@ -196,8 +195,8 @@ where
         instance
             .exec_context
             .as_mut()
-            .expect("unitialized context")
-            .caller = TypedEncoded::new(&caller);
+            .expect("uninitialized context")
+            .caller = scale::Encode::encode(&caller);
     })
 }
 /// Returns the total number of reads and writes of the contract's storage.
@@ -251,10 +250,22 @@ where
     T: Environment,
 {
     ENV_INSTANCE.with(|instance| {
+        // TODO type hell
         let instance = &mut instance.borrow();
         let cont = instance.exec_context.as_ref().expect("no exec context");
-        let callee = cont.callee.decode()?;
-        Ok(callee)
+        let res: std::result::Result<T::AccountId, scale::Error> =
+            scale::Decode::decode(&mut &cont.callee[..]);
+        let res: std::result::Result<T::AccountId, super::accounts::AccountError> =
+            res.map_err(super::accounts::AccountError::from);
+        let callee: std::result::Result<T::AccountId, OffChainError> =
+            res.map_err(Into::into);
+        let callee: std::result::Result<
+            T::AccountId,
+            ink_env_types::Error<OffChainError>,
+        > = callee.map_err(|offchainerr| {
+            ink_env_types::Error::<OffChainError>::OffChain(offchainerr)
+        });
+        callee
     })
 }