refactor!: Reorganize exports and modules exposed

examples/src/ref_finance.rs

@@ -1,6 +1,7 @@
 use std::{collections::HashMap, convert::TryInto};
 
 use near_units::{parse_gas, parse_near};
+use workspaces::network::Sandbox;
 use workspaces::{prelude::*, BlockHeight, DevNetwork};
 use workspaces::{Account, AccountId, Contract, Network, Worker};
 
@@ -15,10 +16,7 @@ const BLOCK_HEIGHT: BlockHeight = 50_000_000;
 
 /// Pull down the ref-finance contract and deploy it to the sandbox network,
 /// initializing it with all data required to run the tests.
-async fn create_ref(
-    owner: &Account,
-    worker: &Worker<impl Network + StatePatcher>,
-) -> anyhow::Result<Contract> {
+async fn create_ref(owner: &Account, worker: &Worker<Sandbox>) -> anyhow::Result<Contract> {
     let mainnet = workspaces::mainnet_archival();
     let ref_finance_id: AccountId = REF_FINANCE_ACCOUNT_ID.parse()?;
 
@@ -56,10 +54,7 @@ async fn create_ref(
 }
 
 /// Pull down the WNear contract from mainnet and initilize it with our own metadata.
-async fn create_wnear(
-    owner: &Account,
-    worker: &Worker<impl Network + StatePatcher>,
-) -> anyhow::Result<Contract> {
+async fn create_wnear(owner: &Account, worker: &Worker<Sandbox>) -> anyhow::Result<Contract> {
     let mainnet = workspaces::mainnet_archival();
     let wnear_id: AccountId = "wrap.near".to_string().try_into()?;
     let wnear = worker

workspaces/src/lib.rs

@@ -3,16 +3,18 @@ mod cargo;
 #[cfg(feature = "unstable")]
 pub use cargo::compile_project;
 
-mod network;
 mod rpc;
 mod types;
 mod worker;
 
+pub mod network;
+pub mod operations;
 pub mod prelude;
+pub mod result;
 
-pub use network::result;
-pub use network::transaction::Function;
-pub use network::{Account, AccountDetails, Block, Contract, DevNetwork, Network};
+pub use network::variants::{DevNetwork, Network};
+pub use types::account::{Account, AccountDetails, Contract};
+pub use types::block::Block;
 pub use types::{AccessKey, AccountId, BlockHeight, CryptoHash, InMemorySigner};
 pub use worker::{
     mainnet, mainnet_archival, sandbox, testnet, testnet_archival, with_mainnet,

workspaces/src/network/mainnet.rs

@@ -3,10 +3,11 @@ use std::path::PathBuf;
 use async_trait::async_trait;
 
 use crate::network::Info;
-use crate::network::{Account, CallExecution, NetworkClient, NetworkInfo, TopLevelAccountCreator};
+use crate::network::{NetworkClient, NetworkInfo, TopLevelAccountCreator};
+use crate::result::CallExecution;
 use crate::rpc::client::Client;
 use crate::types::{AccountId, SecretKey};
-use crate::Contract;
+use crate::{Account, Contract};
 
 const RPC_URL: &str = "https://rpc.mainnet.near.org";
 const ARCHIVAL_URL: &str = "https://archival-rpc.mainnet.near.org";

workspaces/src/network/mod.rs

@@ -1,154 +1,20 @@
-mod account;
-mod block;
+//! All builtin network types and traits.
+//!
+//! Currently the builtin network types are [`Mainnet`], [`Testnet`], and [`Sandbox`].
+
 mod info;
 mod mainnet;
-pub mod result;
 mod sandbox;
 mod server;
 mod testnet;
+pub(crate) mod variants;
 
-pub mod transaction;
-
-use async_trait::async_trait;
-
-use near_jsonrpc_client::methods::sandbox_patch_state::RpcSandboxPatchStateRequest;
-use near_primitives::state_record::StateRecord;
-
-pub(crate) use crate::network::info::Info;
-use crate::rpc::client::Client;
-use crate::rpc::patch::ImportContractTransaction;
-use crate::types::{AccountId, KeyType, SecretKey};
-use crate::Worker;
-
-pub use crate::network::account::{Account, AccountDetails, Contract};
-pub use crate::network::block::Block;
-pub use crate::network::mainnet::Mainnet;
-pub use crate::network::result::{CallExecution, CallExecutionDetails, ViewResultDetails};
-pub use crate::network::sandbox::Sandbox;
-pub use crate::network::testnet::Testnet;
-
-pub(crate) const DEV_ACCOUNT_SEED: &str = "testificate";
-
-pub trait NetworkClient {
-    fn client(&self) -> &Client;
-}
-
-pub trait NetworkInfo {
-    fn info(&self) -> &Info;
-}
-
-#[async_trait]
-pub trait TopLevelAccountCreator {
-    async fn create_tla(
-        &self,
-        id: AccountId,
-        sk: SecretKey,
-    ) -> anyhow::Result<CallExecution<Account>>;
-
-    async fn create_tla_and_deploy(
-        &self,
-        id: AccountId,
-        sk: SecretKey,
-        wasm: &[u8],
-    ) -> anyhow::Result<CallExecution<Contract>>;
-}
-
-// NOTE: Not all networks/runtimes will have the ability to be able to do dev_deploy.
-// This trait acts as segmented boundary for only specific networks such as sandbox and testnet.
-pub trait AllowDevAccountCreation {}
-
-#[async_trait]
-pub trait DevAccountDeployer {
-    async fn dev_generate(&self) -> (AccountId, SecretKey);
-    async fn dev_create_account(&self) -> anyhow::Result<Account>;
-    async fn dev_deploy(&self, wasm: &[u8]) -> anyhow::Result<Contract>;
-}
-
-#[async_trait]
-impl<T> DevAccountDeployer for T
-where
-    T: TopLevelAccountCreator + NetworkInfo + AllowDevAccountCreation + Send + Sync,
-{
-    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);
-        (id, sk)
-    }
-
-    async fn dev_create_account(&self) -> anyhow::Result<Account> {
-        let (id, sk) = self.dev_generate().await;
-        let account = self.create_tla(id.clone(), sk).await?;
-        account.into()
-    }
-
-    async fn dev_deploy(&self, wasm: &[u8]) -> anyhow::Result<Contract> {
-        let (id, sk) = self.dev_generate().await;
-        let contract = self.create_tla_and_deploy(id.clone(), sk, wasm).await?;
-        contract.into()
-    }
-}
-
-pub trait AllowStatePatching {}
-
-#[async_trait]
-pub trait StatePatcher {
-    async fn patch_state(
-        &self,
-        contract_id: &AccountId,
-        key: &[u8],
-        value: &[u8],
-    ) -> anyhow::Result<()>;
-
-    fn import_contract<'a, 'b>(
-        &'b self,
-        id: &AccountId,
-        worker: &'a Worker<impl Network>,
-    ) -> ImportContractTransaction<'a, 'b>;
-}
-
-#[async_trait]
-impl<T> StatePatcher for T
-where
-    T: AllowStatePatching + NetworkClient + Send + Sync,
-{
-    async fn patch_state(
-        &self,
-        contract_id: &AccountId,
-        key: &[u8],
-        value: &[u8],
-    ) -> anyhow::Result<()> {
-        let state = StateRecord::Data {
-            account_id: contract_id.to_owned(),
-            data_key: key.to_vec(),
-            value: value.to_vec(),
-        };
-        let records = vec![state];
-
-        // NOTE: RpcSandboxPatchStateResponse is an empty struct with no fields, so don't do anything with it:
-        let _patch_resp = self
-            .client()
-            .query(&RpcSandboxPatchStateRequest { records })
-            .await
-            .map_err(|err| anyhow::anyhow!("Failed to patch state: {:?}", err))?;
-
-        Ok(())
-    }
-
-    fn import_contract<'a, 'b>(
-        &'b self,
-        id: &AccountId,
-        worker: &'a Worker<impl Network>,
-    ) -> ImportContractTransaction<'a, 'b> {
-        ImportContractTransaction::new(id.to_owned(), worker.client(), self.client())
-    }
-}
-
-pub trait Network: TopLevelAccountCreator + NetworkInfo + NetworkClient + Send + Sync {}
-
-impl<T> Network for T where T: TopLevelAccountCreator + NetworkInfo + NetworkClient + Send + Sync {}
-
-/// DevNetwork is a Network that can call into `dev_create` and `dev_deploy` to create developer accounts.
-pub trait DevNetwork: AllowDevAccountCreation + Network {}
+pub(crate) use variants::DEV_ACCOUNT_SEED;
 
-// Implemented by default if we have `AllowDevAccountCreation`
-impl<T> DevNetwork for T where T: AllowDevAccountCreation + Network {}
+pub use self::info::Info;
+pub use self::mainnet::Mainnet;
+pub use self::sandbox::Sandbox;
+pub use self::testnet::Testnet;
+pub use self::variants::{
+    AllowDevAccountCreation, DevAccountDeployer, NetworkClient, NetworkInfo, TopLevelAccountCreator,
+};

workspaces/src/network/sandbox.rs

@@ -3,15 +3,13 @@ use std::str::FromStr;
 
 use async_trait::async_trait;
 
-use super::{
-    Account, AllowDevAccountCreation, AllowStatePatching, CallExecution, Contract, NetworkClient,
-    NetworkInfo, TopLevelAccountCreator,
-};
-
+use super::{AllowDevAccountCreation, NetworkClient, NetworkInfo, TopLevelAccountCreator};
 use crate::network::server::SandboxServer;
 use crate::network::Info;
+use crate::result::CallExecution;
 use crate::rpc::client::Client;
 use crate::types::{AccountId, Balance, InMemorySigner, SecretKey};
+use crate::{Account, Contract};
 
 // Constant taken from nearcore crate to avoid dependency
 pub(crate) const NEAR_BASE: Balance = 1_000_000_000_000_000_000_000_000;
@@ -58,8 +56,6 @@ impl Sandbox {
     }
 }
 
-impl AllowStatePatching for Sandbox {}
-
 impl AllowDevAccountCreation for Sandbox {}
 
 #[async_trait]

workspaces/src/network/testnet.rs

@@ -7,14 +7,11 @@ use url::Url;
 use near_primitives::views::{ExecutionStatusView, FinalExecutionStatus};
 
 use crate::network::Info;
-use crate::network::{
-    Account, AllowDevAccountCreation, CallExecution, CallExecutionDetails, NetworkClient,
-    NetworkInfo, TopLevelAccountCreator,
-};
-use crate::result::ExecutionOutcome;
+use crate::network::{AllowDevAccountCreation, NetworkClient, NetworkInfo, TopLevelAccountCreator};
+use crate::result::{CallExecution, CallExecutionDetails, ExecutionOutcome};
 use crate::rpc::{client::Client, tool};
 use crate::types::{AccountId, InMemorySigner, SecretKey};
-use crate::{Contract, CryptoHash};
+use crate::{Account, Contract, CryptoHash};
 
 const RPC_URL: &str = "https://rpc.testnet.near.org";
 const HELPER_URL: &str = "https://helper.testnet.near.org";

workspaces/src/network/variants.rs

@@ -0,0 +1,77 @@
+use crate::network::Info;
+use crate::result::CallExecution;
+use crate::rpc::client::Client;
+use crate::types::{AccountId, KeyType, SecretKey};
+use crate::{Account, Contract};
+use async_trait::async_trait;
+
+pub(crate) const DEV_ACCOUNT_SEED: &str = "testificate";
+
+pub trait NetworkClient {
+    fn client(&self) -> &Client;
+}
+
+pub trait NetworkInfo {
+    fn info(&self) -> &Info;
+}
+
+#[async_trait]
+pub trait TopLevelAccountCreator {
+    async fn create_tla(
+        &self,
+        id: AccountId,
+        sk: SecretKey,
+    ) -> anyhow::Result<CallExecution<Account>>;
+
+    async fn create_tla_and_deploy(
+        &self,
+        id: AccountId,
+        sk: SecretKey,
+        wasm: &[u8],
+    ) -> anyhow::Result<CallExecution<Contract>>;
+}
+
+// NOTE: Not all networks/runtimes will have the ability to be able to do dev_deploy.
+// This trait acts as segmented boundary for only specific networks such as sandbox and testnet.
+pub trait AllowDevAccountCreation {}
+
+#[async_trait]
+pub trait DevAccountDeployer {
+    async fn dev_generate(&self) -> (AccountId, SecretKey);
+    async fn dev_create_account(&self) -> anyhow::Result<Account>;
+    async fn dev_deploy(&self, wasm: &[u8]) -> anyhow::Result<Contract>;
+}
+
+#[async_trait]
+impl<T> DevAccountDeployer for T
+where
+    T: TopLevelAccountCreator + NetworkInfo + AllowDevAccountCreation + Send + Sync,
+{
+    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);
+        (id, sk)
+    }
+
+    async fn dev_create_account(&self) -> anyhow::Result<Account> {
+        let (id, sk) = self.dev_generate().await;
+        let account = self.create_tla(id.clone(), sk).await?;
+        account.into()
+    }
+
+    async fn dev_deploy(&self, wasm: &[u8]) -> anyhow::Result<Contract> {
+        let (id, sk) = self.dev_generate().await;
+        let contract = self.create_tla_and_deploy(id.clone(), sk, wasm).await?;
+        contract.into()
+    }
+}
+
+pub trait Network: TopLevelAccountCreator + NetworkInfo + NetworkClient + Send + Sync {}
+
+impl<T> Network for T where T: TopLevelAccountCreator + NetworkInfo + NetworkClient + Send + Sync {}
+
+/// DevNetwork is a Network that can call into `dev_create` and `dev_deploy` to create developer accounts.
+pub trait DevNetwork: AllowDevAccountCreation + Network {}
+
+// Implemented by default if we have `AllowDevAccountCreation`
+impl<T> DevNetwork for T where T: AllowDevAccountCreation + Network {}

workspaces/src/network/transaction.rs → workspaces/src/operations.rs

@@ -1,19 +1,20 @@
-use std::convert::TryInto;
-
-use near_crypto::KeyType;
-use near_primitives::transaction::{
-    Action, AddKeyAction, CreateAccountAction, DeleteAccountAction, DeleteKeyAction,
-    DeployContractAction, FunctionCallAction, StakeAction, TransferAction,
-};
-use near_primitives::views::FinalExecutionOutcomeView;
+//! All operation types that are generated/used when making transactions or view calls.
 
-use crate::network::{CallExecution, CallExecutionDetails, Network, ViewResultDetails};
+use crate::result::{CallExecution, CallExecutionDetails, ViewResultDetails};
 use crate::rpc::client::{
     send_batch_tx_and_retry, Client, DEFAULT_CALL_DEPOSIT, DEFAULT_CALL_FN_GAS,
 };
 use crate::types::{AccessKey, AccountId, Balance, Gas, InMemorySigner, PublicKey, SecretKey};
 use crate::worker::Worker;
 use crate::Account;
+use crate::Network;
+use near_crypto::KeyType;
+use near_primitives::transaction::{
+    Action, AddKeyAction, CreateAccountAction, DeleteAccountAction, DeleteKeyAction,
+    DeployContractAction, FunctionCallAction, StakeAction, TransferAction,
+};
+use near_primitives::views::FinalExecutionOutcomeView;
+use std::convert::TryInto;
 
 const MAX_GAS: Gas = 300_000_000_000_000;
 

workspaces/src/prelude.rs

@@ -1 +1 @@
-pub use crate::network::{DevAccountDeployer, StatePatcher, TopLevelAccountCreator};
+pub use crate::network::{DevAccountDeployer, TopLevelAccountCreator};

workspaces/src/network/result.rs → workspaces/src/result.rs

@@ -1,3 +1,5 @@
+//! Result and execution types from results of RPC calls to the network.
+
 use near_account_id::AccountId;
 use near_primitives::views::{
     CallResult, ExecutionOutcomeWithIdView, ExecutionStatusView, FinalExecutionOutcomeView,