feat!: worker.dev_create_account, worker.dev_deploy create subaccounts of root account instead of tla (sandbox, testnet)

.github/workflows/test.yml

@@ -47,7 +47,7 @@ jobs:
     needs: cargo-fmt
     strategy:
       matrix:
-        platform: [ubuntu-latest, macos-latest]
+        platform: [macos-latest, ubuntu-latest]
         toolchain: [stable]
     runs-on: ${{ matrix.platform }}
 

examples/src/ref_finance.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::convert::TryInto;
 
 use near_gas::NearGas;
-use near_workspaces::network::Sandbox;
+use near_workspaces::network::{Sandbox, SponsoredAccountCreator};
 use near_workspaces::types::NearToken;
 use near_workspaces::{Account, AccountId, Contract, Worker};
 use near_workspaces::{BlockHeight, DevNetwork};
@@ -187,7 +187,7 @@ async fn deposit_tokens(
 /// Create our own custom Fungible Token contract and setup the initial state.
 async fn create_custom_ft(
     owner: &Account,
-    worker: &Worker<impl DevNetwork>,
+    worker: &Worker<impl DevNetwork + SponsoredAccountCreator>,
 ) -> anyhow::Result<Contract> {
     let ft: Contract = worker
         .dev_deploy(&std::fs::read(FT_CONTRACT_FILEPATH)?)

examples/src/spooning.rs

@@ -1,6 +1,7 @@
 use std::env;
 
 use near_primitives::borsh::{BorshDeserialize, BorshSerialize};
+use near_workspaces::network::SponsoredAccountCreator;
 use near_workspaces::{AccountId, Contract, DevNetwork, Worker};
 use serde_json::json;
 use tracing::info;
@@ -46,7 +47,7 @@ struct StatusMessage {
 /// For example, our predeployed testnet contract has already done this:
 ///    set_status(TESTNET_PREDEPLOYED_CONTRACT_ID) = "hello from testnet"
 async fn deploy_status_contract(
-    worker: &Worker<impl DevNetwork>,
+    worker: &Worker<impl DevNetwork + SponsoredAccountCreator>,
     msg: &str,
 ) -> anyhow::Result<Contract> {
     let wasm = std::fs::read(STATUS_MSG_WASM_FILEPATH)?;

workspaces/src/network/mod.rs

@@ -25,6 +25,7 @@ pub use self::sandbox::Sandbox;
 pub use self::server::{pick_unused_port, ValidatorKey};
 pub use self::testnet::Testnet;
 pub use self::variants::{
-    AllowDevAccountCreation, NetworkClient, NetworkInfo, TopLevelAccountCreator,
+    AllowDevAccountCreation, NetworkClient, NetworkInfo, SponsoredAccountCreator,
+    TopLevelAccountCreator,
 };
 pub use config::set_sandbox_genesis;

workspaces/src/network/sandbox.rs

@@ -9,8 +9,11 @@ use near_sandbox_utils as sandbox;
 
 use super::builder::{FromNetworkBuilder, NetworkBuilder};
 use super::server::ValidatorKey;
-use super::{AllowDevAccountCreation, NetworkClient, NetworkInfo, TopLevelAccountCreator};
-use crate::error::SandboxErrorCode;
+use super::{
+    AllowDevAccountCreation, NetworkClient, NetworkInfo, SponsoredAccountCreator,
+    TopLevelAccountCreator,
+};
+use crate::error::{ErrorKind, SandboxErrorCode};
 use crate::network::server::SandboxServer;
 use crate::network::Info;
 use crate::result::{Execution, ExecutionFinalResult, Result};
@@ -143,7 +146,6 @@ impl TopLevelAccountCreator for Sandbox {
             .client()
             .create_account(&root_signer, &id, sk.public_key(), DEFAULT_DEPOSIT)
             .await?;
-
         let signer = InMemorySigner::from_secret_key(id, sk);
         Ok(Execution {
             result: Account::new(signer, worker),
@@ -169,7 +171,57 @@ impl TopLevelAccountCreator for Sandbox {
                 wasm.into(),
             )
             .await?;
+        let signer = InMemorySigner::from_secret_key(id, sk);
+        Ok(Execution {
+            result: Contract::new(signer, worker),
+            details: ExecutionFinalResult::from_view(outcome),
+        })
+    }
+}
 
+#[async_trait]
+impl SponsoredAccountCreator for Sandbox {
+    async fn create_sponsored_account(
+        &self,
+        worker: Worker<dyn Network>,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+    ) -> Result<Execution<Account>> {
+        let id =
+            AccountId::from_str(format!("{}.{}", subaccount_prefix, self.info().root_id).as_str())
+                .map_err(|e| ErrorKind::DataConversion.custom(e))?;
+        let root_signer = self.root_signer()?;
+        let outcome = self
+            .client()
+            .create_account(&root_signer, &id, sk.public_key(), DEFAULT_DEPOSIT)
+            .await?;
+        let signer = InMemorySigner::from_secret_key(id, sk);
+        Ok(Execution {
+            result: Account::new(signer, worker),
+            details: ExecutionFinalResult::from_view(outcome),
+        })
+    }
+    async fn create_sponsored_account_and_deploy(
+        &self,
+        worker: Worker<dyn Network>,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+        wasm: &[u8],
+    ) -> Result<Execution<Contract>> {
+        let id =
+            AccountId::from_str(format!("{}.{}", subaccount_prefix, self.info().root_id).as_str())
+                .map_err(|e| ErrorKind::DataConversion.custom(e))?;
+        let root_signer = self.root_signer()?;
+        let outcome = self
+            .client()
+            .create_account_and_deploy(
+                &root_signer,
+                &id,
+                sk.public_key(),
+                DEFAULT_DEPOSIT,
+                wasm.into(),
+            )
+            .await?;
         let signer = InMemorySigner::from_secret_key(id, sk);
         Ok(Execution {
             result: Contract::new(signer, worker),

workspaces/src/network/testnet.rs

@@ -7,9 +7,12 @@ use url::Url;
 
 use near_primitives::views::ExecutionStatusView;
 
+use crate::error::ErrorKind;
 use crate::network::builder::{FromNetworkBuilder, NetworkBuilder};
 use crate::network::Info;
-use crate::network::{AllowDevAccountCreation, NetworkClient, NetworkInfo, TopLevelAccountCreator};
+use crate::network::{
+    AllowDevAccountCreation, NetworkClient, NetworkInfo, SponsoredAccountCreator,
+};
 use crate::result::{Execution, ExecutionDetails, ExecutionFinalResult, ExecutionOutcome, Result};
 use crate::rpc::{client::Client, tool};
 use crate::types::{AccountId, InMemorySigner, NearToken, SecretKey};
@@ -18,7 +21,7 @@ use crate::{Account, Contract, CryptoHash, Network, Worker};
 /// URL to the testnet RPC node provided by near.org.
 pub const RPC_URL: &str = "https://rpc.testnet.near.org";
 
-/// URL to the helper contract used to create top-level-accounts (TLA) provided by near.org.
+/// URL to the helper contract used to create named accounts provided by near.org.
 pub const HELPER_URL: &str = "https://helper.testnet.near.org";
 
 /// URL to the testnet archival RPC node provided by near.org.
@@ -67,15 +70,19 @@ impl std::fmt::Debug for Testnet {
 impl AllowDevAccountCreation for Testnet {}
 
 #[async_trait]
-impl TopLevelAccountCreator for Testnet {
-    async fn create_tla(
+impl SponsoredAccountCreator for Testnet {
+    async fn create_sponsored_account(
         &self,
         worker: Worker<dyn Network>,
-        id: AccountId,
+        subaccount_prefix: AccountId,
         sk: SecretKey,
         // TODO: return Account only, but then you don't get metadata info for it...
     ) -> Result<Execution<Account>> {
         let url = Url::parse(HELPER_URL).unwrap();
+        //only registrar can create tla on testnet, so must concatenate random created id with .testnet
+        let id =
+            AccountId::from_str(format!("{}.{}", subaccount_prefix, self.info().root_id).as_str())
+                .map_err(|e| ErrorKind::DataConversion.custom(e))?;
         tool::url_create_account(url, id.clone(), sk.public_key()).await?;
         let signer = InMemorySigner::from_secret_key(id, sk);
 
@@ -104,17 +111,22 @@ impl TopLevelAccountCreator for Testnet {
         })
     }
 
-    async fn create_tla_and_deploy(
+    async fn create_sponsored_account_and_deploy(
         &self,
         worker: Worker<dyn Network>,
-        id: AccountId,
+        subaccount_prefix: AccountId,
         sk: SecretKey,
         wasm: &[u8],
     ) -> Result<Execution<Contract>> {
-        let signer = InMemorySigner::from_secret_key(id.clone(), sk.clone());
-        let account = self.create_tla(worker, id.clone(), sk).await?;
-
-        let outcome = self.client().deploy(&signer, &id, wasm.into()).await?;
+        let signer = InMemorySigner::from_secret_key(subaccount_prefix.clone(), sk.clone());
+        let account = self
+            .create_sponsored_account(worker, subaccount_prefix.clone(), sk)
+            .await?;
+
+        let outcome = self
+            .client()
+            .deploy(&signer, &subaccount_prefix, wasm.into())
+            .await?;
 
         Ok(Execution {
             result: Contract::account(account.into_result()?),

workspaces/src/network/variants.rs

@@ -15,6 +15,29 @@ pub trait NetworkInfo {
     fn info(&self) -> &Info;
 }
 
+/// Trait provides the ability to create a sponsored account. A sponsored account is a subaccount
+/// of the network's root account. The `subaccount_prefix` is a prefix for the subaccount ID.
+/// For example, if this parameter is `"subaccount"`, the full ID for testnet will be `"subaccount.testnet"`.
+///
+/// It is expected that the `subaccount_prefix` does not contain a `.`.
+#[async_trait]
+pub trait SponsoredAccountCreator {
+    async fn create_sponsored_account(
+        &self,
+        worker: Worker<dyn Network>,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+    ) -> Result<Execution<Account>>;
+
+    async fn create_sponsored_account_and_deploy(
+        &self,
+        worker: Worker<dyn Network>,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+        wasm: &[u8],
+    ) -> Result<Execution<Contract>>;
+}
+
 #[async_trait]
 pub trait TopLevelAccountCreator {
     async fn create_tla(
@@ -33,7 +56,7 @@ pub trait TopLevelAccountCreator {
     ) -> Result<Execution<Contract>>;
 }
 
-// NOTE: Not all networks/runtimes will have the ability to be able to do dev_deploy.
+// NOTE: Not all networks/runtimes will have the ability to be able to do dev_deploy or dev_deploy_tla.
 // This trait acts as segmented boundary for only specific networks such as sandbox and testnet.
 pub trait AllowDevAccountCreation {}
 
@@ -72,6 +95,80 @@ where
         Ok(res)
     }
 
+    pub async fn generate_tla_credentials(&self) -> (AccountId, SecretKey) {
+        let id = crate::rpc::tool::random_account_id();
+        let sk = SecretKey::from_seed(KeyType::ED25519, DEV_ACCOUNT_SEED);
+        (id, sk)
+    }
+
+    /// Creates a top level developement account.
+    /// On sandbox network it has a balance of 100 Near.
+    /// If you need more Near for your tests in sandbox consider using `root_account()` method:
+    ///
+    /// # Examples
+    /// ```
+    /// use near_workspaces::{result::Result, Account, network::Sandbox, Worker};
+    /// fn get_account_with_lots_of_near(worker: &Worker<Sandbox>) -> Result<Account> {
+    ///     worker.root_account()
+    /// }
+    /// ```
+    ///
+    pub async fn dev_create_tla(&self) -> Result<Account> {
+        let (id, sk) = self.generate_tla_credentials().await;
+        let account = self.create_tla(id.clone(), sk).await?;
+        Ok(account.into_result()?)
+    }
+
+    pub async fn dev_deploy_tla(&self, wasm: &[u8]) -> Result<Contract> {
+        let (id, sk) = self.generate_tla_credentials().await;
+        let contract = self.create_tla_and_deploy(id.clone(), sk, wasm).await?;
+        Ok(contract.into_result()?)
+    }
+}
+
+impl<T> Worker<T>
+where
+    T: DevNetwork + SponsoredAccountCreator + 'static,
+{
+    pub async fn create_dev_account(
+        &self,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+    ) -> Result<Execution<Account>> {
+        if subaccount_prefix.as_str().contains('.') {
+            return Err(crate::error::ErrorKind::Io
+                .custom("Subaccount prefix for sponsored account cannot contain '.'"));
+        }
+        let res = self
+            .workspace
+            .create_sponsored_account(self.clone().coerce(), subaccount_prefix, sk)
+            .await?;
+
+        for callback in self.tx_callbacks.iter() {
+            callback(res.details.total_gas_burnt)?;
+        }
+
+        Ok(res)
+    }
+
+    pub async fn create_dev_account_and_deploy(
+        &self,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+        wasm: &[u8],
+    ) -> Result<Execution<Contract>> {
+        let res = self
+            .workspace
+            .create_sponsored_account_and_deploy(self.clone().coerce(), subaccount_prefix, sk, wasm)
+            .await?;
+
+        for callback in self.tx_callbacks.iter() {
+            callback(res.details.total_gas_burnt)?;
+        }
+
+        Ok(res)
+    }
+
     pub async fn dev_generate(&self) -> (AccountId, SecretKey) {
         let id = crate::rpc::tool::random_account_id();
         let sk = SecretKey::from_seed(KeyType::ED25519, DEV_ACCOUNT_SEED);
@@ -92,13 +189,15 @@ where
     ///
     pub async fn dev_create_account(&self) -> Result<Account> {
         let (id, sk) = self.dev_generate().await;
-        let account = self.create_tla(id.clone(), sk).await?;
+        let account = self.create_dev_account(id.clone(), sk).await?;
         Ok(account.into_result()?)
     }
 
     pub async fn dev_deploy(&self, wasm: &[u8]) -> Result<Contract> {
         let (id, sk) = self.dev_generate().await;
-        let contract = self.create_tla_and_deploy(id.clone(), sk, wasm).await?;
+        let contract = self
+            .create_dev_account_and_deploy(id.clone(), sk, wasm)
+            .await?;
         Ok(contract.into_result()?)
     }
 }
@@ -110,9 +209,6 @@ pub trait Network: NetworkInfo + NetworkClient + Send + Sync {}
 impl<T> Network for T where T: NetworkInfo + NetworkClient + Send + Sync {}
 
 /// DevNetwork is a Network that can call into `dev_create` and `dev_deploy` to create developer accounts.
-pub trait DevNetwork: TopLevelAccountCreator + AllowDevAccountCreation + Network + 'static {}
+pub trait DevNetwork: AllowDevAccountCreation + Network + 'static {}
 
-impl<T> DevNetwork for T where
-    T: TopLevelAccountCreator + AllowDevAccountCreation + Network + 'static
-{
-}
+impl<T> DevNetwork for T where T: AllowDevAccountCreation + Network + 'static {}