[ink_e2e] method to generate and fund unique accounts

crates/e2e/Cargo.toml

@@ -21,7 +21,7 @@ ink = { version = "4.0.0-beta", path = "../ink" }
 ink_env = { version = "4.0.0-beta", path = "../env" }
 ink_primitives = { version = "4.0.0-beta", path = "../primitives" }
 
-contract-metadata = { version = "2.0.0-beta.1" }
+contract-metadata = { version = "2.0.0-rc" }
 impl-serde = { version = "0.3.1", default-features = false }
 jsonrpsee = { version = "0.16.0", features = ["ws-client"] }
 serde = { version = "1.0.137", default-features = false, features = ["derive"] }

crates/e2e/src/builders.rs

@@ -32,8 +32,9 @@ use scale::Encode;
 
 /// The type returned from `ContractRef` constructors, partially initialized with the execution
 /// input arguments.
-pub type CreateBuilderPartial<E, Args, R> = CreateBuilder<
+pub type CreateBuilderPartial<E, ContractRef, Args, R> = CreateBuilder<
     E,
+    ContractRef,
     Unset<<E as Environment>::Hash>,
     Unset<u64>,
     Unset<<E as Environment>::Balance>,
@@ -43,9 +44,12 @@ pub type CreateBuilderPartial<E, Args, R> = CreateBuilder<
 >;
 
 /// Get the encoded constructor arguments from the partially initialized `CreateBuilder`
-pub fn constructor_exec_input<E: Environment, Args: Encode, R>(
-    builder: CreateBuilderPartial<E, Args, R>,
-) -> Vec<u8> {
+pub fn constructor_exec_input<E, ContractRef, Args: Encode, R>(
+    builder: CreateBuilderPartial<E, ContractRef, Args, R>,
+) -> Vec<u8>
+where
+    E: Environment,
+{
     // set all the other properties to default values, we only require the `exec_input`.
     builder
         .endowment(0u32.into())

crates/e2e/src/client.rs

@@ -21,10 +21,6 @@ use super::{
     log_error,
     log_info,
     sr25519,
-    xts::{
-        Call,
-        InstantiateWithCode,
-    },
     CodeUploadResult,
     ContractExecResult,
     ContractInstantiateResult,
@@ -35,6 +31,7 @@ use contract_metadata::ContractMetadata;
 use ink_env::Environment;
 use ink_primitives::MessageResult;
 
+use sp_core::Pair;
 use sp_runtime::traits::{
     IdentifyAccount,
     Verify,
@@ -55,7 +52,10 @@ use subxt::{
             ValueDef,
         },
     },
-    tx::ExtrinsicParams,
+    tx::{
+        ExtrinsicParams,
+        PairSigner,
+    },
 };
 
 /// Result of a contract instantiation.
@@ -300,11 +300,8 @@ where
 
     E: Environment,
     E::AccountId: Debug,
-    E::Balance: Debug + scale::Encode + serde::Serialize,
+    E::Balance: Debug + scale::HasCompact + serde::Serialize,
     E::Hash: Debug + scale::Encode,
-
-    Call<E, E::Balance>: scale::Encode,
-    InstantiateWithCode<E::Balance>: scale::Encode,
 {
     /// Creates a new [`Client`] instance.
     pub async fn new(url: &str, contracts: impl IntoIterator<Item = &str>) -> Self {
@@ -342,6 +339,52 @@ where
         }
     }
 
+    /// Generate a new keypair and fund with the given amount from the origin account.
+    ///
+    /// Because many tests may execute this in parallel, transfers may fail due to a race condition
+    /// with account indices. Therefore this will reattempt transfers a number of times.
+    pub async fn create_and_fund_account(
+        &self,
+        origin: &Signer<C>,
+        amount: E::Balance,
+    ) -> Signer<C>
+    where
+        E::Balance: Clone,
+        C::AccountId: Clone + core::fmt::Display,
+    {
+        let (pair, _, _) = <sr25519::Pair as Pair>::generate_with_phrase(None);
+        let account_id =
+            <C::Signature as Verify>::Signer::from(pair.public()).into_account();
+
+        for _ in 0..6 {
+            let transfer_result = self
+                .api
+                .try_transfer_balance(origin, account_id.clone(), amount)
+                .await;
+            match transfer_result {
+                Ok(_) => {
+                    log_info(&format!(
+                        "transfer from {} to {} succeeded",
+                        origin.account_id(),
+                        account_id,
+                    ));
+                    break
+                }
+                Err(err) => {
+                    log_info(&format!(
+                        "transfer from {} to {} failed with {:?}",
+                        origin.account_id(),
+                        account_id,
+                        err
+                    ));
+                    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                }
+            }
+        }
+
+        PairSigner::new(pair)
+    }
+
     /// This function extracts the metadata of the contract at the file path
     /// `target/ink/$contract_name.contract`.
     ///
@@ -350,11 +393,11 @@ where
     /// Calling this function multiple times is idempotent, the contract is
     /// newly instantiated each time using a unique salt. No existing contract
     /// instance is reused!
-    pub async fn instantiate<Args, R>(
+    pub async fn instantiate<ContractRef, Args, R>(
         &mut self,
         contract_name: &str,
         signer: &Signer<C>,
-        constructor: CreateBuilderPartial<E, Args, R>,
+        constructor: CreateBuilderPartial<E, ContractRef, Args, R>,
         value: E::Balance,
         storage_deposit_limit: Option<E::Balance>,
     ) -> Result<InstantiationResult<C, E>, Error<C, E>>
@@ -374,11 +417,11 @@ where
     }
 
     /// Dry run contract instantiation using the given constructor.
-    pub async fn instantiate_dry_run<Args, R>(
+    pub async fn instantiate_dry_run<ContractRef, Args, R>(
         &mut self,
         contract_name: &str,
         signer: &Signer<C>,
-        constructor: CreateBuilderPartial<E, Args, R>,
+        constructor: CreateBuilderPartial<E, ContractRef, Args, R>,
         value: E::Balance,
         storage_deposit_limit: Option<E::Balance>,
     ) -> ContractInstantiateResult<C::AccountId, E::Balance>
@@ -406,11 +449,11 @@ where
     }
 
     /// Executes an `instantiate_with_code` call and captures the resulting events.
-    async fn exec_instantiate<Args, R>(
+    async fn exec_instantiate<ContractRef, Args, R>(
         &mut self,
         signer: &Signer<C>,
         code: Vec<u8>,
-        constructor: CreateBuilderPartial<E, Args, R>,
+        constructor: CreateBuilderPartial<E, ContractRef, Args, R>,
         value: E::Balance,
         storage_deposit_limit: Option<E::Balance>,
     ) -> Result<InstantiationResult<C, E>, Error<C, E>>

crates/e2e/src/xts.rs

@@ -68,6 +68,25 @@ pub struct Call<E: Environment, B> {
     data: Vec<u8>,
 }
 
+/// A raw call to `pallet-contracts`'s `call`.
+#[derive(Debug, scale::Encode, scale::Decode)]
+pub struct Call2<E: Environment, B> {
+    dest: sp_runtime::MultiAddress<E::AccountId, ()>,
+    #[codec(compact)]
+    value: B,
+    gas_limit: Weight,
+    storage_deposit_limit: Option<B>,
+    data: Vec<u8>,
+}
+
+/// A raw call to `pallet-contracts`'s `call`.
+#[derive(Debug, scale::Encode, scale::Decode)]
+pub struct Transfer<E: Environment, C: subxt::Config> {
+    dest: C::Address,
+    #[codec(compact)]
+    value: E::Balance,
+}
+
 #[derive(
     Debug, Clone, Copy, scale::Encode, scale::Decode, PartialEq, Eq, serde::Serialize,
 )]
@@ -167,10 +186,7 @@ where
     sr25519::Signature: Into<C::Signature>,
 
     E: Environment,
-    E::Balance: scale::Encode + serde::Serialize,
-
-    Call<E, E::Balance>: scale::Encode,
-    InstantiateWithCode<E::Balance>: scale::Encode,
+    E::Balance: scale::HasCompact + serde::Serialize,
 {
     /// Creates a new [`ContractsApi`] instance.
     pub async fn new(client: OnlineClient<C>, url: &str) -> Self {
@@ -189,6 +205,40 @@ where
         }
     }
 
+    /// Attempt to transfer the `value` from `origin` to `dest`.
+    ///
+    /// Returns `Ok` on success, and a [`subxt::Error`] if the extrinsic is
+    /// invalid (e.g. out of date nonce)
+    pub async fn try_transfer_balance(
+        &self,
+        origin: &Signer<C>,
+        dest: C::AccountId,
+        value: E::Balance,
+    ) -> Result<(), subxt::Error> {
+        let call = subxt::tx::StaticTxPayload::new(
+            "Balances",
+            "transfer",
+            Transfer::<E, C> {
+                dest: dest.into(),
+                value,
+            },
+            Default::default(),
+        )
+        .unvalidated();
+
+        let tx_progress = self
+            .client
+            .tx()
+            .sign_and_submit_then_watch_default(&call, origin)
+            .await?;
+
+        tx_progress.wait_for_in_block().await.unwrap_or_else(|err| {
+            panic!("error on call `wait_for_in_block`: {:?}", err);
+        });
+
+        Ok(())
+    }
+
     /// Dry runs the instantiation of the given `code`.
     pub async fn instantiate_with_code_dry_run(
         &self,

crates/env/Cargo.toml

@@ -49,6 +49,9 @@ secp256k1 = { version = "0.26.0", features = ["recovery", "global-context"], opt
 # Never use this crate outside the off-chain environment!
 scale-info = { version = "2.3", default-features = false, features = ["derive"], optional = true }
 
+[dev-dependencies]
+ink = { path = "../ink" }
+
 [features]
 default = ["std"]
 std = [

crates/env/src/api.rs

@@ -23,8 +23,10 @@ use crate::{
     call::{
         Call,
         CallParams,
+        ConstructorReturnType,
         CreateParams,
         DelegateCall,
+        FromAccountId,
     },
     engine::{
         EnvInstance,
@@ -323,50 +325,20 @@ where
 /// - If the instantiation process runs out of gas.
 /// - If given insufficient endowment.
 /// - 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>>
-where
-    E: Environment,
-    Args: scale::Encode,
-    Salt: AsRef<[u8]>,
-{
-    <EnvInstance as OnInstance>::on_instance(|instance| {
-        TypedEnvBackend::instantiate_contract::<E, Args, Salt, R>(instance, params)
-    })
-}
-
-/// Attempts to instantiate another contract, returning the instantiation result back to the
-/// caller.
-///
-/// # Note
-///
-/// This is a low level way to instantiate another smart contract.
-///
-/// Prefer to use methods on a `ContractRef` or the [`CreateBuilder`](`crate::call::CreateBuilder`)
-/// through [`build_create`](`crate::call::build_create`) instead.
-///
-/// # Errors
-///
-/// - If the code hash is invalid.
-/// - If the arguments passed to the instantiation process are invalid.
-/// - If the instantiation process traps.
-/// - If the instantiation process runs out of gas.
-/// - If given insufficient endowment.
-/// - If the returned account ID failed to decode properly.
-pub fn instantiate_fallible_contract<E, Args, Salt, R, ContractError>(
-    params: &CreateParams<E, Args, Salt, R>,
+pub fn instantiate_contract<E, ContractRef, Args, Salt, R>(
+    params: &CreateParams<E, ContractRef, Args, Salt, R>,
 ) -> Result<
-    ink_primitives::ConstructorResult<core::result::Result<E::AccountId, ContractError>>,
+    ink_primitives::ConstructorResult<<R as ConstructorReturnType<ContractRef>>::Output>,
 >
 where
     E: Environment,
+    ContractRef: FromAccountId<E>,
     Args: scale::Encode,
     Salt: AsRef<[u8]>,
-    ContractError: scale::Decode,
+    R: ConstructorReturnType<ContractRef>,
 {
     <EnvInstance as OnInstance>::on_instance(|instance| {
-        TypedEnvBackend::instantiate_fallible_contract::<E, Args, Salt, R, ContractError>(
+        TypedEnvBackend::instantiate_contract::<E, ContractRef, Args, Salt, R>(
             instance, params,
         )
     })

crates/env/src/backend.rs

@@ -16,8 +16,10 @@ use crate::{
     call::{
         Call,
         CallParams,
+        ConstructorReturnType,
         CreateParams,
         DelegateCall,
+        FromAccountId,
     },
     hash::{
         CryptoHash,
@@ -439,34 +441,20 @@ pub trait TypedEnvBackend: EnvBackend {
     /// # Note
     ///
     /// For more details visit: [`instantiate_contract`][`crate::instantiate_contract`]
-    fn instantiate_contract<E, Args, Salt, R>(
+    fn instantiate_contract<E, ContractRef, Args, Salt, R>(
         &mut self,
-        params: &CreateParams<E, Args, Salt, R>,
-    ) -> Result<ink_primitives::ConstructorResult<E::AccountId>>
-    where
-        E: Environment,
-        Args: scale::Encode,
-        Salt: AsRef<[u8]>;
-
-    /// Attempts to instantiate another contract, returning the instantiation result back to the
-    /// caller.
-    ///
-    /// # Note
-    ///
-    /// For more details visit: [`instantiate_fallible_contract`][`crate::instantiate_fallible_contract`]
-    fn instantiate_fallible_contract<E, Args, Salt, R, ContractError>(
-        &mut self,
-        params: &CreateParams<E, Args, Salt, R>,
+        params: &CreateParams<E, ContractRef, Args, Salt, R>,
     ) -> Result<
         ink_primitives::ConstructorResult<
-            core::result::Result<E::AccountId, ContractError>,
+            <R as ConstructorReturnType<ContractRef>>::Output,
         >,
     >
     where
         E: Environment,
+        ContractRef: FromAccountId<E>,
         Args: scale::Encode,
         Salt: AsRef<[u8]>,
-        ContractError: scale::Decode;
+        R: ConstructorReturnType<ContractRef>;
 
     /// Terminates a smart contract.
     ///