wative 1.0.8 → 1.0.10

package/src/account.ts

@@ -13,15 +13,24 @@ import {
     getAccountIndex,
     getAccountRange,
     confirmSomething,
+    numberValidator,
+    formatAddr,
+    listWithLazyBalanceLoading,
 } from "./utils";
-import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getPKAccountAddress, selectDefaultNetwork, switchNetworkByAccountLabel, switchPPNetwork } from "./network";
-import { showAssets } from './assets';
+import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getStatus, selectDefaultNetwork, showAllAccounts, switchNetworkByAccountLabel } from "./network";
+import { getAssetList, showAssets, showAssetsDetail } from './assets';
 import { selectToolsOptions } from './tools';
 import inquirer from "inquirer";
+import { getChainType } from "./chain";
 
 const cliProgress = require('cli-progress');
 const { WativeCore } = require("wative-core");
 
+const DEFAULT_ACCOUNT: any = {
+    account_label: '',
+    default_account_index: 0
+};
+
 const preAccountImport = async (keystore_path: string) => {
     const networks = getNetworkInfo(keystore_path)
 
@@ -78,37 +87,112 @@ const importPassphrase = async (keystore_path: string, wative_core: typeof Wativ
     fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
 }
 
-const importPrivateKey = async (keystore_path: string, wative_core: typeof WativeCore) => {
+
+const createPrivateKeyAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
     let pre_account_info = await preAccountImport(keystore_path);
     if (!pre_account_info) {
         return;
     }
 
     let private_key = await inputSomething('Please enter a private key');
-    let network_info = await getNetworkInfoByName(keystore_path, pre_account_info.selected_default_network);
+    await _importAccount(
+        keystore_path,
+        pre_account_info.password,
+        pre_account_info.account_label,
+        private_key,
+        pre_account_info.selected_default_network,
+        wative_core,
+        true
+    );
+
+    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));
+}
+
+const importPrivateKeyAccount = async (
+    keystore_path: string,
+    password: string,
+    account_label: string,
+    wative_core: typeof WativeCore
+) => {
+    let private_key = await inputSomething('Please enter a private key');
+    let account_info_path = path.join(keystore_path, `accounts/${account_label}.json`);
+    let exist_account_info = JSON.parse(fs.readFileSync(account_info_path, 'utf8'));
 
-    let privatekey_account = await wative_core.account.generatePKAccount(pre_account_info.account_label, private_key, pre_account_info.password, network_info.chainId);
+    await _importAccount(
+        keystore_path,
+        password,
+        account_label,
+        private_key,
+        exist_account_info.default_network,
+        wative_core,
+        false
+    );
+}
+
+const _importAccount = async (
+    keystore_path: string,
+    password: string,
+    account_label: string,
+    private_key: string,
+    default_network: string,
+    wative_core: typeof WativeCore,
+    generate_account_label: boolean
+) => {
+    let network_info = await getNetworkInfoByName(keystore_path, default_network);
+    let network_type = getChainType(network_info.chainId);
+    if (network_type === 'evm' && !private_key.startsWith('0x')) {
+        private_key = "0x" + private_key;
+    }
+
+    let privatekey_account = await wative_core.account.generatePKAccount(account_label, private_key, password, network_info.chainId, generate_account_label);
     if (!privatekey_account.status) {
         console.log(
             chalk.red(privatekey_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/${account_label}.json`);
+
+    let result: any;
+    if (fs.existsSync(account_info_path)) {
+        let exist_account_info = JSON.parse(fs.readFileSync(account_info_path, 'utf8'));
+        if ("data" in exist_account_info) {
+            exist_account_info.data.push({
+                ciphertexts: privatekey_account.output.ciphertexts
+            });
+            result = exist_account_info;
+        } else {
+            exist_account_info.data = [
+                { ciphertexts: exist_account_info.ciphertexts }
+            ]
+            delete exist_account_info.ciphertexts;
+            exist_account_info.data.push({
+                ciphertexts: privatekey_account.output.ciphertexts
+            });
+            result = exist_account_info;
+        }
+    } else {
+        privatekey_account.output.data = [
+            { ciphertexts: privatekey_account.output.ciphertexts }
+        ];
+        delete privatekey_account.output.ciphertexts;
+        privatekey_account.output.default_network = default_network;
+        result = privatekey_account.output;
+    }
 
-    privatekey_account.output.default_network = pre_account_info.selected_default_network;
-    fs.writeFileSync(account_info_path, JSON.stringify(privatekey_account.output, null, 4));
+    fs.writeFileSync(account_info_path, JSON.stringify(result, null, 4));
 
-    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));
+    wative_core.account.reloadAccount();
 }
 
 const createAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
     const create_account_options = [
         '> Import Passphrase',
         '> Import Private Key',
+        new inquirer.Separator('----------------------------------'),
         '> Back'
     ];
 
@@ -120,13 +204,15 @@ const createAccount = async (keystore_path: string, wative_core: typeof WativeCo
             break;
         }
         case '> Import Private Key': {
-            await importPrivateKey(keystore_path, wative_core);
+            await createPrivateKeyAccount(keystore_path, wative_core);
             break;
         }
         case '> Back': {
             return;
         }
     }
+
+    wative_core.account.reloadAccount();
 }
 
 const getNetworkInfo = (keystore_path: string) => {
@@ -149,18 +235,28 @@ export const saveAccountInfo = (keystore_path: string, account_label: string, ac
 export const loginIn = async (account_label: string, wative_core: typeof WativeCore) => {
     const is_login = wative_core.account.isLogin(account_label);
     if (is_login) {
-        return true;
+        return { isLoginIn: true };
     }
-    let password = await inputPassword(`Please input the password for Account [${account_label}]`);
-    const login_result = await wative_core.account.login(account_label, password);
-    if (login_result.status) {
-        return true;
-    } else {
-        console.log(
-            chalk.red(login_result.output)
-        );
-        return false;
+
+    for (let i = 0; i < 3; i++) {
+        const password = await inputPassword(`Please input the password for Account [${account_label}]`);
+        if (!password) {
+            console.log(
+                chalk.red("Password can't be empty")
+            );
+            return { isLoginIn: false };
+        }
+
+        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)
+            );
+        }
     }
+    return { isLoginIn: false };
 }
 
 const selectAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
@@ -168,7 +264,8 @@ const selectAccount = async (keystore_path: string, wative_core: typeof WativeCo
     const account_label_list = networks.accounts;
 
     let select_account_options = [
-        "> Back"
+        '> Back',
+        new inquirer.Separator('----------------------------------')
     ];
 
     const account_label_len = account_label_list.length;
@@ -182,7 +279,7 @@ 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);
-        if (account_info.account_type === "PP") {
+        if ("data" in account_info) {
             select_account_options.push(`${i + 1}) ${account_label} [${account_info.account_type}:${account_info.data.length}]`);
         } else {
             select_account_options.push(`${i + 1}) ${account_label} [${account_info.account_type}:1]`);
@@ -190,14 +287,14 @@ const selectAccount = async (keystore_path: string, wative_core: typeof WativeCo
     }
 
     const selected_account = await selectSomething(select_account_options, "Select an account");
-    if (selected_account === "> Back") {
+    if (selected_account === '> Back') {
         return;
     }
 
-    const selected_account_label = account_label_list[select_account_options.indexOf(selected_account) - 1];
+    const selected_account_label = account_label_list[select_account_options.indexOf(selected_account) - 2];
     let login_result = await loginIn(selected_account_label, wative_core);
-    if (login_result) {
-        await accountManager(keystore_path, selected_account_label, wative_core);
+    if (login_result.isLoginIn) {
+        await accountManager(keystore_path, selected_account_label, wative_core, login_result.password);
     }
 
     await selectAccount(keystore_path, wative_core);
@@ -207,18 +304,19 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
     const account_info = await getAccountInfo(keystore_path, account_label);
 
     let disable_address_options = [
-        "> Back",
-        "1.Disabled Slots",
-        "2.Add Single",
-        "3.Add Range"
+        "> Disabled Slots",
+        "> Add Single",
+        "> Add Range",
+        new inquirer.Separator('----------------------------------'),
+        '> Back'
     ];
 
     const selected_disable_address = await selectSomething(disable_address_options);
     switch (selected_disable_address) {
-        case "> Back": {
+        case '> Back': {
             return;
         }
-        case "1.Disabled Slots": {
+        case "> Disabled Slots": {
             let disabled_slots = account_info.disabled_slots;
             if (!disabled_slots || disabled_slots.length === 0) {
                 console.log(
@@ -230,7 +328,8 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
             let account_data = account_info.data;
 
             let disabled_slots_options = [
-                "> Back",
+                '> Back',
+                new inquirer.Separator('----------------------------------'),
             ];
 
             let default_network = account_info.default_network;
@@ -284,7 +383,7 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
 
             let selected_disabled_slots = await selectSomething(disabled_slots_options);
 
-            if (selected_disabled_slots === "> Back") {
+            if (selected_disabled_slots === '> Back') {
                 break;
             }
 
@@ -292,14 +391,14 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
             if (!confirm) {
                 break;
             }
-            let selected_disabled_slots_index = disabled_slots_options.indexOf(selected_disabled_slots) - 1;
+            let selected_disabled_slots_index = disabled_slots_options.indexOf(selected_disabled_slots) - 2;
 
             account_info.disabled_slots.splice(selected_disabled_slots_index, 1);
             saveAccountInfo(keystore_path, account_label, account_info);
 
             break;
         }
-        case "2.Add Single": {
+        case "> Add Single": {
             let account_index_or_address = await getAccountIndex(account_info, "Input address or index");
             if (account_index_or_address === null) {
                 console.log(chalk.red("Invalid account index"));
@@ -321,7 +420,7 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
             saveAccountInfo(keystore_path, account_label, account_info);
             break;
         }
-        case "3.Add Range": {
+        case "> Add Range": {
             let account_range = await getAccountRange(account_info);
             if (!account_range) {
                 console.log(chalk.red("Invalid account range"));
@@ -343,41 +442,43 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
 }
 
 
-const accountManager = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+const accountManager = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore, password: string) => {
     let account_info = await getAccountInfo(keystore_path, account_label);
 
-    let account_manager_options: string[];
+    let account_manager_options: any[];
 
     if (account_info.account_type === "PP") {
         account_manager_options = [
-            '1.Address List',
-            '2.Expand Address',
-            '3.Slice Address',
-            '4.Disable Address',
-            '5.Reset Account Password',
-            `6.Switch Networks [${account_info.default_network}]`,
+            '> Address List',
+            '> Expand Address',
+            '> Slice Address',
+            '> Disable Address',
+            '> Reset Account Password',
+            `> Switch Networks [${account_info.default_network}]`,
+            '> Remove',
+            new inquirer.Separator('----------------------------------'),
             '> Back'
         ];
     } else {
         account_manager_options = [
-            '1.Address List',
-            '2.Reset Account Password',
-            `3.Switch Networks [${account_info.default_network}]`,
+            '> Address List',
+            '> Import Private Key',
+            '> Remove Address',
+            '> Reset Account Password',
+            `> Switch Networks [${account_info.default_network}]`,
+            '> Remove',
+            new inquirer.Separator('----------------------------------'),
             '> Back'
         ];
     }
 
     const selected_account_manager = await selectSomething(account_manager_options);
     switch (selected_account_manager) {
-        case '1.Address List': {
-            if (account_info.account_type === "PP") {
-                await showPPAccounts(keystore_path, account_label, wative_core);
-            } else {
-                await showPKAccounts(keystore_path, account_label, wative_core);
-            }
+        case '> Address List': {
+            await showAccounts(keystore_path, account_label, wative_core);
             break;
         }
-        case '2.Expand Address': {
+        case '> Expand Address': {
             const count = await inputSomething('Expand accounts count', expandAmountValidator);
             if (Number(count) > 2000) {
                 console.log(
@@ -389,20 +490,28 @@ const accountManager = async (keystore_path: string, account_label: string, wati
             await expandAddress(keystore_path, account_label, Number(count), wative_core);
             break;
         }
-        case '3.Slice Address': {
+        case '> Import Private Key': {
+            await importPrivateKeyAccount(keystore_path, password, account_label, wative_core);
+            break;
+        }
+        case '> Slice Address': {
             const last_account_no = await inputSomething('Please input last account number', lastAccountNoValidator);
             await sliceAddress(keystore_path, account_label, Number(last_account_no), wative_core);
             break;
         }
-        case '4.Disable Address': {
+        case '> Remove Address': {
+            await removeAddress(keystore_path, account_label, wative_core);
+            break;
+        }
+        case '> Disable Address': {
             await setDisableAddress(keystore_path, account_label, wative_core);
             break;
         }
-        case '5.Reset Account Password': {
+        case '> Reset Account Password': {
             const password1 = await inputPassword(`Please input new password for Account [${account_label}]`);
             const password2 = await inputPassword(`Please confirm new password for Account [${account_label}]`);
 
-            if (password1 !== password2) {
+            if (!password1 || !password2 || password1 !== password2) {
                 console.log(
                     chalk.red("Passwords do not match")
                 );
@@ -412,105 +521,98 @@ const accountManager = async (keystore_path: string, account_label: string, wati
             await wative_core.account.resetPassword(account_label, password1);
             return;
         }
-        case `3.Switch Networks [${account_info.default_network}]`: {
+        case `> Switch Networks [${account_info.default_network}]`: {
             await switchNetworkByAccountLabel(keystore_path, account_label, true);
             break;
         }
-        case `6.Switch Networks [${account_info.default_network}]`: {
-            await switchNetworkByAccountLabel(keystore_path, account_label, true);
+        case '> Remove': {
+            await removeAccountLabel(keystore_path, account_label);
             break;
         }
-        case '2.Reset Account Password': {
-            const password1 = await inputPassword(`Please input new password for Account [${account_label}]`);
-            const password2 = await inputPassword(`Please confirm new password for Account [${account_label}]`);
-
-            if (password1 !== password2) {
-                console.log(
-                    chalk.red("Passwords do not match")
-                );
-                break;
-            }
-
-            await wative_core.account.resetPassword(account_label, password1);
-            return;
-        }
         case '> Back': {
             return;
         }
     }
 
-    await accountManager(keystore_path, account_label, wative_core);
+    await accountManager(keystore_path, account_label, wative_core, password);
 }
 
-const showPPAccounts = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+const showAccounts = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
     const account_info = await getAccountInfo(keystore_path, account_label);
+
     let option_accounts: any = [
-        '> Back'
+        '> Back',
+        new inquirer.Separator('----------------------------------'),
     ];
-
     let disabled_slots = account_info.disabled_slots;
-    for (let i = 0; i < account_info.data.length; i++) {
-
-        let default_network = account_info.default_network;
-        if ("default_network" in account_info.data[i]) {
-            default_network = account_info.data[i].default_network;
-        }
-
-        let network_type = getNetworkTypeByName(keystore_path, default_network);
+    let status = getStatus(keystore_path);
 
-        let tag = "";
-        if ("tag" in account_info.data[i]) {
-            tag = `(${account_info.data[i].tag})`;
-        }
+    let default_network = account_info.default_network;
+    let network_info = getNetworkInfoByName(keystore_path, default_network);
+    let network_type = getChainType(network_info.chainId.toString());
 
+    for (let i = 0; i < account_info.data.length; i++) {
+        let tag = account_info.data[i].tag ? `(${account_info.data[i].tag})` : "";
         let is_disable_address = wative_core.account.checkIsDisableAddress(disabled_slots, i);
-        if (network_type === "evm") {
-            if (is_disable_address) {
-                option_accounts.push(new inquirer.Separator(
-                    chalk.yellow(`#${i} ${account_info.data[i].ciphertexts.evm.address} ${tag} [${default_network}]`)
-                ))
-            } else {
-                option_accounts.push(`#${i} ${account_info.data[i].ciphertexts.evm.address} ${tag} [${default_network}]`);
-            }
 
-        } else if (network_type === "solana") {
-            if (is_disable_address) {
-                option_accounts.push(new inquirer.Separator(
-                    chalk.yellow(`#${i} ${account_info.data[i].ciphertexts.solana.address} ${tag} [${default_network}]`)
-                ))
+        let account_address: string;
+        if (account_info.account_type === "PP") {
+            if (network_type === "evm") {
+                account_address = account_info.data[i].ciphertexts.evm.address;
             } else {
-                option_accounts.push(`#${i} ${account_info.data[i].ciphertexts.solana.address} ${tag} [${default_network}]`);
+                account_address = account_info.data[i].ciphertexts.solana.address;
             }
+        } else {
+            account_address = account_info.data[i].ciphertexts.address;
+        }
+
+        if (is_disable_address) {
+            option_accounts.push(
+                new inquirer.Separator(chalk.yellow(`#${i} ${formatAddr(account_address, status.fullAddr)} ${tag}`))
+            )
+        } else {
+            option_accounts.push(`#${i} ${formatAddr(account_address, status.fullAddr)} ${tag}`);
         }
     }
 
-    let selected_account = await selectSomething(option_accounts, "Select an account");
-    if (selected_account === "> Back") {
+    let selected_default_account = DEFAULT_ACCOUNT.account_label === account_label ? option_accounts[DEFAULT_ACCOUNT.account_index] : option_accounts[0];
+
+    let asset_info_list = await getAssetList(keystore_path, network_info.chainId);
+    let selected_account = await listWithLazyBalanceLoading(
+        option_accounts,
+        network_type === "evm",
+        keystore_path,
+        asset_info_list,
+        network_info,
+        status.gasToken,
+        status.extendedToken,
+        "Select an account",
+        selected_default_account
+    );
+
+    if (selected_account === '> Back') {
         return;
     }
 
-    let selected_account_id = option_accounts.indexOf(selected_account) - 1;
+    DEFAULT_ACCOUNT.account_label = account_label;
+    DEFAULT_ACCOUNT.account_index = option_accounts.indexOf(selected_account);
 
-    await showPPAccountDetail(keystore_path, account_label, selected_account_id, wative_core);
-    await showPPAccounts(keystore_path, account_label, wative_core);
+    await showAccountDetail(keystore_path, account_label, option_accounts.indexOf(selected_account) - 2, wative_core);
+    await showAccounts(keystore_path, account_label, wative_core);
 }
 
-const showPPAccountDetail = async (keystore_path: string, account_label: string, selected_account_id: number, wative_core: typeof WativeCore) => {
+const showAccountDetail = async (keystore_path: string, account_label: string, selected_account_id: number, wative_core: typeof WativeCore) => {
     const account_info = await getAccountInfo(keystore_path, account_label);
 
     let default_network = account_info.default_network;
-    if ("default_network" in account_info.data[selected_account_id]) {
-        default_network = account_info.data[selected_account_id].default_network;
-    }
+    let account_address = getAccountAddress(keystore_path, account_label, selected_account_id);
 
     const network = await getNetworkInfoByName(keystore_path, default_network);
-    let account_address = getAccountAddress(keystore_path, account_label, selected_account_id);
     const balance_result = await getAccountBalance(
         account_address,
         keystore_path,
         default_network
     );
-
     if (balance_result.status) {
         console.log(
             chalk.green(`  Address No: #${selected_account_id}\n  Network: ${default_network}\n  ${network.nativeCurrency.symbol} Balance: ${balance_result.output}`)
@@ -521,17 +623,21 @@ const showPPAccountDetail = async (keystore_path: string, account_label: string,
         );
     }
 
-    let tag = "> Tag()";
-    if ("tag" in account_info.data[selected_account_id] && account_info.data[selected_account_id].tag !== "") {
+    let tag = '> Tag';
+    if (
+        "tag" in account_info.data[selected_account_id] &&
+        account_info.data[selected_account_id].tag !== ""
+    ) {
         tag = `> Tag(${account_info.data[selected_account_id].tag})`;
     }
 
     let options_account_detail = [
         tag,
-        '> Switch network',
+        '> Show address',
         '> Assets',
         '> Tools',
         '> Dump private key',
+        new inquirer.Separator('----------------------------------'),
         '> Back'
     ];
 
@@ -539,7 +645,7 @@ const showPPAccountDetail = async (keystore_path: string, account_label: string,
 
     switch (selected_account_detail) {
         case tag: {
-            let cureent_tag = 'Current tag ()';
+            let cureent_tag = 'Current tag';
             if ("tag" in account_info.data[selected_account_id] && account_info.data[selected_account_id].tag !== "") {
                 cureent_tag = `Current tag (${account_info.data[selected_account_id].tag})`;
             }
@@ -549,12 +655,13 @@ const showPPAccountDetail = async (keystore_path: string, account_label: string,
             saveAccountInfo(keystore_path, account_label, account_info);
             break;
         }
-        case '> Switch network': {
-            await switchPPNetwork(keystore_path, account_label, selected_account_id);
+        case '> Show address': {
+            await showAllAccounts(keystore_path, account_label, selected_account_id);
             break;
         }
         case '> Assets': {
-            await showAssets(keystore_path, account_address, default_network);
+            await showAssetsDetail(keystore_path, default_network, account_address);
+            // await showAssets(keystore_path, account_address, default_network);
             break;
         }
         case '> Tools': {
@@ -574,92 +681,6 @@ const showPPAccountDetail = async (keystore_path: string, account_label: string,
     }
 }
 
-const showPKAccounts = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, account_label);
-    let option_accounts = [
-        '> Back'
-    ];
-
-    let tag = "";
-    if ("tag" in account_info && account_info.tag !== "") {
-        tag = `(${account_info.tag})`;
-    }
-
-    option_accounts.push(`#0 ${account_info.ciphertexts.address} ${tag} [${account_info.default_network}]`);
-    let selected_account = await selectSomething(option_accounts, "Select an account");
-    if (selected_account === "> Back") {
-        return;
-    }
-
-    let default_network = account_info.default_network;
-    const network = await getNetworkInfoByName(keystore_path, default_network);
-    console.log(
-        chalk.green(`  Address No: #0\n  Network: ${default_network}\n  ${network.nativeCurrency.symbol} Balance: 0`)
-    );
-
-    await showPKAccountDetail(keystore_path, account_label, wative_core);
-    await showPKAccounts(keystore_path, account_label, wative_core);
-}
-
-
-const showPKAccountDetail = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, account_label);
-    let tag = "> Tag()";
-    if ("tag" in account_info && account_info.tag !== "") {
-        tag = `> Tag(${account_info.tag})`;
-    }
-
-    let options_account_detail = [
-        tag,
-        '> Switch network',
-        '> Assets',
-        '> Tools',
-        '> Dump private key',
-        '> Back'
-    ];
-
-    let selected_account_detail = await selectSomething(options_account_detail);
-
-    switch (selected_account_detail) {
-        case tag: {
-            let cureent_tag = 'Current tag ()';
-            if ("tag" in account_info && account_info.tag !== "") {
-                cureent_tag = `Current tag (${account_info.tag})`;
-            }
-            let tag = await inputSomething(cureent_tag, tagValidator);
-            account_info.tag = tag.replace(/\s+/g, " ").trim().toLocaleLowerCase();
-            saveAccountInfo(keystore_path, account_label, account_info);
-            break;
-        }
-        case '> Switch network': {
-            await switchNetworkByAccountLabel(keystore_path, account_label, false);
-            break;
-        }
-        case '> Assets': {
-            let account_address = getPKAccountAddress(keystore_path, account_label);
-            await showAssets(keystore_path, account_address, account_info.default_network);
-            break;
-        }
-        case '> Tools': {
-            let account_address = getPKAccountAddress(keystore_path, account_label);
-            await selectToolsOptions(keystore_path, account_label, account_address, wative_core);
-            break;
-        }
-        case '> Dump private key': {
-            let account_address = getPKAccountAddress(keystore_path, account_label);
-            let private_key = await wative_core.account.showPrivateKey(account_address);
-            console.log("account: ", account_address);
-            console.log("private key: ", private_key);
-            break;
-        }
-        case '> Back': {
-            return;
-        }
-    }
-
-    await showPKAccountDetail(keystore_path, account_label, wative_core);
-}
-
 const expandAddress = async (keystore_path: string, account_label: string, expand_amount: number, wative_core: typeof WativeCore) => {
     const account_info = await getAccountInfo(keystore_path, account_label);
     const account_len = account_info.data.length;
@@ -681,6 +702,7 @@ const expandAddress = async (keystore_path: string, account_label: string, expan
     bar1.stop();
 
     saveAccountInfo(keystore_path, account_label, account_info);
+    wative_core.account.reloadAccount();
 }
 
 const sliceAddress = async (keystore_path: string, account_label: string, last_account_no: number, wative_core: typeof WativeCore) => {
@@ -690,17 +712,65 @@ const sliceAddress = async (keystore_path: string, account_label: string, last_a
     wative_core.account.reloadAccount();
 }
 
+const removeAddress = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+    let account_index = await inputSomething('Please input the accountIndex to remove this account', numberValidator);
+    if (account_index === "0") {
+        console.log(chalk.red("Can't remove the first account"));
+        return;
+    }
+
+    let account_info = await getAccountInfo(keystore_path, account_label);
+    let isConfirm = await confirmSomething(`Are you sure you want to remove this account(${account_info.data[account_index].ciphertexts.address})`);
+    if (!isConfirm) {
+        return;
+    }
+
+    account_info.data.splice(Number(account_index), 1);
+    saveAccountInfo(keystore_path, account_label, account_info);
+    wative_core.account.reloadAccount();
+}
+
+const removeAccountLabel = async (keystore_path: string, account_label: string) => {
+    let _accountLabel = await inputSomething('Please input the accountLabel to remove this account');
+    if (_accountLabel !== account_label) {
+        console.log(chalk.red("Can't remove this account"));
+        return;
+    }
+
+    const isConfirm = await confirmSomething(`Are you sure you want to remove this account(${account_label})`);
+    if (!isConfirm) {
+        return;
+    }
+
+    let account_label_path = path.join(keystore_path, `accounts/${account_label}.json`);
+    fs.rmSync(account_label_path);
+}
+
+
 export const accountSetting = async (keystore_path: string, wative_core: typeof WativeCore) => {
     const account_path = path.resolve(keystore_path, 'accounts');
     if (!fs.existsSync(account_path)) {
         fs.mkdirSync(account_path);
     }
 
-    const account_setting_options = [
-        '> Select an account',
-        '> Create a new account',
-        '> Back'
-    ];
+    const networks = getNetworkInfo(keystore_path);
+    const account_label_list = networks.accounts;
+
+    let account_setting_options: any[];
+    if (account_label_list.length === 0) {
+        account_setting_options = [
+            '> Create a new account',
+            new inquirer.Separator('----------------------------------'),
+            '> Back'
+        ];
+    } else {
+        account_setting_options = [
+            '> Select an account',
+            '> Create a new account',
+            new inquirer.Separator('----------------------------------'),
+            '> Back'
+        ];
+    }
 
     let selected_account_setting = await selectSomething(account_setting_options);