[cli] Add Task Scheduling Command and Refactor Wallet Context API (#2704

)

* [cli] Implement rooch task schedule command

* [gas_market] Add exists_new_events to gas markent and use task schedule in testcase

* [CLI] Refactor wallet context password and sign API

crates/rooch-faucet/src/faucet.rs

@@ -7,7 +7,6 @@ use clap::Parser;
 use move_core_types::language_storage::StructTag;
 use moveos_types::transaction::MoveAction;
 use prometheus::Registry;
-use rooch_key::keystore::account_keystore::AccountKeystore;
 use rooch_rpc_client::wallet_context::WalletContext;
 use rooch_types::address::{MultiChainAddress, RoochAddress};
 use rooch_types::authentication_key::AuthenticationKey;
@@ -55,7 +54,6 @@ impl Default for FaucetConfig {
 
 struct State {
     config: FaucetConfig,
-    wallet_pwd: Option<String>,
     context: WalletContext,
     // metrics: FaucetMetrics,
 }
@@ -73,17 +71,16 @@ impl Faucet {
         faucet_receiver: Receiver<FaucetRequest>,
         faucet_error_sender: Sender<FaucetError>,
     ) -> Result<Self> {
-        let wallet = WalletContext::new(config.wallet_config_dir.clone()).unwrap();
+        let mut wallet = WalletContext::new(config.wallet_config_dir.clone()).unwrap();
         let _metrics = FaucetMetrics::new(prometheus_registry);
         let wallet_pwd = match env::var("ROOCH_FAUCET_PWD") {
             Ok(val) => Some(val.parse::<String>().unwrap()),
             _ => None,
         };
-
+        wallet.set_password(wallet_pwd);
         Ok(Self {
             state: Arc::new(RwLock::new(State {
                 config,
-                wallet_pwd,
                 context: wallet,
             })),
             faucet_error_sender,
@@ -122,25 +119,20 @@ impl Faucet {
         state: RwLockWriteGuard<'a, State>,
     ) -> Result<()> {
         let sender: RoochAddress = state.context.client_config.active_address.unwrap();
-        let pwd = state.wallet_pwd.clone();
+        let tx_data = state
+            .context
+            .build_tx_data(sender, action, None)
+            .await
+            .map_err(FaucetError::internal)?;
         let result = if let Some(session_key) = state.config.session_key.clone() {
-            let tx_data = state
-                .context
-                .build_tx_data(sender, action, None)
-                .await
-                .map_err(FaucetError::internal)?;
             let tx = state
                 .context
-                .keystore
-                .sign_transaction_via_session_key(&sender, tx_data, &session_key, pwd)
+                .sign_transaction_via_session_key(&sender, tx_data, &session_key)
                 .map_err(|e| RoochError::SignMessageError(e.to_string()))
                 .map_err(FaucetError::internal)?;
             state.context.execute(tx).await
         } else {
-            state
-                .context
-                .sign_and_execute(sender, action, pwd, None)
-                .await
+            state.context.sign_and_execute(sender, tx_data).await
         };
 
         match result {

crates/rooch-oracle/src/binance.rs

@@ -52,13 +52,11 @@ pub struct Binance {
 
 impl Binance {
     pub async fn new(config: BinanceConfig) -> Self {
-        let wallet = WalletContext::new(config.binance_wallet_dir.clone()).unwrap();
+        let mut wallet = WalletContext::new(config.binance_wallet_dir.clone()).unwrap();
         let wallet_pwd = config.binance_wallet_pwd.clone();
+        wallet.set_password(wallet_pwd);
         Self {
-            wallet_state: Arc::new(RwLock::new(State {
-                wallet_pwd,
-                context: wallet,
-            })),
+            wallet_state: Arc::new(RwLock::new(State { context: wallet })),
             binance_config: config,
         }
     }

crates/rooch-oracle/src/data_process.rs

@@ -89,7 +89,6 @@ pub async fn subscribe_http(url: String, tx: mpsc::Sender<Value>, interval: u64)
 }
 
 pub struct State {
-    pub(crate) wallet_pwd: Option<String>,
     pub context: WalletContext,
 }
 
@@ -99,11 +98,8 @@ pub async fn execute_transaction<'a>(
     state: RwLockWriteGuard<'a, State>,
 ) -> Result<()> {
     let sender: RoochAddress = state.context.client_config.active_address.unwrap();
-    let pwd = state.wallet_pwd.clone();
-    let result = state
-        .context
-        .sign_and_execute(sender, action, pwd, None)
-        .await;
+    let tx_data = state.context.build_tx_data(sender, action, None).await?;
+    let result = state.context.sign_and_execute(sender, tx_data).await;
     match result {
         Ok(tx) => match tx.execution_info.status {
             KeptVMStatusView::Executed => {

crates/rooch-oracle/src/okx.rs

@@ -49,13 +49,11 @@ pub struct Okx {
 
 impl Okx {
     pub async fn new(config: OkxConfig) -> Self {
-        let wallet = WalletContext::new(config.okx_wallet_dir.clone()).unwrap();
+        let mut wallet = WalletContext::new(config.okx_wallet_dir.clone()).unwrap();
         let wallet_pwd = config.okx_wallet_pwd.clone();
+        wallet.set_password(wallet_pwd);
         Self {
-            wallet_state: Arc::new(RwLock::new(State {
-                wallet_pwd,
-                context: wallet,
-            })),
+            wallet_state: Arc::new(RwLock::new(State { context: wallet })),
             okx_config: config,
         }
     }

crates/rooch-oracle/src/pyth.rs

@@ -49,13 +49,11 @@ pub struct Pyth {
 
 impl Pyth {
     pub async fn new(config: PythConfig) -> Self {
-        let wallet = WalletContext::new(config.pyth_wallet_dir.clone()).unwrap();
+        let mut wallet = WalletContext::new(config.pyth_wallet_dir.clone()).unwrap();
         let wallet_pwd = config.pyth_wallet_pwd.clone();
+        wallet.set_password(wallet_pwd);
         Self {
-            wallet_state: Arc::new(RwLock::new(State {
-                wallet_pwd,
-                context: wallet,
-            })),
+            wallet_state: Arc::new(RwLock::new(State { context: wallet })),
             pyth_config: config,
         }
     }

crates/rooch-rpc-api/src/jsonrpc_types/function_return_value_view.rs

@@ -13,7 +13,7 @@ use moveos_types::function_return_value::{
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 pub enum VMStatusView {
     Executed,
     MoveAbort {

crates/rooch-rpc-client/src/wallet_context.rs

@@ -19,6 +19,7 @@ use rooch_key::keystore::Keystore;
 use rooch_rpc_api::jsonrpc_types::{ExecuteTransactionResponseView, KeptVMStatusView, TxOptions};
 use rooch_types::address::RoochAddress;
 use rooch_types::address::{BitcoinAddress, ParsedAddress};
+use rooch_types::authentication_key::AuthenticationKey;
 use rooch_types::bitcoin::network::Network;
 use rooch_types::crypto::RoochKeyPair;
 use rooch_types::error::{RoochError, RoochResult};
@@ -224,19 +225,27 @@ impl WalletContext {
         Ok(tx_data)
     }
 
-    pub async fn sign(
+    pub fn generate_session_key(&mut self, address: &RoochAddress) -> Result<AuthenticationKey> {
+        self.keystore
+            .generate_session_key(address, self.password.clone())
+    }
+
+    pub fn sign_transaction_via_session_key(
         &self,
-        sender: RoochAddress,
-        action: MoveAction,
-        password: Option<String>,
-        max_gas_amount: Option<u64>,
+        signer: &RoochAddress,
+        tx_data: RoochTransactionData,
+        authentication_key: &AuthenticationKey,
     ) -> RoochResult<RoochTransaction> {
-        let tx_data = self.build_tx_data(sender, action, max_gas_amount).await?;
-        let tx = self.keystore.sign_transaction(&sender, tx_data, password)?;
+        let tx = self.keystore.sign_transaction_via_session_key(
+            signer,
+            tx_data,
+            authentication_key,
+            self.password.clone(),
+        )?;
         Ok(tx)
     }
 
-    pub async fn sign_transaction(
+    pub fn sign_transaction(
         &self,
         signer: RoochAddress,
         tx_data: RoochTransactionData,
@@ -268,11 +277,9 @@ impl WalletContext {
     pub async fn sign_and_execute(
         &self,
         sender: RoochAddress,
-        action: MoveAction,
-        password: Option<String>,
-        max_gas_amount: Option<u64>,
+        tx_data: RoochTransactionData,
     ) -> RoochResult<ExecuteTransactionResponseView> {
-        let tx = self.sign(sender, action, password, max_gas_amount).await?;
+        let tx = self.sign_transaction(sender, tx_data)?;
         self.execute(tx).await
     }
 

crates/rooch-types/src/address.rs

@@ -987,6 +987,12 @@ pub enum ParsedAddress {
     Bitcoin(BitcoinAddress),
 }
 
+impl Default for ParsedAddress {
+    fn default() -> Self {
+        Self::Named("default".to_string())
+    }
+}
+
 impl ParsedAddress {
     pub fn into_rooch_address(
         self,

crates/rooch/src/commands/account/commands/create_multisign.rs

@@ -83,7 +83,7 @@ impl CommandAction<Option<MultisignAccountOutput>> for CreateMultisignCommand {
             let tx_data = context
                 .build_tx_data(sender, action, self.tx_options.max_gas_amount)
                 .await?;
-            let signed_tx = context.sign_transaction(sender, tx_data).await?;
+            let signed_tx = context.sign_transaction(sender, tx_data)?;
             let result = context.execute(signed_tx).await?;
             context.assert_execute_success(result)?;
         }

crates/rooch/src/commands/account/commands/transfer.rs

@@ -6,8 +6,6 @@ use async_trait::async_trait;
 use clap::Parser;
 use move_command_line_common::types::ParsedStructType;
 use move_core_types::u256::U256;
-use rooch_key::key_derive::verify_password;
-use rooch_key::keystore::account_keystore::AccountKeystore;
 use rooch_rpc_api::jsonrpc_types::ExecuteTransactionResponseView;
 use rooch_types::address::ParsedAddress;
 use rooch_types::address::RoochAddress;
@@ -16,7 +14,6 @@ use rooch_types::{
     error::{RoochError, RoochResult},
     transaction::rooch::RoochTransaction,
 };
-use rpassword::prompt_password;
 
 /// Transfer coins
 #[derive(Debug, Parser)]
@@ -44,7 +41,7 @@ pub struct TransferCommand {
 #[async_trait]
 impl CommandAction<ExecuteTransactionResponseView> for TransferCommand {
     async fn execute(self) -> RoochResult<ExecuteTransactionResponseView> {
-        let context = self.context.build()?;
+        let context = self.context.build_require_password()?;
         let mapping = context.address_mapping();
         let sender: RoochAddress = context.resolve_address(self.tx_options.sender)?.into();
         let max_gas_amount: Option<u64> = self.tx_options.max_gas_amount;
@@ -53,75 +50,23 @@ impl CommandAction<ExecuteTransactionResponseView> for TransferCommand {
         let action =
             TransferModule::create_transfer_coin_action(coin_type, address_addr, self.amount);
 
+        let tx_data = context
+            .build_tx_data(sender, action, max_gas_amount)
+            .await?;
         match (self.tx_options.authenticator, self.tx_options.session_key) {
             (Some(authenticator), _) => {
-                let tx_data = context
-                    .build_tx_data(sender, action, max_gas_amount)
-                    .await?;
                 //TODO the authenticator usually is associated with the RoochTransactinData
                 //So we need to find a way to let user generate the authenticator based on the tx_data.
                 let tx = RoochTransaction::new(tx_data, authenticator.into());
                 context.execute(tx).await
             }
-            (_, Some(session_key)) => {
-                let tx_data = context
-                    .build_tx_data(sender, action, max_gas_amount)
-                    .await?;
-                let tx = if context.keystore.get_if_password_is_empty() {
-                    context
-                        .keystore
-                        .sign_transaction_via_session_key(&sender, tx_data, &session_key, None)
-                        .map_err(|e| RoochError::SignMessageError(e.to_string()))?
-                } else {
-                    let password =
-                        prompt_password("Enter the password to run functions:").unwrap_or_default();
-                    let is_verified = verify_password(
-                        Some(password.clone()),
-                        context.keystore.get_password_hash(),
-                    )?;
-
-                    if !is_verified {
-                        return Err(RoochError::InvalidPasswordError(
-                            "Password is invalid".to_owned(),
-                        ));
-                    }
-
-                    context
-                        .keystore
-                        .sign_transaction_via_session_key(
-                            &sender,
-                            tx_data,
-                            &session_key,
-                            Some(password),
-                        )
-                        .map_err(|e| RoochError::SignMessageError(e.to_string()))?
-                };
+            (_, Some(auth_key)) => {
+                let tx = context
+                    .sign_transaction_via_session_key(&sender, tx_data, &auth_key)
+                    .map_err(|e| RoochError::SignMessageError(e.to_string()))?;
                 context.execute(tx).await
             }
-            (None, None) => {
-                if context.keystore.get_if_password_is_empty() {
-                    context
-                        .sign_and_execute(sender, action, None, max_gas_amount)
-                        .await
-                } else {
-                    let password =
-                        prompt_password("Enter the password to run functions:").unwrap_or_default();
-                    let is_verified = verify_password(
-                        Some(password.clone()),
-                        context.keystore.get_password_hash(),
-                    )?;
-
-                    if !is_verified {
-                        return Err(RoochError::InvalidPasswordError(
-                            "Password is invalid".to_owned(),
-                        ));
-                    }
-
-                    context
-                        .sign_and_execute(sender, action, Some(password), max_gas_amount)
-                        .await
-                }
-            }
+            (None, None) => context.sign_and_execute(sender, tx_data).await,
         }
     }
 }

crates/rooch/src/commands/mod.rs

@@ -20,6 +20,7 @@ pub mod server;
 pub mod session_key;
 pub mod state;
 pub mod statedb;
+pub mod task;
 pub mod transaction;
 pub mod upgrade;
 pub mod util;