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

workspaces/src/network/mod.rs

@@ -25,6 +25,6 @@ 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,
+    NetworkClient, NetworkInfo, RootAccountSubaccountCreator, TopLevelAccountCreator,
 };
 pub use config::set_sandbox_genesis;

workspaces/src/network/sandbox.rs

@@ -1,3 +1,4 @@
+use std::convert::TryFrom;
 use std::path::PathBuf;
 use std::str::FromStr;
 
@@ -9,8 +10,8 @@ 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::{NetworkClient, NetworkInfo, RootAccountSubaccountCreator, TopLevelAccountCreator};
+use crate::error::{ErrorKind, SandboxErrorCode};
 use crate::network::server::SandboxServer;
 use crate::network::Info;
 use crate::result::{Execution, ExecutionFinalResult, Result};
@@ -36,16 +37,7 @@ pub struct Sandbox {
 
 impl Sandbox {
     pub(crate) fn root_signer(&self) -> Result<InMemorySigner> {
-        match &self.server.validator_key {
-            ValidatorKey::HomeDir(home_dir) => {
-                let path = home_dir.join("validator_key.json");
-                InMemorySigner::from_file(&path)
-            }
-            ValidatorKey::Known(account_id, secret_key) => Ok(InMemorySigner::from_secret_key(
-                account_id.clone(),
-                secret_key.clone(),
-            )),
-        }
+        InMemorySigner::try_from(self.server.validator_key.clone())
     }
 
     pub(crate) fn registrar_signer(&self) -> Result<InMemorySigner> {
@@ -95,9 +87,11 @@ impl Sandbox {
         // lockfiles as soon as possible.
         server.unlock_lockfiles()?;
 
+        let root_id = InMemorySigner::try_from(server.validator_key.clone())?.account_id;
+
         let info = Info {
             name: build.name.into(),
-            root_id: AccountId::from_str("test.near").unwrap(),
+            root_id,
             keystore_path: PathBuf::from(".near-credentials/sandbox/"),
             rpc_url: url::Url::parse(&server.rpc_addr()).expect("url is hardcoded"),
         };
@@ -130,8 +124,6 @@ impl FromNetworkBuilder for Sandbox {
     }
 }
 
-impl AllowDevAccountCreation for Sandbox {}
-
 #[async_trait]
 impl TopLevelAccountCreator for Sandbox {
     async fn create_tla(
@@ -145,7 +137,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),
@@ -171,7 +162,61 @@ 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 RootAccountSubaccountCreator for Sandbox {
+    fn root_account_id(&self) -> Result<AccountId> {
+        Ok(self.root_signer()?.account_id)
+    }
+
+    async fn create_root_account_subaccount(
+        &self,
+        worker: Worker<dyn Network>,
+        subaccount_prefix: AccountId,
+        sk: SecretKey,
+    ) -> Result<Execution<Account>> {
+        let root_id = self.root_account_id()?;
+        let id = AccountId::from_str(format!("{}.{}", subaccount_prefix, 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_root_account_subaccount_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/server.rs

@@ -75,7 +75,7 @@ async fn init_home_dir_with_version(version: &str) -> Result<TempDir> {
     Ok(home_dir)
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 #[non_exhaustive]
 pub enum ValidatorKey {
     HomeDir(PathBuf),

workspaces/src/network/testnet.rs

@@ -7,9 +7,10 @@ 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::{NetworkClient, NetworkInfo, RootAccountSubaccountCreator};
 use crate::result::{Execution, ExecutionDetails, ExecutionFinalResult, ExecutionOutcome, Result};
 use crate::rpc::{client::Client, tool};
 use crate::types::{AccountId, InMemorySigner, NearToken, SecretKey};
@@ -18,7 +19,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.
@@ -65,18 +66,26 @@ impl std::fmt::Debug for Testnet {
     }
 }
 
-impl AllowDevAccountCreation for Testnet {}
-
 #[async_trait]
-impl TopLevelAccountCreator for Testnet {
-    async fn create_tla(
+impl RootAccountSubaccountCreator for Testnet {
+    fn root_account_id(&self) -> Result<AccountId> {
+        Ok(self.info().root_id.clone())
+    }
+
+    async fn create_root_account_subaccount(
         &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();
+        let root_id = self
+            .root_account_id()
+            .expect("no source of error expected on testnet");
+        //only registrar can create tla on testnet, so must concatenate random created id with .testnet
+        let id = AccountId::from_str(format!("{}.{}", subaccount_prefix, 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);
 
@@ -105,17 +114,22 @@ impl TopLevelAccountCreator for Testnet {
         })
     }
 
-    async fn create_tla_and_deploy(
+    async fn create_root_account_subaccount_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_root_account_subaccount(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()?),