WIP experiment

crates/env/src/api.rs

@@ -25,6 +25,8 @@ use crate::{
         CallParams,
         CreateParams,
         DelegateCall,
+        FromAccountId,
+        utils::ConstructorOutputValue,
     },
     engine::{
         EnvInstance,
@@ -325,11 +327,12 @@ where
 /// - If the returned account ID failed to decode properly.
 pub fn instantiate_contract<E, Args, Salt, R>(
     params: &CreateParams<E, Args, Salt, R>,
-) -> Result<ink_primitives::ConstructorResult<E::AccountId>>
+) -> Result<ink_primitives::ConstructorResult<ConstructorOutputValue<R, E>>>
 where
     E: Environment,
     Args: scale::Encode,
     Salt: AsRef<[u8]>,
+    R: FromAccountId<E>,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
         TypedEnvBackend::instantiate_contract::<E, Args, Salt, R>(instance, params)

crates/env/src/backend.rs

@@ -17,7 +17,12 @@ use crate::{
         Call,
         CallParams,
         CreateParams,
+        FromAccountId,
         DelegateCall,
+        utils::{
+            ConstructorOutput,
+            ConstructorOutputValue,
+        }
     },
     hash::{
         CryptoHash,
@@ -442,11 +447,12 @@ pub trait TypedEnvBackend: EnvBackend {
     fn instantiate_contract<E, Args, Salt, R>(
         &mut self,
         params: &CreateParams<E, Args, Salt, R>,
-    ) -> Result<ink_primitives::ConstructorResult<E::AccountId>>
+    ) -> Result<ink_primitives::ConstructorResult<ConstructorOutputValue<R, E>>>
     where
         E: Environment,
         Args: scale::Encode,
-        Salt: AsRef<[u8]>;
+        Salt: AsRef<[u8]>,
+        R: FromAccountId<E>,;
 
     /// Attempts to instantiate another contract, returning the instantiation result back to the
     /// caller.

crates/env/src/call/common.rs

@@ -15,6 +15,8 @@
 //! Utilities, types and abstractions common to call and instantiation routines.
 
 use core::marker::PhantomData;
+use crate::call::FromAccountId;
+use crate::Environment;
 
 /// Represents a return type.
 ///
@@ -38,6 +40,100 @@ impl<T> Default for ReturnType<T> {
     }
 }
 
+mod private {
+    /// Seals the implementation of `ConstructorReturnType`.
+    pub trait Sealed {}
+}
+
+/// Guards against using invalid contract initializer types.
+///
+/// # Note
+///
+/// Currently the only allowed types are `()` and `Result<(), E>`
+/// where `E` is some unspecified error type.
+/// If the contract initializer returns `Result::Err` the utility
+/// method that is used to initialize an ink! smart contract will
+/// revert the state of the contract instantiation.
+pub trait ConstructorOutput<C, Env: Environment>: private::Sealed {
+    /// Is `true` if `Self` is `Result<C, E>`.
+    const IS_RESULT: bool = false;
+
+    /// Reflects the output type of the dispatchable ink! constructor.
+    type Output;
+
+    /// The error type of the constructor return type.
+    ///
+    /// # Note
+    ///
+    /// For infallible constructors this is `()` whereas for fallible
+    /// constructors this is the actual return error type. Since we only ever
+    /// return a value in case of `Result::Err` the `Result::Ok` value type
+    /// does not matter.
+    type Error;
+
+    // todo: docs
+    fn from_account_id(account_id: Env::AccountId) -> Self::Output;
+
+    /// Converts the return value into a `Result` instance.
+    ///
+    /// # Note
+    ///
+    /// For infallible constructor returns this always yields `Ok`.
+    fn as_result(&self) -> Result<&C, &Self::Error>;
+}
+
+/// todo: comment
+pub struct ConstructorOutputValue<T, Env: Environment>(T, PhantomData<Env>);
+
+impl<T, Env> ConstructorOutputValue<T, Env>
+where
+    Env: Environment,
+{
+    pub fn new(val: T) -> Self {
+        Self(val, PhantomData)
+    }
+}
+
+impl<T, Env: Environment> private::Sealed for ConstructorOutputValue<T, Env> {}
+
+impl<C, Env> ConstructorOutput<C, Env> for ConstructorOutputValue<C, Env>
+where
+    C: FromAccountId<Env>,
+    Env: Environment,
+{
+    type Output = C;
+    type Error = &'static ();
+
+    fn from_account_id(account_id: Env::AccountId) -> Self::Output {
+        C::from_account_id(account_id)
+    }
+
+    #[inline(always)]
+    fn as_result(&self) -> Result<&C, &Self::Error> {
+        Ok(&self.0)
+    }
+}
+
+impl<C, E, Env> ConstructorOutput<C, Env> for ConstructorOutputValue<Result<C, E>, Env>
+where
+    C: FromAccountId<Env>,
+    Env: Environment,
+{
+    const IS_RESULT: bool = true;
+
+    type Output = Result<C, E>;
+    type Error = E;
+
+    fn from_account_id(account_id: Env::AccountId) -> Self::Output {
+        Ok(C::from_account_id(account_id))
+    }
+
+    #[inline(always)]
+    fn as_result(&self) -> Result<&C, &Self::Error> {
+        self.0.as_ref()
+    }
+}
+
 /// A parameter that has been set to some value.
 #[derive(Debug, Copy, Clone)]
 pub struct Set<T>(pub T);

crates/env/src/call/create_builder.rs

@@ -15,6 +15,8 @@
 use crate::{
     call::{
         utils::{
+            ConstructorOutput,
+            ConstructorOutputValue,
             EmptyArgumentList,
             ReturnType,
             Set,
@@ -152,7 +154,6 @@ where
         &self,
     ) -> Result<ink_primitives::ConstructorResult<R>, crate::Error> {
         crate::instantiate_contract(self)
-            .map(|inner| inner.map(FromAccountId::from_account_id))
     }
 }
 

crates/env/src/call/mod.rs

@@ -24,6 +24,8 @@ mod selector;
 pub mod utils {
     pub use super::{
         common::{
+            ConstructorOutput,
+            ConstructorOutputValue,
             ReturnType,
             Set,
             Unset,

crates/env/src/engine/off_chain/impls.rs

@@ -18,7 +18,12 @@ use crate::{
         Call,
         CallParams,
         CreateParams,
+        FromAccountId,
         DelegateCall,
+        utils::{
+            ConstructorOutput,
+            ConstructorOutputValue,
+        }
     },
     hash::{
         Blake2x128,
@@ -472,11 +477,12 @@ impl TypedEnvBackend for EnvInstance {
     fn instantiate_contract<E, Args, Salt, R>(
         &mut self,
         params: &CreateParams<E, Args, Salt, R>,
-    ) -> Result<ink_primitives::ConstructorResult<E::AccountId>>
+    ) -> Result<ink_primitives::ConstructorResult<ConstructorOutputValue<R, E>>>
     where
         E: Environment,
         Args: scale::Encode,
         Salt: AsRef<[u8]>,
+        R: FromAccountId<E>,
     {
         let _code_hash = params.code_hash();
         let _gas_limit = params.gas_limit();

crates/env/src/engine/on_chain/impls.rs

@@ -24,6 +24,10 @@ use crate::{
         CallParams,
         CreateParams,
         DelegateCall,
+        utils::{
+            ConstructorOutput,
+            ConstructorOutputValue,
+        }
     },
     hash::{
         Blake2x128,
@@ -41,6 +45,7 @@ use crate::{
     EnvBackend,
     Environment,
     Error,
+    FromAccountId,
     FromLittleEndian,
     Result,
     ReturnFlags,
@@ -482,11 +487,12 @@ impl TypedEnvBackend for EnvInstance {
     fn instantiate_contract<E, Args, Salt, R>(
         &mut self,
         params: &CreateParams<E, Args, Salt, R>,
-    ) -> Result<ink_primitives::ConstructorResult<E::AccountId>>
+    ) -> Result<ink_primitives::ConstructorResult<ConstructorOutputValue<R>>>
     where
         E: Environment,
         Args: scale::Encode,
         Salt: AsRef<[u8]>,
+        R: FromAccountId<E>,
     {
         let mut scoped = self.scoped_buffer();
         let gas_limit = params.gas_limit();
@@ -513,17 +519,18 @@ impl TypedEnvBackend for EnvInstance {
         match instantiate_result {
             Ok(()) => {
                 let account_id = scale::Decode::decode(&mut &out_address[..])?;
-                Ok(Ok(account_id))
+                Ok(Ok(<R as FromAccountId<E>>::from_account_id(account_id)))
             }
             Err(ext::Error::CalleeReverted) => {
                 // We don't wrap manually with an extra `Err` like we do in the `Ok` case since the
                 // buffer already comes back in the form of `Err(LangError)` (assuming it's encoded
                 // by the ink! codegen and not the contract).
-                let out = ink_primitives::ConstructorResult::<E::AccountId>::decode(
-                    &mut &out_return_value[..],
-                )?;
-                assert!(out.is_err(), "The callee reverted, but did not encode an error in the output buffer.");
-                Ok(out)
+                // let out = ink_primitives::ConstructorResult::<E::AccountId>::decode(
+                //     &mut &out_return_value[..],
+                // )?;
+                // assert!(out.is_err(), "The callee reverted, but did not encode an error in the output buffer.");
+                // Ok(out)
+                todo!("custom decoding based on ConstructorOutputValue<R>")
             }
             Err(actual_error) => Err(actual_error.into()),
         }

crates/ink/codegen/src/generator/as_dependency/contract_ref.rs

@@ -420,7 +420,8 @@ impl ContractRef<'_> {
                 ::ink::env::call::utils::Unset<Balance>,
                 ::ink::env::call::utils::Set<::ink::env::call::ExecutionInput<#arg_list>>,
                 ::ink::env::call::utils::Unset<::ink::env::call::state::Salt>,
-                ::ink::env::call::utils::Set<::ink::env::call::utils::ReturnType<#ret_type>>,
+                ::ink::env::call::utils::Set<::ink::env::call::utils::ConstructorOutputValue<#ret_type>>,
+                Self,
             > {
                 ::ink::env::call::build_create::<Environment>()
                     .exec_input(
@@ -431,7 +432,6 @@ impl ContractRef<'_> {
                             .push_arg(#input_bindings)
                         )*
                     )
-                    .returns::<#ret_type>()
             }
         )
     }