wative 1.2.7 → 1.2.10

package/src/account.ts

@@ -1,864 +0,0 @@
-const chalk = require('chalk');
-import * as fs from "fs";
-import * as path from "path";
-import {
-    getAccountName,
-    selectSomething,
-    inputPassword,
-    inputSomething,
-    tagValidator,
-    passphraseValidator,
-    expandAmountValidator,
-    lastAccountNoValidator,
-    getAccountIndex,
-    getAccountRange,
-    confirmSomething,
-    numberValidator,
-    formatAddr,
-    listWithLazyBalanceLoading,
-    inputPasswordWithoutValidator,
-    getKeystoreSlugByAccountName,
-    getAccountNameByKeystoreSlug,
-    inputMaskedPassword,
-    importMaskedPassphrase
-} from "./utils";
-import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getStatus, selectDefaultNetwork, showAllAccounts, switchNetworkByAccountName } from "./network";
-import { getAssetList, showAssetsDetail, updateTokenBalanceOption } from './assets';
-import { selectToolsOptions } from './tools';
-import inquirer from "inquirer";
-import { getChainType } from "./chain";
-
-require("dotenv").config();
-const cliProgress = require('cli-progress');
-const { WativeCore } = require("wative-core");
-
-const DEFAULT_ACCOUNT: any = {
-    keystore_slug: '',
-    default_account_index: 0
-};
-
-const preAccountImport = async (keystore_path: string) => {
-    const networks = getNetworkInfo(keystore_path)
-
-    let account_name_list: string[] = [];
-    if (networks.accounts) {
-        account_name_list = networks.accounts;
-    }
-
-    let account_name = await getAccountName('Account Name', account_name_list);
-    if (account_name === null) {
-        return null;
-    }
-
-    let password = await inputPassword(`Please set a password for Account [${account_name}]`);
-    let selected_default_network = await selectDefaultNetwork(keystore_path);
-
-    let pre_account_info = {
-        account_name,
-        password,
-        selected_default_network
-    };
-
-    return pre_account_info;
-}
-
-
-// account label
-// cureent network
-// data version 1: only evm or only solana 2: evm and solana
-const importPassphrase = async (keystore_path: string, wative_core: typeof WativeCore) => {
-    let pre_account_info = await preAccountImport(keystore_path);
-    if (!pre_account_info) {
-        return;
-    }
-
-    let passphrase = await importMaskedPassphrase('Please enter a mnemonic [split by space]', passphraseValidator);
-    passphrase = passphrase.replace(/\s+/g, " ");
-
-    let keystore_slug = getKeystoreSlugByAccountName(pre_account_info.account_name);
-    const passphrase_account = wative_core.account.generatePPAccount(keystore_slug, 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/${keystore_slug}.json`);
-
-    passphrase_account.output.default_network = pre_account_info.selected_default_network;
-    fs.writeFileSync(account_info_path, JSON.stringify(passphrase_account.output, 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_name);
-    fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
-}
-
-
-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 inputMaskedPassword('Please enter a private key');
-    let keystore_slug = getKeystoreSlugByAccountName(pre_account_info.account_name);
-    await _importAccount(
-        keystore_path,
-        pre_account_info.password,
-        keystore_slug,
-        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_name);
-
-    fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
-}
-
-const importPrivateKeyAccount = async (
-    keystore_path: string,
-    password: string,
-    keystore_slug: string,
-    wative_core: typeof WativeCore
-) => {
-    let private_key = await inputSomething('Please enter a private key');
-    let account_info_path = path.join(keystore_path, `accounts/${keystore_slug}.json`);
-    let exist_account_info = JSON.parse(fs.readFileSync(account_info_path, 'utf8'));
-
-    await _importAccount(
-        keystore_path,
-        password,
-        keystore_slug,
-        private_key,
-        exist_account_info.default_network,
-        wative_core,
-        false
-    );
-}
-
-const _importAccount = async (
-    keystore_path: string,
-    password: string,
-    keystore_slug: string,
-    private_key: string,
-    default_network: string,
-    wative_core: typeof WativeCore,
-    generate_keystore_slug: boolean
-) => {
-    let network_info = await getNetworkInfoByName(keystore_path, default_network);
-
-    let network_type = getChainType(network_info.chainId.toString());
-    if (network_type === 'evm' && !private_key.startsWith('0x')) {
-        private_key = "0x" + private_key;
-    }
-
-    let privatekey_account = await wative_core.account.generatePKAccount(keystore_slug, private_key, password, network_info.chainId.toString(), generate_keystore_slug);
-    if (!privatekey_account.status) {
-        console.log(
-            chalk.red(privatekey_account.output)
-        );
-        return;
-    }
-    let account_info_path = path.join(keystore_path, `accounts/${keystore_slug}.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) {
-            const exist_account_address_list = exist_account_info.data.map((item: any) => {
-                return item.ciphertexts.address;
-            });
-
-            if (exist_account_address_list.includes(privatekey_account.output.ciphertexts.address)) {
-                console.log(
-                    chalk.red("The account has already been imported")
-                );
-                return;
-            }
-
-            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;
-    }
-
-    fs.writeFileSync(account_info_path, JSON.stringify(result, 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'
-    ];
-
-    let selected_create_account = await selectSomething(create_account_options);
-
-    switch (selected_create_account) {
-        case '> Import Passphrase': {
-            await importPassphrase(keystore_path, wative_core);
-            break;
-        }
-        case '> Import Private Key': {
-            await createPrivateKeyAccount(keystore_path, wative_core);
-            break;
-        }
-        case '> Back': {
-            return;
-        }
-    }
-
-    wative_core.account.reloadAccount();
-}
-
-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;
-}
-
-export const getAccountInfo = (keystore_path: string, keystore_slug: string) => {
-    const account_info_path = path.join(keystore_path, `accounts/${keystore_slug}.json`);
-    const account_info = JSON.parse(fs.readFileSync(account_info_path, 'utf8'));
-    return account_info;
-}
-
-export const saveAccountInfo = (keystore_path: string, keystore_slug: string, account_info: any) => {
-    const account_info_path = path.join(keystore_path, `accounts/${keystore_slug}.json`);
-    fs.writeFileSync(account_info_path, JSON.stringify(account_info, null, 4));
-}
-
-export const loginIn = async (keystore_path: string, keystore_slug: string, wative_core: typeof WativeCore) => {
-    const is_login = wative_core.account.isLogin(keystore_slug);
-    if (is_login) {
-        return { isLoginIn: true };
-    }
-
-    for (let i = 0; i < 3; i++) {
-        let account_name = getAccountNameByKeystoreSlug(keystore_path, keystore_slug);
-        let password_name = 'WATIVE_PASSWD_' + keystore_slug;
-        let password: any;
-        if (process.env[password_name] && process.env[password_name] !== '') {
-            password = process.env[password_name];
-        } else if (process.env.WativePassword && process.env.WativePassword !== '') {
-            password = process.env.WativePassword;
-        } else {
-            password = await inputPasswordWithoutValidator(`Please input the password for Account [${account_name}]`);
-        }
-        if (!password) {
-            console.log(
-                chalk.red("Password can't be empty")
-            );
-            return { isLoginIn: false };
-        }
-
-        const login_result = await wative_core.account.login(keystore_slug, password);
-        if (login_result.status) {
-            return { isLoginIn: true, password };
-        }
-
-        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 };
-}
-
-const selectAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
-    const networks = getNetworkInfo(keystore_path);
-    const account_name_list = networks.accounts;
-
-    let select_account_options = [
-        '> Back',
-        new inquirer.Separator('----------------------------------')
-    ];
-
-    const account_name_len = account_name_list.length;
-    if (account_name_len === 0) {
-        console.log(
-            chalk.red("No address here yet")
-        );
-        return;
-    }
-
-    for (let i = 0; i < account_name_len; i++) {
-        const account_name = account_name_list[i];
-        const keystore_slug = getKeystoreSlugByAccountName(account_name);
-        const account_info = getAccountInfo(keystore_path, keystore_slug);
-        if ("data" in account_info) {
-            select_account_options.push(`${i + 1}) ${account_name} [${account_info.account_type}:${account_info.data.length}]`);
-        } else {
-            select_account_options.push(`${i + 1}) ${account_name} [${account_info.account_type}:1]`);
-        }
-    }
-
-    const selected_account = await selectSomething(select_account_options, "Select an account");
-    if (selected_account === '> Back') {
-        return;
-    }
-
-    const selected_account_name = account_name_list[select_account_options.indexOf(selected_account) - 2];
-    const keystore_slug = getKeystoreSlugByAccountName(selected_account_name);
-
-    console.log(
-        chalk.green(`Keystore slug: [${keystore_slug}]`)
-    );
-    let login_result = await loginIn(keystore_path, keystore_slug, wative_core);
-    if (login_result.isLoginIn) {
-        await accountManager(keystore_path, keystore_slug, wative_core, login_result.password);
-    }
-
-    await selectAccount(keystore_path, wative_core);
-}
-
-const setDisableAddress = async (keystore_path: string, keystore_slug: string, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, keystore_slug);
-
-    let disable_address_options = [
-        "> 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': {
-            return;
-        }
-        case "> Disabled Slots": {
-            let disabled_slots = account_info.disabled_slots;
-            if (!disabled_slots || disabled_slots.length === 0) {
-                console.log(
-                    chalk.red("No disabled slots here yet")
-                )
-                break;
-            }
-
-            let account_data = account_info.data;
-
-            let disabled_slots_options = [
-                '> Back',
-                new inquirer.Separator('----------------------------------'),
-            ];
-
-            let default_network = account_info.default_network;
-            for (let i = 0; i < disabled_slots.length; i++) {
-                let from = disabled_slots[i].from;
-                let to = disabled_slots[i].to;
-
-                let from_default_network = default_network;
-                let to_default_network = default_network;
-
-                if ("default_network" in account_data[from]) {
-                    from_default_network = account_data[from].default_network;
-                }
-
-                if ("default_network" in account_data[to]) {
-                    to_default_network = account_data[to].default_network;
-                }
-
-                let from_network_type = getNetworkTypeByName(keystore_path, from_default_network);
-                let to_network_type = getNetworkTypeByName(keystore_path, to_default_network);
-
-                if (from_network_type !== "evm" && from_network_type !== "solana") {
-                    throw new Error(`Invalid network type: ${from_network_type}`);
-                }
-
-                if (to_network_type !== "evm" && to_network_type !== "solana") {
-                    throw new Error(`Invalid network type: ${to_network_type}`);
-                }
-
-                let from_address: string;
-                let to_address: string;
-
-                if (from_network_type === "evm") {
-                    from_address = account_data[from].ciphertexts.evm.address;
-                } else {
-                    from_address = account_data[to].ciphertexts.solana.address;
-                }
-
-                if (to_network_type === "evm") {
-                    to_address = account_data[to].ciphertexts.evm.address;
-                } else {
-                    to_address = account_data[to].ciphertexts.solana.address;
-                }
-
-                if (from === to) {
-                    disabled_slots_options.push(`${i + 1}. ${from_address}[${from}]`);
-                } else {
-                    disabled_slots_options.push(`${i + 1}. ${from_address}[${from}]-${to_address}[${to}]`);
-                }
-            }
-
-            let selected_disabled_slots = await selectSomething(disabled_slots_options);
-
-            if (selected_disabled_slots === '> Back') {
-                break;
-            }
-
-            let confirm = await confirmSomething(`Are you sure to delete the ${selected_disabled_slots}?`, true);
-            if (!confirm) {
-                break;
-            }
-            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, keystore_slug, account_info);
-
-            break;
-        }
-        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"));
-                break;
-            }
-
-            if (account_info.disabled_slots) {
-                account_info.disabled_slots.push({
-                    from: account_index_or_address,
-                    to: account_index_or_address
-                });
-            } else {
-                account_info.disabled_slots = [{
-                    from: account_index_or_address,
-                    to: account_index_or_address
-                }];
-            }
-
-            saveAccountInfo(keystore_path, keystore_slug, account_info);
-            break;
-        }
-        case "> Add Range": {
-            let account_range = await getAccountRange(account_info);
-            if (!account_range) {
-                console.log(chalk.red("Invalid account range"));
-                break;
-            }
-
-            if (account_info.disabled_slots) {
-                account_info.disabled_slots.push(account_range);
-            } else {
-                account_info.disabled_slots = [account_range];
-            }
-
-            saveAccountInfo(keystore_path, keystore_slug, account_info);
-            break;
-        }
-    }
-
-    await setDisableAddress(keystore_path, keystore_slug, wative_core);
-}
-
-
-const accountManager = async (keystore_path: string, keystore_slug: string, wative_core: typeof WativeCore, password: string) => {
-    let account_info = await getAccountInfo(keystore_path, keystore_slug);
-
-    let account_manager_options: any[];
-
-    if (account_info.account_type === "PP") {
-        account_manager_options = [
-            '> 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 = [
-            '> 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 '> Address List': {
-            await showAccounts(keystore_path, keystore_slug, wative_core);
-            break;
-        }
-        case '> Expand Address': {
-            const count = await inputSomething('Expand accounts count', expandAmountValidator);
-            if (Number(count) > 2000) {
-                console.log(
-                    chalk.red("Too many accounts, please input less than 2000")
-                );
-                break;
-            }
-
-            await expandAddress(keystore_path, keystore_slug, Number(count), wative_core);
-            break;
-        }
-        case '> Import Private Key': {
-            await importPrivateKeyAccount(keystore_path, password, keystore_slug, wative_core);
-            break;
-        }
-        case '> Slice Address': {
-            const last_account_no = await inputSomething('Please input last account number', lastAccountNoValidator);
-            await sliceAddress(keystore_path, keystore_slug, Number(last_account_no), wative_core);
-            break;
-        }
-        case '> Remove Address': {
-            await removeAddress(keystore_path, keystore_slug, wative_core);
-            break;
-        }
-        case '> Disable Address': {
-            await setDisableAddress(keystore_path, keystore_slug, wative_core);
-            break;
-        }
-        case '> Reset Account Password': {
-            let account_name = getAccountNameByKeystoreSlug(keystore_path, keystore_slug);
-            const password1 = await inputPassword(`Please input new password for Account [${account_name}]`);
-            const password2 = await inputPassword(`Please confirm new password for Account [${account_name}]`);
-
-            if (!password1 || !password2 || password1 !== password2) {
-                console.log(
-                    chalk.red("Passwords do not match")
-                );
-                break;
-            }
-
-            await wative_core.account.resetPassword(keystore_slug, password1);
-            return;
-        }
-        case `> Switch Networks [${account_info.default_network}]`: {
-            await switchNetworkByAccountName(keystore_path, keystore_slug, true);
-            break;
-        }
-        case '> Remove': {
-            await removeAccountName(keystore_path, keystore_slug);
-            return;
-        }
-        case '> Back': {
-            return;
-        }
-    }
-
-    await accountManager(keystore_path, keystore_slug, wative_core, password);
-}
-
-const showAccounts = async (keystore_path: string, keystore_slug: string, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, keystore_slug);
-
-    let option_accounts: any = [
-        '> Back',
-        new inquirer.Separator('----------------------------------'),
-    ];
-    let option_account_addrs: any = [null, null];
-    let disabled_slots = account_info.disabled_slots;
-    let status = getStatus(keystore_path);
-
-    let default_network = account_info.default_network;
-    let network_info = getNetworkInfoByName(keystore_path, default_network);
-    let network_type = getChainType(network_info.chainId.toString());
-
-    let pad_index = account_info.data.length.toString().length + 1;
-    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);
-
-        let account_address: string;
-        if (account_info.account_type === "PP") {
-            if (network_type === "evm") {
-                account_address = account_info.data[i].ciphertexts.evm.address;
-            } else {
-                account_address = account_info.data[i].ciphertexts.solana.address;
-            }
-        } else {
-            account_address = account_info.data[i].ciphertexts.address;
-        }
-
-        option_account_addrs.push(account_address);
-        if (is_disable_address) {
-            option_accounts.push(
-                new inquirer.Separator(chalk.yellow(`#${i.toString().padEnd(pad_index)} ${formatAddr(account_address, status.fullAddr)} ${tag}`))
-            )
-        } else {
-            option_accounts.push(`#${i.toString().padEnd(pad_index)} ${formatAddr(account_address, status.fullAddr)} ${tag}`);
-        }
-    }
-
-    let selected_default_account = DEFAULT_ACCOUNT.keystore_slug === keystore_slug ? option_accounts[DEFAULT_ACCOUNT.account_index] : option_accounts[0];
-    let direct_display = DEFAULT_ACCOUNT.keystore_slug === keystore_slug && DEFAULT_ACCOUNT.account_index > 0;
-    let asset_info_list = await getAssetList(keystore_path, network_info.chainId.toString());
-
-    let to_select_account: any;
-    if (direct_display && DEFAULT_ACCOUNT.account_index > 15) {
-        let option_accounts_slice1 = option_accounts.slice(0, DEFAULT_ACCOUNT.account_index - 15);
-        let option_accounts_slice2 = option_accounts.slice(DEFAULT_ACCOUNT.account_index - 15);
-        to_select_account = option_accounts_slice2.concat(option_accounts_slice1);
-    } else {
-        to_select_account = option_accounts.slice(0);
-    }
-
-    let selected_account = await listWithLazyBalanceLoading(
-        to_select_account,
-        network_type === "evm",
-        keystore_path,
-        asset_info_list,
-        network_info,
-        status.gasToken,
-        status.extendedToken,
-        direct_display,
-        "Select an account",
-        selected_default_account
-    );
-
-    if (selected_account === '> Back') {
-        return;
-    }
-
-    DEFAULT_ACCOUNT.keystore_slug = keystore_slug;
-    DEFAULT_ACCOUNT.account_index = option_accounts.indexOf(selected_account);
-
-    await showAccountDetail(keystore_path, keystore_slug, option_accounts.indexOf(selected_account) - 2, wative_core);
-    await showAccounts(keystore_path, keystore_slug, wative_core);
-}
-
-const showAccountDetail = async (keystore_path: string, keystore_slug: string, selected_account_id: number, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, keystore_slug);
-
-    let default_network = account_info.default_network;
-    let account_address = getAccountAddress(keystore_path, keystore_slug, selected_account_id);
-
-    const network = await getNetworkInfoByName(keystore_path, default_network);
-    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}`)
-        );
-    } else {
-        console.log(
-            chalk.green(`  Address No: #${selected_account_id}\n  Network: ${default_network}\n  ${network.nativeCurrency.symbol}`)
-        );
-    }
-
-    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 = [
-        '> Tools',
-        '> Show address',
-        '> Assets',
-        tag,
-        '> Reload balances',
-        '> Dump private key',
-        new inquirer.Separator('----------------------------------'),
-        '> Back'
-    ];
-
-    let selected_account_detail = await selectSomething(options_account_detail);
-
-    switch (selected_account_detail) {
-        case '> Tools': {
-            await selectToolsOptions(keystore_path, keystore_slug, account_address, wative_core);
-            break;
-        }
-        case '> Show address': {
-            await showAllAccounts(keystore_path, keystore_slug, selected_account_id);
-            break;
-        }
-        case '> Assets': {
-            await showAssetsDetail(keystore_path, default_network, account_address);
-            // await showAssets(keystore_path, account_address, default_network);
-            break;
-        }
-        case '> Reload balances': {
-            await updateTokenBalanceOption(keystore_path, default_network, account_address);
-            break;
-        }
-        case tag: {
-            let current_tag = 'Current tag';
-            if ("tag" in account_info.data[selected_account_id] && account_info.data[selected_account_id].tag !== "") {
-                current_tag = `Current tag (${account_info.data[selected_account_id].tag})`;
-            }
-            let tag = await inputSomething(current_tag, tagValidator);
-            account_info.data[selected_account_id].tag = tag.replace(/\s+/g, " ").trim();
-            saveAccountInfo(keystore_path, keystore_slug, account_info);
-            break;
-        }
-        case '> Dump private key': {
-            let account_address = getAccountAddress(keystore_path, keystore_slug, selected_account_id);
-            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;
-        }
-    }
-}
-
-const expandAddress = async (keystore_path: string, keystore_slug: string, expand_amount: number, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, keystore_slug);
-    const account_len = account_info.data.length;
-    const bar1 = new cliProgress.SingleBar({}, cliProgress.Presets.legacy);
-    bar1.start(expand_amount, 0);
-    for (let i = account_len; i < account_len + expand_amount; i++) {
-        let sub_account = await wative_core.account.generateSubAccount(keystore_slug, i);
-        if (!sub_account.status) {
-            console.log(
-                chalk.red(sub_account.output)
-            );
-            return;
-        }
-        account_info.data.push({
-            ciphertexts: sub_account.output
-        });
-        bar1.increment();
-    }
-    bar1.stop();
-
-    saveAccountInfo(keystore_path, keystore_slug, account_info);
-    wative_core.account.reloadAccount();
-}
-
-const sliceAddress = async (keystore_path: string, keystore_slug: string, last_account_no: number, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, keystore_slug);
-    account_info.data = account_info.data.slice(0, last_account_no + 1);
-    saveAccountInfo(keystore_path, keystore_slug, account_info);
-    wative_core.account.reloadAccount();
-}
-
-const removeAddress = async (keystore_path: string, keystore_slug: 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, keystore_slug);
-    let isConfirm = await confirmSomething(`Are you sure you want to remove this account(${account_info.data[account_index].ciphertexts.address})`, true);
-    if (!isConfirm) {
-        return;
-    }
-
-    account_info.data.splice(Number(account_index), 1);
-    saveAccountInfo(keystore_path, keystore_slug, account_info);
-    wative_core.account.reloadAccount();
-}
-
-const removeAccountName = async (keystore_path: string, keystore_slug: string) => {
-    let _account_name = await inputSomething('Please input the account name to remove this account');
-    let account_name = getAccountNameByKeystoreSlug(keystore_path, keystore_slug);
-    if (_account_name !== account_name) {
-        console.log(chalk.red("Can't remove this account"));
-        return;
-    }
-
-    const isConfirm = await confirmSomething(`Are you sure you want to remove this account(${account_name})`, true);
-    if (!isConfirm) {
-        return;
-    }
-
-    let keystore_slug_path = path.join(keystore_path, `accounts/${keystore_slug}.json`);
-    fs.rmSync(keystore_slug_path);
-
-    const network_path = path.resolve(keystore_path, 'network.json');
-    if (!fs.existsSync(network_path)) {
-        return;
-    }
-
-    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
-    let account_name_index = networks.accounts.indexOf(account_name);
-    networks.accounts.splice(account_name_index, 1);
-    fs.writeFileSync(network_path, JSON.stringify(networks, null, 2));
-}
-
-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 networks = getNetworkInfo(keystore_path);
-    const account_name_list = networks.accounts;
-
-    let account_setting_options: any[];
-    if (account_name_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);
-
-    switch (selected_account_setting) {
-        case '> Select an account': {
-            await selectAccount(keystore_path, wative_core);
-            break;
-        }
-        case '> Create a new account': {
-            await createAccount(keystore_path, wative_core);
-            break;
-        }
-        case '> Back': {
-            return;
-        }
-    }
-
-    await accountSetting(keystore_path, wative_core);
-}