Merge 4cd05d2 into 3e7f197

.github/workflows/release.yml

@@ -1,8 +1,8 @@
 name: release
 on:
   workflow_dispatch:
-  # pull_request:
-  #   branches: [master]
+  pull_request:
+    branches: [master]
   # push:    
     #Enable when testing release infrastructure on a branch.
     # branches: [master]
@@ -20,7 +20,7 @@ jobs:
       - name: Get the release version from the tag
         # if: env.NEAR_CLI_VERSION == ''
         run: |
-          echo "NEAR_CLI_VERSION=0.1.01" >> $GITHUB_ENV
+          echo "NEAR_CLI_VERSION=0.1.02" >> $GITHUB_ENV
           echo "version is: ${{ env.NEAR_CLI_VERSION }}"
 
       - name: Create GitHub release

Cargo.toml

@@ -33,6 +33,7 @@ dirs = "3.0"
 # The fix is needed for seemless clap integration: /~https://github.com/wusyong/slip10/pull/3
 slip10 = { git = "/~https://github.com/frol/slip10", rev = "a3235dd0acf3a485f547cf23e2dd56838adb45f8" }
 url = { version = "2", features = ["serde"] }
+url_open = "0.0.1"
 
 color-eyre = "0.5"
 

src/commands/add_command/access_key/public_key_mode/generate_keypair/mod.rs

@@ -108,6 +108,7 @@ impl GenerateKeypair {
             format!("{}.json", &prepopulated_unsigned_transaction.signer_id).into();
         let mut path = std::path::PathBuf::from(&home_dir);
         path.push(crate::consts::DIR_NAME_KEY_CHAIN);
+        std::fs::create_dir_all(&path)?;
         path.push(file_name);
         if path.exists() {
             return Err(color_eyre::Report::msg(format!(

src/commands/add_command/contract_code/contract/mod.rs

@@ -111,10 +111,10 @@ impl ContractFile {
         prepopulated_unsigned_transaction: near_primitives::transaction::Transaction,
         network_connection_config: Option<crate::common::ConnectionConfig>,
     ) -> crate::CliResult {
-        let mut f = std::fs::File::open(&self.file_path.clone())
-            .map_err(|err| color_eyre::Report::msg(format!("Failed to open file: {:?}", err)))?;
         let mut code = Vec::new();
-        f.read_to_end(&mut code)
+        std::fs::File::open(&self.file_path.clone())
+            .map_err(|err| color_eyre::Report::msg(format!("Failed to open file: {:?}", err)))?
+            .read_to_end(&mut code)
             .map_err(|err| color_eyre::Report::msg(format!("Failed to read file: {:?}", err)))?;
         let action = near_primitives::transaction::Action::DeployContract(
             near_primitives::transaction::DeployContractAction { code },

src/commands/add_command/implicit_account/generate_keypair/mod.rs

@@ -82,6 +82,7 @@ impl CliGenerateKeypair {
         let file_name: std::path::PathBuf = format!("{}.json", &implicit_account_id).into();
         let mut path = std::path::PathBuf::from(&home_dir);
         path.push(crate::consts::DIR_NAME_KEY_CHAIN);
+        std::fs::create_dir_all(&path)?;
         path.push(file_name);
         if path.exists() {
             return Err(color_eyre::Report::msg(format!(

src/commands/add_command/sub_account/full_access_key/public_key_mode/generate_keypair/mod.rs

@@ -105,6 +105,7 @@ impl GenerateKeypair {
             format!("{}.json", &prepopulated_unsigned_transaction.receiver_id).into();
         let mut path = std::path::PathBuf::from(&home_dir);
         path.push(crate::consts::DIR_NAME_KEY_CHAIN);
+        std::fs::create_dir_all(&path)?;
         path.push(file_name);
         if path.exists() {
             return Err(color_eyre::Report::msg(format!(

src/commands/construct_transaction_command/sign_transaction/mod.rs

@@ -2,8 +2,8 @@ use dialoguer::{theme::ColorfulTheme, Select};
 use strum::{EnumDiscriminants, EnumIter, EnumMessage, IntoEnumIterator};
 
 mod sign_manually;
-mod sign_with_keychain;
-mod sign_with_private_key;
+pub mod sign_with_keychain;
+pub mod sign_with_private_key;
 
 #[derive(Debug, clap::Clap)]
 pub enum CliSignTransaction {

src/commands/construct_transaction_command/sign_transaction/sign_with_keychain/mod.rs

@@ -11,7 +11,7 @@ pub struct CliSignKeychain {
 
 #[derive(Debug)]
 pub struct SignKeychain {
-    submit: Option<super::sign_with_private_key::Submit>,
+    pub submit: Option<super::sign_with_private_key::Submit>,
 }
 
 impl From<CliSignKeychain> for SignKeychain {

src/commands/login/mod.rs

@@ -0,0 +1 @@
+pub mod operation_mode;

src/commands/login/operation_mode/mod.rs

@@ -0,0 +1,64 @@
+use strum::{EnumDiscriminants, EnumIter, EnumMessage};
+
+pub mod online_mode;
+
+/// инструмент выбора режима online/offline
+#[derive(Debug, Default, clap::Clap)]
+pub struct CliOperationMode {
+    #[clap(subcommand)]
+    mode: Option<CliMode>,
+}
+
+#[derive(Debug)]
+pub struct OperationMode {
+    pub mode: Mode,
+}
+
+impl From<CliOperationMode> for OperationMode {
+    fn from(item: CliOperationMode) -> Self {
+        let mode = match item.mode {
+            Some(cli_mode) => Mode::from(cli_mode),
+            None => Mode::choose_mode(),
+        };
+        Self { mode }
+    }
+}
+
+impl OperationMode {
+    pub async fn process(self) -> crate::CliResult {
+        self.mode.process().await
+    }
+}
+
+#[derive(Debug, clap::Clap)]
+pub enum CliMode {
+    /// Execute a change method with online mode
+    Network(self::online_mode::CliNetworkArgs),
+}
+
+#[derive(Debug, EnumDiscriminants)]
+#[strum_discriminants(derive(EnumMessage, EnumIter))]
+pub enum Mode {
+    #[strum_discriminants(strum(message = "Yes, I keep it simple"))]
+    Network(self::online_mode::NetworkArgs),
+}
+
+impl From<CliMode> for Mode {
+    fn from(item: CliMode) -> Self {
+        match item {
+            CliMode::Network(cli_network_args) => Self::Network(cli_network_args.into()),
+        }
+    }
+}
+
+impl Mode {
+    pub fn choose_mode() -> Self {
+        Self::from(CliMode::Network(Default::default()))
+    }
+
+    pub async fn process(self) -> crate::CliResult {
+        match self {
+            Self::Network(network_args) => network_args.process().await,
+        }
+    }
+}

src/commands/login/operation_mode/online_mode/mod.rs

@@ -0,0 +1,31 @@
+pub mod select_server;
+
+/// аргументы, необходимые для создания транзакции в online mode
+#[derive(Debug, Default, clap::Clap)]
+pub struct CliNetworkArgs {
+    #[clap(subcommand)]
+    selected_server: Option<self::select_server::CliSelectServer>,
+}
+
+#[derive(Debug)]
+pub struct NetworkArgs {
+    selected_server: self::select_server::SelectServer,
+}
+
+impl From<CliNetworkArgs> for NetworkArgs {
+    fn from(item: CliNetworkArgs) -> Self {
+        let selected_server = match item.selected_server {
+            Some(cli_selected_server) => {
+                self::select_server::SelectServer::from(cli_selected_server)
+            }
+            None => self::select_server::SelectServer::choose_server(),
+        };
+        Self { selected_server }
+    }
+}
+
+impl NetworkArgs {
+    pub async fn process(self) -> crate::CliResult {
+        self.selected_server.process().await
+    }
+}

src/commands/login/operation_mode/online_mode/select_server/mod.rs

@@ -0,0 +1,89 @@
+use dialoguer::{theme::ColorfulTheme, Select};
+use strum::{EnumDiscriminants, EnumIter, EnumMessage, IntoEnumIterator};
+
+pub mod server;
+
+#[derive(Debug, clap::Clap)]
+pub enum CliSelectServer {
+    /// предоставление данных для сервера https://rpc.testnet.near.org
+    Testnet(self::server::CliServer),
+    /// предоставление данных для сервера https://rpc.mainnet.near.org
+    Mainnet(self::server::CliServer),
+    /// предоставление данных для сервера https://rpc.betanet.near.org
+    Betanet(self::server::CliServer),
+    /// предоставление данных для сервера, указанного вручную
+    Custom(self::server::CliCustomServer),
+}
+
+#[derive(Debug, EnumDiscriminants)]
+#[strum_discriminants(derive(EnumMessage, EnumIter))]
+pub enum SelectServer {
+    #[strum_discriminants(strum(message = "Testnet"))]
+    Testnet(self::server::Server),
+    #[strum_discriminants(strum(message = "Mainnet"))]
+    Mainnet(self::server::Server),
+    #[strum_discriminants(strum(message = "Betanet"))]
+    Betanet(self::server::Server),
+    #[strum_discriminants(strum(message = "Custom"))]
+    Custom(self::server::Server),
+}
+
+impl From<CliSelectServer> for SelectServer {
+    fn from(item: CliSelectServer) -> Self {
+        match item {
+            CliSelectServer::Testnet(cli_server) => {
+                Self::Testnet(cli_server.into_server(crate::common::ConnectionConfig::Testnet))
+            }
+            CliSelectServer::Mainnet(cli_server) => {
+                Self::Mainnet(cli_server.into_server(crate::common::ConnectionConfig::Mainnet))
+            }
+            CliSelectServer::Betanet(cli_server) => {
+                Self::Betanet(cli_server.into_server(crate::common::ConnectionConfig::Betanet))
+            }
+            CliSelectServer::Custom(cli_custom_server) => {
+                Self::Custom(cli_custom_server.into_server())
+            }
+        }
+    }
+}
+
+impl SelectServer {
+    pub fn choose_server() -> Self {
+        println!();
+        let variants = SelectServerDiscriminants::iter().collect::<Vec<_>>();
+        let servers = variants
+            .iter()
+            .map(|p| p.get_message().unwrap().to_owned())
+            .collect::<Vec<_>>();
+        let selected_server = Select::with_theme(&ColorfulTheme::default())
+            .with_prompt("Select NEAR protocol wallet url")
+            .items(&servers)
+            .default(0)
+            .interact()
+            .unwrap();
+        let cli_select_server = match variants[selected_server] {
+            SelectServerDiscriminants::Testnet => CliSelectServer::Testnet(Default::default()),
+            SelectServerDiscriminants::Mainnet => CliSelectServer::Mainnet(Default::default()),
+            SelectServerDiscriminants::Betanet => CliSelectServer::Betanet(Default::default()),
+            SelectServerDiscriminants::Custom => CliSelectServer::Custom(Default::default()),
+        };
+        Self::from(cli_select_server)
+    }
+
+    pub async fn process(self) -> crate::CliResult {
+        Ok(match self {
+            SelectServer::Testnet(server) => {
+                server.process().await?;
+            }
+            SelectServer::Mainnet(server) => {
+                server.process().await?;
+            }
+            SelectServer::Betanet(server) => {
+                server.process().await?;
+            }
+            SelectServer::Custom(server) => {
+                server.process().await?;
+            }
+        })
+    }
+}