wative 1.0.33 → 1.0.35

package/src/account.ts

@@ -16,9 +16,11 @@ import {
     numberValidator,
     formatAddr,
     listWithLazyBalanceLoading,
+    inputPasswordWithoutValidator,
+    format_account_label,
 } from "./utils";
 import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getStatus, selectDefaultNetwork, showAllAccounts, switchNetworkByAccountLabel } from "./network";
-import { getAssetList, showAssets, showAssetsDetail } from './assets';
+import { getAssetList, showAssetsDetail } from './assets';
 import { selectToolsOptions } from './tools';
 import inquirer from "inquirer";
 import { getChainType } from "./chain";
@@ -70,14 +72,15 @@ const importPassphrase = async (keystore_path: string, wative_core: typeof Wativ
     let passphrase = await inputSomething('Please enter a mnemonic [split by space]', passphraseValidator);
     passphrase = passphrase.replace(/\s+/g, " ");
 
-    const passphrase_account = wative_core.account.generatePPAccount(pre_account_info.account_label, passphrase, pre_account_info.password);
+    let formatted_account_label = format_account_label(pre_account_info.account_label);
+    const passphrase_account = wative_core.account.generatePPAccount(formatted_account_label, passphrase, pre_account_info.password);
     if (!passphrase_account.status) {
         console.log(
             chalk.red(passphrase_account.output)
         );
         return;
     }
-    let account_info_path = path.join(keystore_path, `accounts/${pre_account_info.account_label}.json`);
+    let account_info_path = path.join(keystore_path, `accounts/${formatted_account_label}.json`);
 
     passphrase_account.output.default_network = pre_account_info.selected_default_network;
     fs.writeFileSync(account_info_path, JSON.stringify(passphrase_account.output, null, 4));
@@ -96,10 +99,11 @@ const createPrivateKeyAccount = async (keystore_path: string, wative_core: typeo
     }
 
     let private_key = await inputSomething('Please enter a private key');
+    let formatted_account_label = format_account_label(pre_account_info.account_label);
     await _importAccount(
         keystore_path,
         pre_account_info.password,
-        pre_account_info.account_label,
+        formatted_account_label,
         private_key,
         pre_account_info.selected_default_network,
         wative_core,
@@ -109,6 +113,7 @@ const createPrivateKeyAccount = async (keystore_path: string, wative_core: typeo
     const network_path = path.resolve(keystore_path, 'network.json');
     const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
     networks.accounts.push(pre_account_info.account_label);
+
     fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
 }
 
@@ -217,7 +222,7 @@ const createAccount = async (keystore_path: string, wative_core: typeof WativeCo
     wative_core.account.reloadAccount();
 }
 
-const getNetworkInfo = (keystore_path: string) => {
+export const getNetworkInfo = (keystore_path: string) => {
     const network_path = path.resolve(keystore_path, 'network.json');
     const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
     return networks;
@@ -241,15 +246,11 @@ export const loginIn = async (account_label: string, wative_core: typeof WativeC
     }
 
     for (let i = 0; i < 3; i++) {
-        let isConfirm = await confirmSomething(`Confirm select account [${account_label}]`);
-        if (!isConfirm) {
-            return { isLoginIn: false };
-        }
         let password: any;
         if (process.env.WativePassword && process.env.WativePassword !== '') {
             password = process.env.WativePassword;
         } else {
-            password = await inputPassword(`Please input the password for Account [${account_label}]`);
+            password = await inputPasswordWithoutValidator(`Please input the password for Account [${account_label}]`);
         }
         if (!password) {
             console.log(
@@ -261,10 +262,17 @@ export const loginIn = async (account_label: string, wative_core: typeof WativeC
         const login_result = await wative_core.account.login(account_label, password);
         if (login_result.status) {
             return { isLoginIn: true, password };
-        } else {
-            console.log(
-                chalk.red(login_result.output)
-            );
+        }
+
+        const options = [
+            '> Try Again',
+            '> Back'
+        ];
+        const selected_option = await selectSomething(options, login_result.output);
+        if (selected_option === '> Back') {
+            return { isLoginIn: false };
+        } else if (selected_option === '> Try Again') {
+            continue;
         }
     }
     return { isLoginIn: false };
@@ -289,7 +297,8 @@ const selectAccount = async (keystore_path: string, wative_core: typeof WativeCo
 
     for (let i = 0; i < account_label_len; i++) {
         const account_label = account_label_list[i];
-        const account_info = getAccountInfo(keystore_path, account_label);
+        const formatted_account_label = format_account_label(account_label);
+        const account_info = getAccountInfo(keystore_path, formatted_account_label);
         if ("data" in account_info) {
             select_account_options.push(`${i + 1}) ${account_label} [${account_info.account_type}:${account_info.data.length}]`);
         } else {
@@ -303,9 +312,11 @@ const selectAccount = async (keystore_path: string, wative_core: typeof WativeCo
     }
 
     const selected_account_label = account_label_list[select_account_options.indexOf(selected_account) - 2];
-    let login_result = await loginIn(selected_account_label, wative_core);
+    const formatted_account_label = format_account_label(selected_account_label);
+
+    let login_result = await loginIn(formatted_account_label, wative_core);
     if (login_result.isLoginIn) {
-        await accountManager(keystore_path, selected_account_label, wative_core, login_result.password);
+        await accountManager(keystore_path, formatted_account_label, wative_core, login_result.password);
     }
 
     await selectAccount(keystore_path, wative_core);

package/src/index.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { showIntroduction, getKeystorePath, updateStorage } from "./utils";
+import { showIntroduction, getKeystorePath, updateStorage, batch_format_account_label } from "./utils";
 import { createNetwork } from "./network";
 import { showHomePage } from "./home_page";
 
@@ -20,7 +20,8 @@ const main = async () => {
 
     const network_path = path.resolve(keystore_path, 'network.json');
     const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
-    const wative_core = new WativeCore(keystore_path, networks.accounts, null, true);
+    let format_account_label_list = batch_format_account_label(networks.accounts);
+    const wative_core = new WativeCore(keystore_path, format_account_label_list, null, true);
     await showHomePage(keystore_path, wative_core);
 }
 

package/src/tools.ts

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 import { BigNumber } from 'bignumber.js';
 import inquirer from 'inquirer';
-import { addrValidator, chainAddressValidator, confirmSomething, editorSomething, gasValidator, getAccountChainType, hexValidator, inputSomething, numberValidator, selectSomething } from "./utils";
+import { addrValidator, chainAddressValidator, confirmSomething, editorSomething, gasValidator, getAccountChainType, hexValidator, inputSomething, numberValidator, selectSomething, un_format_account_label } from "./utils";
 import { loginIn } from './account';
 import { getAccountBalance, getDefaultNetworkByAddress, getEvmNetworks, getNetworkInfoByName, getNetworkTypeByName } from './network';
 import { GasUtil } from './tx_gas_utils';
@@ -537,20 +537,6 @@ const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url:
         return;
     }
 
-    // let amount: any;
-    // for (let i = 0; i < 5; i++) {
-    //     let input_amount = await inputSomething("Amount", numberValidator);
-    //     if ((new BigNumber(input_amount).multipliedBy(Math.pow(10, Number(token_decimals)))).isLessThanOrEqualTo(new BigNumber(token_balance_result.output))) {
-    //         amount = input_amount;
-    //         break;
-    //     }
-    //     console.log(chalk.red("Not enough balance"));
-    // }
-
-    // if (!amount) {
-    //     return;
-    // }
-
     let transfer_amount = await getTransferTokenAmount(
         token_balance_result.output,
         token_name,
@@ -713,14 +699,14 @@ const getTransferTokenAmount = async (max_value: string, token_symbols: string,
     let total_balance = (new BigNumber(max_value)).dividedBy(10 ** decimals).toFixed(4, BigNumber.ROUND_FLOOR);
 
     let option_select_value_list: any = [
-        '> Input value',
+        '> Input amount',
         `> Total Balance (${total_balance} ${token_symbols})`
     ]
     let selected_value = await selectSomething(option_select_value_list);
     let value_id = option_select_value_list.indexOf(selected_value);
     let value = "0";
     if (value_id === 0) {
-        let input_value = await inputSomething("value", numberValidator);
+        let input_value = await inputSomething("amount", numberValidator);
         value = new BigNumber(input_value).multipliedBy(10 ** decimals).toFixed(0, BigNumber.ROUND_FLOOR);
     } else if (value_id === 1) {
         value = max_value;
@@ -895,6 +881,9 @@ export const showTools = async (keystore_path: string, wative_core: typeof Wativ
     }
 
     let account_label = account_label_info.account_label;
+    let show_account_label = un_format_account_label(keystore_path, account_label);
+    console.log(chalk.green(`Found account label: [${show_account_label}]`));
+
     account_address = account_label_info.account_address;
     if (account_label === null) {
         console.log(chalk.red("Account not found"));

package/src/utils.ts

@@ -9,6 +9,7 @@ import { getChainIdByEvm } from "./web3";
 import { MNEMONIC_WORDS } from './config';
 import { getChainType } from './chain';
 import { getBatchAccountBalance } from './assets';
+import { getNetworkInfo } from './account';
 
 const USER_HOME: any = process.env.HOME || process.env.USERPROFILE
 const BASE_PATH = `${USER_HOME}/.wative`
@@ -331,14 +332,50 @@ export const getColor = async (text: string) => {
     return null;
 }
 
+export const un_format_account_label = (keystore_path: string, account_label: string) => {
+    const networks = getNetworkInfo(keystore_path);
+
+    const account_label_list = networks.accounts;
+    const formatted_account_label_list = batch_format_account_label(account_label_list);
+
+    const index = formatted_account_label_list.indexOf(account_label);
+    if (index !== -1) {
+        return account_label_list[index];
+    }
+    return account_label;
+}
+
+export const format_account_label = (account_label: string) => {
+    account_label = account_label.trim();
+    account_label = account_label.toLocaleLowerCase();
+    account_label = account_label.replace(/\s+/g, "-").trim();
+    account_label = account_label.replace(/\-+/g, "-").trim();
+    return account_label;
+}
+
+
+export const batch_format_account_label = (account_label_list: string[]) => {
+    let formatted_account_label_list: string[] = [];
+    for (let i = 0; i < account_label_list.length; i++) {
+        formatted_account_label_list.push(
+            format_account_label(account_label_list[i])
+        );
+    }
+    return formatted_account_label_list;
+}
+
+
 export const getAccountLabel = async (text: string, account_label_list: string[]) => {
+    let formatted_account_label_list = batch_format_account_label(account_label_list);
     let reg = /^(?![-_])[a-zA-Z0-9_-]{4,20}(?<![-_])$/g;
     for (let i = 0; i < 5; i++) {
         let account_label = await inputSomething(text);
         account_label = account_label.trim();
-        if (reg.test(account_label)) {
-            if (account_label_list.includes(account_label)) {
-                console.log(chalk.red("Account label already exists"));
+        let formatted_account_label = format_account_label(account_label);
+
+        if (reg.test(formatted_account_label)) {
+            if (formatted_account_label_list.includes(formatted_account_label)) {
+                console.log(chalk.red("Keystore name already exists"));
                 continue;
             } else {
                 return account_label;
@@ -394,6 +431,20 @@ const passwordValidator = function (value: string) {
     }
 };
 
+export const inputPasswordWithoutValidator = async (text: string) => {
+    const questions = [
+        {
+            name: 'password',
+            type: 'password',
+            mask: '#',
+            message: `${text}:`
+        }
+    ]
+
+    let { password } = await inquirer.prompt(questions);
+    return password;
+}
+
 export const inputPassword = async (text: string) => {
     let count = 0;
 
@@ -701,7 +752,8 @@ export const updateStorage = (keystore_path: string) => {
     let account_list_len = networks.accounts.length;
     for (let i = 0; i < account_list_len; i++) {
         let account_label = networks.accounts[account_list_len - 1 - i];
-        let account_label_path = path.resolve(keystore_path, `accounts/${account_label}.json`);
+        let formatted_account_label = format_account_label(account_label);
+        let account_label_path = path.resolve(keystore_path, `accounts/${formatted_account_label}.json`);
 
         if (!fs.existsSync(account_label_path)) {
             networks.accounts.splice(account_list_len - 1 - i, 1);
@@ -710,6 +762,7 @@ export const updateStorage = (keystore_path: string) => {
 
     fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
     let account_label_list = networks.accounts;
+    account_label_list = batch_format_account_label(account_label_list);
 
     for (let i = 0; i < account_label_list.length; i++) {
         let account_label_path = path.resolve(keystore_path, `accounts/${account_label_list[i]}.json`);