wative 1.2.5 → 1.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wative",
-  "version": "1.2.5",
+  "version": "1.2.7",
   "description": "An agile keystore management toolkit",
   "main": "lib/index.umd.js",
   "types": "src/index.d.ts",
@@ -33,26 +33,26 @@
     "@metamask/bip39": "4.0.0",
     "@metaplex-foundation/js": "0.20.1",
     "@rollup/plugin-commonjs": "21.0.1",
-    "@rollup/plugin-typescript": "^12.1.2",
+    "@rollup/plugin-typescript": "12.1.2",
     "@solana/web3.js": "1.91.8",
     "@types/figlet": "1.5.8",
-    "@types/ini": "^4.1.1",
+    "@types/ini": "4.1.1",
     "@types/inquirer": "9.0.7",
     "@types/node-fetch": "2.6.11",
     "bip39": "3.1.0",
     "cli-progress": "3.12.0",
     "commander": "^9.5.0",
-    "crypto-js": "^4.2.0",
+    "crypto-js": "4.2.0",
     "dotenv": "16.4.5",
     "ethereumjs-wallet": "1.0.2",
     "ethers-multicall": "0.2.3",
     "figlet": "1.7.0",
-    "ini": "^5.0.0",
+    "ini": "5.0.0",
     "inquirer": "8.0.0",
     "inquirer-table-input": "0.0.3",
     "inquirer-tree-prompt": "1.1.2",
     "keythereum": "2.0.0",
-    "log4js": "^6.9.1",
+    "log4js": "6.9.1",
     "micro-ed25519-hdkey": "0.1.2",
     "node-fetch": "2.6.0",
     "rollup": "2.79.1",
@@ -61,7 +61,7 @@
     "rpc-websockets": "7.10.0",
     "ssh2": "1.14.0",
     "uuid": "9.0.0",
-    "wative-core": "^1.0.21",
+    "wative-core": "1.0.21",
     "web3": "1.7.3"
   },
   "directories": {
@@ -70,10 +70,10 @@
   },
   "keywords": [],
   "devDependencies": {
-    "@rollup/plugin-json": "^6.1.0",
-    "@types/node": "^24.2.0",
-    "@types/ssh2": "^1.15.4",
-    "rollup-plugin-copy": "^3.5.0",
-    "ts-node": "^10.9.2"
+    "@rollup/plugin-json": "6.1.0",
+    "@types/node": "24.2.0",
+    "@types/ssh2": "1.15.4",
+    "rollup-plugin-copy": "3.5.0",
+    "ts-node": "10.9.2"
   }
 }

package/src/ssh/types.ts

@@ -1,5 +1,3 @@
-import { TxParams } from "@walletbunker/core/lib/types"
-
 type SubAccountMessageParams = {
     rootAccount: string,
     chainId: string,
@@ -8,7 +6,7 @@ type SubAccountMessageParams = {
 }
 
 type SignMessageParams = {
-    txParams: TxParams,
+    txParams: any,
     rpcUrl: string
 }
 

package/src/utils.ts

@@ -326,6 +326,8 @@ export const getMulticallAddress = async (text: string) => {
             console.log(chalk.red("Multicall address length must be 42"));
             continue;
         }
+
+        return multicall_address;
     }
 
     return null;

package/src/ssh/client.rs

@@ -1,221 +0,0 @@
-use crate::setting::Settings;
-use std::error;
-use std::io;
-use std::net::{TcpStream, ToSocketAddrs};
-use std::path::Path;
-use std::sync::Arc;
-
-use async_executor::{Executor, LocalExecutor, Task};
-use async_io::Async;
-use easy_parallel::Parallel;
-use futures::executor::block_on;
-use futures::future::FutureExt;
-use futures::select;
-use futures::{AsyncReadExt, AsyncWriteExt};
-
-#[cfg(not(unix))]
-use std::net::TcpListener;
-#[cfg(unix)]
-use std::os::unix::net::{UnixListener, UnixStream};
-#[cfg(unix)]
-use tempfile::tempdir;
-
-use async_ssh2_lite::AsyncSession;
-
-async fn run(ex: Arc<Executor<'_>>, command: String) -> Result<String, Box<dyn error::Error>> {
-    let ssh_config = &Settings::get().ssh2;
-
-    let use_bastion = ssh_config.use_bastion;
-
-    let addr = ssh_config.addr.to_owned();
-    let username = ssh_config.username.to_owned();
-
-    let bastion_addr;
-    let bastion_username;
-
-    if use_bastion {
-        bastion_addr = ssh_config.bastion_addr.to_owned();
-        bastion_username = ssh_config.bastion_username.to_owned();
-    } else {
-        bastion_addr = ssh_config.addr.to_owned();
-        bastion_username = ssh_config.username.to_owned();
-    }
-
-    let passphrase = ssh_config.passphrase.to_owned();
-    let addr = addr.to_socket_addrs().unwrap().next().unwrap();
-    let bastion_addr = bastion_addr.to_socket_addrs().unwrap().next().unwrap();
-
-    let public_key_path_str = String::from(ssh_config.public_key_path.to_owned());
-    let private_key_path_str = String::from(ssh_config.private_key_path.to_owned());
-
-    let task_with_main = ex.clone().spawn(async move {
-        let public_key_path = Path::new(&public_key_path_str);
-        let private_key_path = Path::new(&private_key_path_str);
-        let bastion_stream = Async::<TcpStream>::connect(bastion_addr).await?;
-
-        let mut bastion_session = AsyncSession::new(bastion_stream, None)?;
-
-        bastion_session.handshake().await?;
-
-        bastion_session
-            .userauth_pubkey_file(
-                &bastion_username,
-                Some(public_key_path),
-                private_key_path,
-                Some(&passphrase),
-            )
-            .await?;
-
-        if !bastion_session.authenticated() {
-            return Err(bastion_session
-                .last_error()
-                .map( io::Error::from)
-                .unwrap_or_else(||io::Error::new(
-                    io::ErrorKind::Other,
-                    "bastion unknown userauth error",
-                )));
-        }
-
-        if !use_bastion {
-            let mut channel = bastion_session.channel_session().await?;
-
-            channel.exec(&command).await?;
-            let mut res = String::new();
-            channel.read_to_string(&mut res).await?;
-            channel.close().await?;
-
-            bastion_session.disconnect(None, "foo", None).await?;
-
-            return Ok(res);
-        }
-
-        let mut bastion_channel = bastion_session
-            .channel_direct_tcpip(addr.ip().to_string().as_ref(), addr.port(), None)
-            .await?;
-
-        let (forward_stream_s, mut forward_stream_r) = {
-            cfg_if::cfg_if! {
-                if #[cfg(unix)] {
-                    let dir = tempdir()?;
-                    let path = dir.path().join("ssh_channel_direct_tcpip");
-                    let listener = Async::<UnixListener>::bind(&path)?;
-                    let stream_s = Async::<UnixStream>::connect(&path).await?;
-                } else {
-                    let listen_addr = TcpListener::bind("localhost:0")
-                        .unwrap()
-                        .local_addr()
-                        .unwrap();
-                    let listener = Async::<TcpListener>::bind(listen_addr)?;
-                    let stream_s = Async::<TcpStream>::connect(listen_addr).await?;
-                }
-            }
-
-            let (stream_r,_) = listener.accept().await.unwrap();
-
-            (stream_s, stream_r)
-        };
-
-        let task_with_forward: Task<io::Result<()>> = ex.clone().spawn(async move {
-            let mut buf_bastion_channel = vec![0; 2048];
-            let mut buf_forward_stream_r = vec![0; 2048];
-
-            loop {
-                select! {
-                    ret_forward_stream_r = forward_stream_r.read(&mut buf_forward_stream_r).fuse() => match ret_forward_stream_r {
-                        Ok(n) if n == 0 => {
-                            break
-                        },
-                        Ok(n) => {
-                            bastion_channel.write(&buf_forward_stream_r[..n]).await.map(|_| ()).map_err(|err| {
-                                err
-                            })?
-                        },
-                        Err(err) =>  {
-                            return Err(err);
-                        }
-                    },
-                    ret_bastion_channel = bastion_channel.read(&mut buf_bastion_channel).fuse() => match ret_bastion_channel {
-                        Ok(n) if n == 0 => {
-                            break
-                        },
-                        Ok(n) => {
-                            forward_stream_r.write(&buf_bastion_channel[..n]).await.map(|_| ()).map_err(|err| {
-                                err
-                            })?
-                        },
-                        Err(err) => {
-                            return Err(err);
-                        }
-                    },
-                }
-            }
-
-            Ok(())
-        });
-        task_with_forward.detach();
-
-        let mut session = AsyncSession::new(forward_stream_s, None)?;
-        session.handshake().await?;
-
-        session.userauth_pubkey_file(
-            &username,
-            Some(public_key_path),
-            private_key_path,
-            Some(&passphrase),
-        )
-        .await?;
-
-        if !session.authenticated() {
-            return Err(session
-                .last_error()
-                .map(io::Error::from)
-                .unwrap_or_else(||io::Error::new(
-                    io::ErrorKind::Other,
-                    "unknown userauth error",
-                )));
-        }
-
-        let mut channel = session.channel_session().await?;
-
-        channel.exec(&command).await?;
-        let mut res = String::new();
-        channel.read_to_string(&mut res).await?;
-        channel.close().await?;
-
-        session.disconnect(None, "foo", None).await?;
-
-        Ok(res)
-    });
-
-    let result = task_with_main.await.map(|message| message).map_err(|err| {
-        eprintln!("task_with_main run failed, err:{err:?}");
-
-        err
-    })?;
-
-    let signed_data = json::parse(&result).unwrap();
-    if signed_data["status"] == false {
-        panic!("{}", signed_data["msg"].to_string())
-    }
-
-    Ok(json::stringify(signed_data["data"].clone()))
-}
-
-pub fn ssh2_call(command: String) -> Result<String, Box<dyn error::Error>> {
-    let ex = Executor::new();
-    let ex = Arc::new(ex);
-    let local_ex = LocalExecutor::new();
-    let (trigger, shutdown) = async_channel::unbounded::<()>();
-
-    let ret_vec = Parallel::new()
-        .each(0..4, |_| block_on(ex.run(async { shutdown.recv().await })))
-        .finish(|| {
-            block_on(local_ex.run(async {
-                let result = run(ex.clone(), command).await.unwrap();
-                drop(trigger);
-                result
-            }))
-        });
-
-    Ok(ret_vec.1)
-}