wative 1.0.35 → 1.0.37

package/src/account.ts

@@ -2,7 +2,7 @@ const chalk = require('chalk');
 import * as fs from "fs";
 import * as path from "path";
 import {
-    getAccountLabel,
+    getAccountName,
     selectSomething,
     inputPassword,
     inputSomething,
@@ -17,9 +17,10 @@ import {
     formatAddr,
     listWithLazyBalanceLoading,
     inputPasswordWithoutValidator,
-    format_account_label,
+    getKeystoreSlugByAccountName,
+    getAccountNameByKeystoreSlug,
 } from "./utils";
-import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getStatus, selectDefaultNetwork, showAllAccounts, switchNetworkByAccountLabel } from "./network";
+import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getStatus, selectDefaultNetwork, showAllAccounts, switchNetworkByAccountName } from "./network";
 import { getAssetList, showAssetsDetail } from './assets';
 import { selectToolsOptions } from './tools';
 import inquirer from "inquirer";
@@ -30,28 +31,28 @@ const cliProgress = require('cli-progress');
 const { WativeCore } = require("wative-core");
 
 const DEFAULT_ACCOUNT: any = {
-    account_label: '',
+    keystore_slug: '',
     default_account_index: 0
 };
 
 const preAccountImport = async (keystore_path: string) => {
     const networks = getNetworkInfo(keystore_path)
 
-    let account_label_list: string[] = [];
+    let account_name_list: string[] = [];
     if (networks.accounts) {
-        account_label_list = networks.accounts;
+        account_name_list = networks.accounts;
     }
 
-    let account_label = await getAccountLabel('Account Label', account_label_list);
-    if (account_label === null) {
+    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_label}]`);
+    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_label,
+        account_name,
         password,
         selected_default_network
     };
@@ -72,22 +73,22 @@ 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, " ");
 
-    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);
+    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/${formatted_account_label}.json`);
+    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_label);
+    networks.accounts.push(pre_account_info.account_name);
     fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
 }
 
@@ -99,11 +100,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);
+    let keystore_slug = getKeystoreSlugByAccountName(pre_account_info.account_name);
     await _importAccount(
         keystore_path,
         pre_account_info.password,
-        formatted_account_label,
+        keystore_slug,
         private_key,
         pre_account_info.selected_default_network,
         wative_core,
@@ -112,7 +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);
+    networks.accounts.push(pre_account_info.account_name);
 
     fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
 }
@@ -120,17 +121,17 @@ const createPrivateKeyAccount = async (keystore_path: string, wative_core: typeo
 const importPrivateKeyAccount = async (
     keystore_path: string,
     password: string,
-    account_label: 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/${account_label}.json`);
+    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,
-        account_label,
+        keystore_slug,
         private_key,
         exist_account_info.default_network,
         wative_core,
@@ -141,11 +142,11 @@ const importPrivateKeyAccount = async (
 const _importAccount = async (
     keystore_path: string,
     password: string,
-    account_label: string,
+    keystore_slug: string,
     private_key: string,
     default_network: string,
     wative_core: typeof WativeCore,
-    generate_account_label: boolean
+    generate_keystore_slug: boolean
 ) => {
     let network_info = await getNetworkInfoByName(keystore_path, default_network);
 
@@ -154,14 +155,14 @@ const _importAccount = async (
         private_key = "0x" + private_key;
     }
 
-    let privatekey_account = await wative_core.account.generatePKAccount(account_label, private_key, password, network_info.chainId.toString(), generate_account_label);
+    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/${account_label}.json`);
+    let account_info_path = path.join(keystore_path, `accounts/${keystore_slug}.json`);
 
     let result: any;
     if (fs.existsSync(account_info_path)) {
@@ -228,29 +229,31 @@ export const getNetworkInfo = (keystore_path: string) => {
     return networks;
 }
 
-export const getAccountInfo = (keystore_path: string, account_label: string) => {
-    const account_info_path = path.join(keystore_path, `accounts/${account_label}.json`);
+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, account_label: string, account_info: any) => {
-    const account_info_path = path.join(keystore_path, `accounts/${account_label}.json`);
+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 (account_label: string, wative_core: typeof WativeCore) => {
-    const is_login = wative_core.account.isLogin(account_label);
+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: any;
         if (process.env.WativePassword && process.env.WativePassword !== '') {
             password = process.env.WativePassword;
         } else {
-            password = await inputPasswordWithoutValidator(`Please input the password for Account [${account_label}]`);
+            password = await inputPasswordWithoutValidator(`Please input the password for Account [${account_name}]`);
         }
         if (!password) {
             console.log(
@@ -259,7 +262,7 @@ export const loginIn = async (account_label: string, wative_core: typeof WativeC
             return { isLoginIn: false };
         }
 
-        const login_result = await wative_core.account.login(account_label, password);
+        const login_result = await wative_core.account.login(keystore_slug, password);
         if (login_result.status) {
             return { isLoginIn: true, password };
         }
@@ -280,29 +283,29 @@ export const loginIn = async (account_label: string, wative_core: typeof WativeC
 
 const selectAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
     const networks = getNetworkInfo(keystore_path);
-    const account_label_list = networks.accounts;
+    const account_name_list = networks.accounts;
 
     let select_account_options = [
         '> Back',
         new inquirer.Separator('----------------------------------')
     ];
 
-    const account_label_len = account_label_list.length;
-    if (account_label_len === 0) {
+    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_label_len; i++) {
-        const account_label = account_label_list[i];
-        const formatted_account_label = format_account_label(account_label);
-        const account_info = getAccountInfo(keystore_path, formatted_account_label);
+    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_label} [${account_info.account_type}:${account_info.data.length}]`);
+            select_account_options.push(`${i + 1}) ${account_name} [${account_info.account_type}:${account_info.data.length}]`);
         } else {
-            select_account_options.push(`${i + 1}) ${account_label} [${account_info.account_type}:1]`);
+            select_account_options.push(`${i + 1}) ${account_name} [${account_info.account_type}:1]`);
         }
     }
 
@@ -311,19 +314,19 @@ const selectAccount = async (keystore_path: string, wative_core: typeof WativeCo
         return;
     }
 
-    const selected_account_label = account_label_list[select_account_options.indexOf(selected_account) - 2];
-    const formatted_account_label = format_account_label(selected_account_label);
+    const selected_account_name = account_name_list[select_account_options.indexOf(selected_account) - 2];
+    const keystore_slug = getKeystoreSlugByAccountName(selected_account_name);
 
-    let login_result = await loginIn(formatted_account_label, wative_core);
+    let login_result = await loginIn(keystore_path, keystore_slug, wative_core);
     if (login_result.isLoginIn) {
-        await accountManager(keystore_path, formatted_account_label, wative_core, login_result.password);
+        await accountManager(keystore_path, keystore_slug, wative_core, login_result.password);
     }
 
     await selectAccount(keystore_path, wative_core);
 }
 
-const setDisableAddress = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, account_label);
+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",
@@ -416,7 +419,7 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
             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);
+            saveAccountInfo(keystore_path, keystore_slug, account_info);
 
             break;
         }
@@ -439,7 +442,7 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
                 }];
             }
 
-            saveAccountInfo(keystore_path, account_label, account_info);
+            saveAccountInfo(keystore_path, keystore_slug, account_info);
             break;
         }
         case "> Add Range": {
@@ -455,17 +458,17 @@ const setDisableAddress = async (keystore_path: string, account_label: string, w
                 account_info.disabled_slots = [account_range];
             }
 
-            saveAccountInfo(keystore_path, account_label, account_info);
+            saveAccountInfo(keystore_path, keystore_slug, account_info);
             break;
         }
     }
 
-    await setDisableAddress(keystore_path, account_label, wative_core);
+    await setDisableAddress(keystore_path, keystore_slug, wative_core);
 }
 
 
-const accountManager = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore, password: string) => {
-    let account_info = await getAccountInfo(keystore_path, account_label);
+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[];
 
@@ -497,7 +500,7 @@ const accountManager = async (keystore_path: string, account_label: string, wati
     const selected_account_manager = await selectSomething(account_manager_options);
     switch (selected_account_manager) {
         case '> Address List': {
-            await showAccounts(keystore_path, account_label, wative_core);
+            await showAccounts(keystore_path, keystore_slug, wative_core);
             break;
         }
         case '> Expand Address': {
@@ -509,29 +512,30 @@ const accountManager = async (keystore_path: string, account_label: string, wati
                 break;
             }
 
-            await expandAddress(keystore_path, account_label, Number(count), wative_core);
+            await expandAddress(keystore_path, keystore_slug, Number(count), wative_core);
             break;
         }
         case '> Import Private Key': {
-            await importPrivateKeyAccount(keystore_path, password, account_label, wative_core);
+            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, account_label, Number(last_account_no), wative_core);
+            await sliceAddress(keystore_path, keystore_slug, Number(last_account_no), wative_core);
             break;
         }
         case '> Remove Address': {
-            await removeAddress(keystore_path, account_label, wative_core);
+            await removeAddress(keystore_path, keystore_slug, wative_core);
             break;
         }
         case '> Disable Address': {
-            await setDisableAddress(keystore_path, account_label, wative_core);
+            await setDisableAddress(keystore_path, keystore_slug, wative_core);
             break;
         }
         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}]`);
+            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(
@@ -540,15 +544,15 @@ const accountManager = async (keystore_path: string, account_label: string, wati
                 break;
             }
 
-            await wative_core.account.resetPassword(account_label, password1);
+            await wative_core.account.resetPassword(keystore_slug, password1);
             return;
         }
         case `> Switch Networks [${account_info.default_network}]`: {
-            await switchNetworkByAccountLabel(keystore_path, account_label, true);
+            await switchNetworkByAccountName(keystore_path, keystore_slug, true);
             break;
         }
         case '> Remove': {
-            await removeAccountLabel(keystore_path, account_label);
+            await removeAccountName(keystore_path, keystore_slug);
             return;
         }
         case '> Back': {
@@ -556,11 +560,11 @@ const accountManager = async (keystore_path: string, account_label: string, wati
         }
     }
 
-    await accountManager(keystore_path, account_label, wative_core, password);
+    await accountManager(keystore_path, keystore_slug, wative_core, password);
 }
 
-const showAccounts = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, account_label);
+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',
@@ -598,7 +602,7 @@ const showAccounts = async (keystore_path: string, account_label: string, wative
         }
     }
 
-    let selected_default_account = DEFAULT_ACCOUNT.account_label === account_label ? option_accounts[DEFAULT_ACCOUNT.account_index] : option_accounts[0];
+    let selected_default_account = DEFAULT_ACCOUNT.keystore_slug === keystore_slug ? option_accounts[DEFAULT_ACCOUNT.account_index] : option_accounts[0];
 
     let asset_info_list = await getAssetList(keystore_path, network_info.chainId.toString());
     let selected_account = await listWithLazyBalanceLoading(
@@ -617,18 +621,18 @@ const showAccounts = async (keystore_path: string, account_label: string, wative
         return;
     }
 
-    DEFAULT_ACCOUNT.account_label = account_label;
+    DEFAULT_ACCOUNT.keystore_slug = keystore_slug;
     DEFAULT_ACCOUNT.account_index = option_accounts.indexOf(selected_account);
 
-    await showAccountDetail(keystore_path, account_label, option_accounts.indexOf(selected_account) - 2, wative_core);
-    await showAccounts(keystore_path, account_label, wative_core);
+    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, account_label: string, selected_account_id: number, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, account_label);
+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, account_label, selected_account_id);
+    let account_address = getAccountAddress(keystore_path, keystore_slug, selected_account_id);
 
     const network = await getNetworkInfoByName(keystore_path, default_network);
     const balance_result = await getAccountBalance(
@@ -674,11 +678,11 @@ const showAccountDetail = async (keystore_path: string, account_label: string, s
             }
             let tag = await inputSomething(current_tag, tagValidator);
             account_info.data[selected_account_id].tag = tag.replace(/\s+/g, " ").trim();
-            saveAccountInfo(keystore_path, account_label, account_info);
+            saveAccountInfo(keystore_path, keystore_slug, account_info);
             break;
         }
         case '> Show address': {
-            await showAllAccounts(keystore_path, account_label, selected_account_id);
+            await showAllAccounts(keystore_path, keystore_slug, selected_account_id);
             break;
         }
         case '> Assets': {
@@ -687,11 +691,11 @@ const showAccountDetail = async (keystore_path: string, account_label: string, s
             break;
         }
         case '> Tools': {
-            await selectToolsOptions(keystore_path, account_label, account_address, wative_core);
+            await selectToolsOptions(keystore_path, keystore_slug, account_address, wative_core);
             break;
         }
         case '> Dump private key': {
-            let account_address = getAccountAddress(keystore_path, account_label, selected_account_id);
+            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);
@@ -703,13 +707,13 @@ const showAccountDetail = async (keystore_path: string, account_label: string, s
     }
 }
 
-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 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(account_label, i);
+        let sub_account = await wative_core.account.generateSubAccount(keystore_slug, i);
         if (!sub_account.status) {
             console.log(
                 chalk.red(sub_account.output)
@@ -723,49 +727,50 @@ const expandAddress = async (keystore_path: string, account_label: string, expan
     }
     bar1.stop();
 
-    saveAccountInfo(keystore_path, account_label, account_info);
+    saveAccountInfo(keystore_path, keystore_slug, account_info);
     wative_core.account.reloadAccount();
 }
 
-const sliceAddress = async (keystore_path: string, account_label: string, last_account_no: number, wative_core: typeof WativeCore) => {
-    const account_info = await getAccountInfo(keystore_path, account_label);
+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, account_label, account_info);
+    saveAccountInfo(keystore_path, keystore_slug, account_info);
     wative_core.account.reloadAccount();
 }
 
-const removeAddress = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+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, account_label);
+    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, account_label, account_info);
+    saveAccountInfo(keystore_path, keystore_slug, 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) {
+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_label})`, true);
+    const isConfirm = await confirmSomething(`Are you sure you want to remove this account(${account_name})`, true);
     if (!isConfirm) {
         return;
     }
 
-    let account_label_path = path.join(keystore_path, `accounts/${account_label}.json`);
-    fs.rmSync(account_label_path);
+    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)) {
@@ -773,8 +778,8 @@ const removeAccountLabel = async (keystore_path: string, account_label: string)
     }
 
     const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
-    let account_label_index = networks.accounts.indexOf(account_label);
-    networks.accounts.splice(account_label_index, 1);
+    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));
 }
 
@@ -785,10 +790,10 @@ export const accountSetting = async (keystore_path: string, wative_core: typeof
     }
 
     const networks = getNetworkInfo(keystore_path);
-    const account_label_list = networks.accounts;
+    const account_name_list = networks.accounts;
 
     let account_setting_options: any[];
-    if (account_label_list.length === 0) {
+    if (account_name_list.length === 0) {
         account_setting_options = [
             '> Create a new account',
             new inquirer.Separator('----------------------------------'),

package/src/index.ts

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