wative 1.0.32 → 1.0.34

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;
@@ -245,7 +250,7 @@ export const loginIn = async (account_label: string, wative_core: typeof WativeC
         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(
@@ -257,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 };
@@ -285,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 {
@@ -299,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);
@@ -658,8 +673,7 @@ const showAccountDetail = async (keystore_path: string, account_label: string, s
                 current_tag = `Current tag (${account_info.data[selected_account_id].tag})`;
             }
             let tag = await inputSomething(current_tag, tagValidator);
-            tag = tag.replace(/\s+/g, " ").trim();
-            account_info.data[selected_account_id].tag = tag.toLocaleLowerCase();
+            account_info.data[selected_account_id].tag = tag.replace(/\s+/g, " ").trim();
             saveAccountInfo(keystore_path, account_label, account_info);
             break;
         }

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';
@@ -334,9 +334,10 @@ const sendEvmTokenTransaction = async (keystore_path: string, chain_rpc_url: str
 
     let token_address: any;
     let token_decimals: any;
+    let token_name: any;
     switch (selected_token_address) {
         case '> Input token ticker':
-            let token_name = await inputSomething("token ticker");
+            token_name = await inputSomething("token ticker");
 
             let token_address_list = await getAssetListByTokenName(keystore_path, chain_id, token_name);
             if (token_address_list.length === 0) {
@@ -381,6 +382,7 @@ const sendEvmTokenTransaction = async (keystore_path: string, chain_rpc_url: str
                 return;
             }
             token_decimals = Number(token_info.output.decimals);
+            token_name = token_info.output.name;
             break;
     }
 
@@ -390,19 +392,6 @@ const sendEvmTokenTransaction = async (keystore_path: string, chain_rpc_url: str
         console.log(chalk.red(token_balance_result.output));
         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;
-    }
 
     const gasUtil = new GasUtil(chain_rpc_url);
     const estimateGasPrice = await gasUtil.getGasPrice();
@@ -411,8 +400,12 @@ const sendEvmTokenTransaction = async (keystore_path: string, chain_rpc_url: str
     const inputGasPrice = await inputSomething(`Gas price (${_estimateGasPrice}), agree or enter`, gasValidator);
     let gasPrice = inputGasPrice ? inputGasPrice : _estimateGasPrice;
     gasPrice = (new BigNumber(gasPrice)).multipliedBy(1e9).toFixed(0);
+    let transfer_amount = await getTransferTokenAmount(
+        token_balance_result.output,
+        token_name,
+        token_decimals
+    );
 
-    let transfer_amount = new BigNumber(amount).multipliedBy(Math.pow(10, token_decimals)).toFixed(0);
     const data = await getTransferTokenData(receipt, transfer_amount, chain_rpc_url);
 
     const estimateNonce = await gasUtil.getTransactionCount(account_address);
@@ -485,9 +478,10 @@ const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url:
 
     let token_address: any;
     let token_decimals: any;
+    let token_name: any;
     switch (selected_token_address) {
         case '> Input token ticker':
-            let token_name = await inputSomething("token ticker");
+            token_name = await inputSomething("token ticker");
 
             let token_address_list = await getAssetListByTokenName(keystore_path, chain_id, token_name);
             if (token_address_list.length === 0) {
@@ -532,30 +526,22 @@ const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url:
                 return;
             }
             token_decimals = Number(token_info.output.decimals);
+            token_name = token_info.output.name;
             break;
     }
 
     const receipt = await inputSomething("Receipt", chainAddressValidator);
-    const token_balance_result = await getTokenBalanceInEvm(account_address, token_address, chain_rpc_url);
+    const token_balance_result = await getTokenBalanceInSolana(account_address, token_address, chain_rpc_url);
     if (!token_balance_result.status) {
         console.log(chalk.red(token_balance_result.output));
         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 = new BigNumber(amount).multipliedBy(Math.pow(10, token_decimals)).toFixed(0);
+    let transfer_amount = await getTransferTokenAmount(
+        token_balance_result.output,
+        token_name,
+        token_decimals
+    );
     let from_token_account = getAssociatedTokenAddressSync(
         new PublicKey(token_address),
         new PublicKey(account_address),
@@ -709,6 +695,31 @@ const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url:
 }
 
 
+const getTransferTokenAmount = async (max_value: string, token_symbols: string, decimals: number): Promise<string> => {
+    let total_balance = (new BigNumber(max_value)).dividedBy(10 ** decimals).toFixed(4, BigNumber.ROUND_FLOOR);
+
+    let option_select_value_list: any = [
+        '> 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("amount", numberValidator);
+        value = new BigNumber(input_value).multipliedBy(10 ** decimals).toFixed(0, BigNumber.ROUND_FLOOR);
+    } else if (value_id === 1) {
+        value = max_value;
+    }
+
+    if ((new BigNumber(value)).isLessThanOrEqualTo(new BigNumber(max_value))) {
+        return value;
+    }
+
+    console.log(chalk.red("Not enough balance"));
+    return getTransferTokenAmount(max_value, token_symbols, decimals);
+}
+
 const excuteTools = async (keystore_path: string, account_label: string, account_address: string, wative_core: typeof WativeCore) => {
     let default_network = getDefaultNetworkByAddress(keystore_path, account_label, account_address);
     let network_type = getNetworkTypeByName(keystore_path, default_network);
@@ -870,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`
@@ -317,7 +318,7 @@ export const getSymbol = async (text: string) => {
 }
 
 export const getColor = async (text: string) => {
-    let reg = /^#[0-9A_F]{6}$/g;
+    let reg = /^#[0-9A-Fa-f]{6}$/g;
     for (let i = 0; i < 5; i++) {
         let color = await inputSomething(text);
         if (color === "") {
@@ -331,14 +332,49 @@ 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();
+    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 reg = /^(?![-_]).*?[a-zA-Z0-9_-]{4,20}(?<![-_])$/g;
+    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 +430,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 +751,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 +761,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`);