wative 1.2.8 → 1.2.10

package/src/utils.ts

@@ -1,916 +0,0 @@
-/* tslint:disable no-var-requires */
-const chalk = require('chalk')
-import * as figlet from 'figlet'
-import inquirer from 'inquirer'
-import * as fs from 'fs'
-import * as path from "path";
-
-import { getChainIdByEvm, batchHasTokenBalance } from "./web3";
-import { MNEMONIC_WORDS } from './config';
-import { getChainType } from './chain';
-import { getBatchAccountBalance } from './assets';
-import { getNetworkInfo } from './account';
-
-const USER_HOME: any = process.env.HOME || process.env.USERPROFILE
-const BASE_PATH = `${USER_HOME}/.wative`
-
-export const inputSomething = async (text: string, validate_func?: Function) => {
-    const questions = [
-        {
-            name: 'inputText',
-            type: 'input',
-            message: `${text}:`,
-            validate: validate_func
-        },
-    ]
-    const { inputText } = await inquirer.prompt(questions)
-    return inputText.trim().toString()
-}
-
-export const getAccountRange = async (account_info: any) => {
-    for (let i = 0; i < 5; i++) {
-        let start_address_index = await getAccountIndex(account_info, "Input start address or index");
-        if (!start_address_index) {
-            console.log(chalk.red("Invalid start account index"));
-            return null;
-        }
-        let end_address_index = await getAccountIndex(account_info, "Input end address or index");
-        if (!end_address_index) {
-            console.log(chalk.red("Invalid end account index"));
-            return null;
-        }
-        if (start_address_index > end_address_index) {
-            console.log(chalk.red("Invalid address range"));
-            continue;
-        }
-        return {
-            from: start_address_index,
-            to: end_address_index
-        };
-    }
-    return null;
-}
-
-export const getAccountIndexByKeystoreSlug = async (keystore_path: string, keystore_slug: string, account_address: string) => {
-    let account_info_path = path.join(keystore_path, `accounts/${keystore_slug}.json`);
-    if (!fs.existsSync(account_info_path)) {
-        return null;
-    }
-
-    let account_info = JSON.parse(fs.readFileSync(account_info_path, 'utf8'));
-    let account_data = account_info.data;
-    let account_type = account_info.account_type;
-    let account_length = account_data.length;
-    if (account_length === 0) {
-        return null;
-    }
-    for (let i = 0; i < account_length; i++) {
-        if (account_type === "PK" && account_data[i].ciphertexts.address.toLocaleLowerCase() === account_address.toLocaleLowerCase()) {
-            return i.toString();
-        }
-        if (account_type === "PP" && (
-            account_data[i].ciphertexts.evm.address.toLocaleLowerCase() === account_address.toLocaleLowerCase() ||
-            account_data[i].ciphertexts.solana.address.toLocaleLowerCase() === account_address.toLocaleLowerCase()
-        )) {
-            return i.toString();
-        }
-    }
-
-    return null;
-}
-
-export const getAccountIndex = async (account_info: any, message: string) => {
-    let account_data = account_info.data;
-    let account_length = account_data.length;
-    if (account_length === 0) {
-        return null;
-    }
-
-    let evm_account_list: any = [];
-    let solana_account_list: any = [];
-
-    for (let i = 0; i < account_length; i++) {
-        evm_account_list.push(account_data[i].ciphertexts.evm.address.toLocaleLowerCase());
-        solana_account_list.push(account_data[i].ciphertexts.solana.address.toLocaleLowerCase());
-    }
-    let max_account_index = account_length - 1;
-    for (let i = 0; i < 5; i++) {
-        let account_index_or_address = await inputSomething(message, accountIndexOrAddressValidator);
-        let account_chain_type = getAccountChainType(account_index_or_address);
-        if (account_chain_type === "unknown") {
-            if (Number(account_index_or_address) > max_account_index) {
-                console.log(chalk.red("Invalid account index"));
-                continue;
-            }
-            return Number(account_index_or_address);
-        } else if (account_chain_type === "evm" && evm_account_list.indexOf(account_index_or_address.toLocaleLowerCase()) !== -1) {
-            return evm_account_list.indexOf(account_index_or_address.toLocaleLowerCase());
-        } else if (account_chain_type === "solana" && solana_account_list.indexOf(account_index_or_address.toLocaleLowerCase()) !== -1) {
-            return solana_account_list.indexOf(account_index_or_address.toLocaleLowerCase());
-        }
-    }
-
-    return null;
-}
-
-export const tagValidator = (tag: string) => {
-    if (tag === "") {
-        return true;
-    }
-
-    tag = tag.replace(/\s+/g, " ").trim();
-
-    if (tag.length > 40) {
-        return "Tag length should be less than 10";
-    }
-
-    if (/^[0-9a-zA-Z\s]*$/g.test(tag) === false) {
-        return "Tag should be alphanumeric";
-    }
-
-    return true;
-}
-
-export const addrValidator = (tag: string) => {
-    if (tag.length < 6) {
-        return "Address length should be greater than 6";
-    }
-    return true;
-}
-
-export const numberValidator = (value: string) => {
-    if (isNaN(Number(value))) {
-        return "Value should be a number";
-    }
-    return true;
-}
-
-export const gasValidator = (value: string) => {
-    if (isNaN(Number(value)) || Number(value) > 1000) {
-        return "Value should be a number";
-    }
-    return true;
-}
-
-export const passphraseValidator = (passphrase: string) => {
-    passphrase = passphrase.replace(/\s+/g, " ");
-    const mnemonic_word_list = passphrase.split(/\s+/g);
-    if (mnemonic_word_list.length !== 12 && mnemonic_word_list.length !== 24) {
-        return "Passphrase should be equal to 12 or 24 words";
-    }
-    for (let i = 0; i < mnemonic_word_list.length; i++) {
-        if (MNEMONIC_WORDS.includes(mnemonic_word_list[i]) === false) {
-            return "Passphrase word should be valid";
-        }
-    }
-    return true;
-}
-
-export const expandAmountValidator = (amount: string) => {
-    let amount_number = Number(amount);
-
-    if (isNaN(amount_number)) {
-        return "Amount should be a number";
-    }
-
-    if (amount_number > 2000) {
-        return "Amount should be less than 2000";
-    }
-
-    return true;
-}
-
-export const lastAccountNoValidator = (last_account_no: string) => {
-    let last_account_no_number = Number(last_account_no);
-
-    if (isNaN(last_account_no_number)) {
-        return "Last account no should be a number";
-    }
-    return true;
-}
-
-export const accountIndexOrAddressValidator = (account_index_or_address: string) => {
-    if (isNaN(Number(account_index_or_address)) === false) {
-        return true;
-    }
-    return chainAddressValidator(account_index_or_address);
-}
-
-export const chainAddressValidator = (chain_address: string) => {
-    let account_chain_type = getAccountChainType(chain_address);
-
-    if (account_chain_type == "unknown") {
-        return "Address should be valid";
-    }
-
-    return true;
-}
-
-export const selectSomething = async (options: any[], message?: string, _default?: any) => {
-    const questions = [
-        {
-            type: 'list',
-            name: 'inputText',
-            message: message || 'Choose an option',
-            default: _default,
-            choices: options,
-            pageSize: 30,
-            filter: (val: string) => {
-                return val;
-            },
-        },
-    ]
-    const { inputText } = await inquirer.prompt(questions)
-    return inputText.toString()
-}
-
-export const selectCheckboxSomething = async (options: any[], message?: string, _default?: any) => {
-    const questions = [
-        {
-            type: 'checkbox',
-            name: 'inputText',
-            message: message || 'Choose an option',
-            default: _default,
-            choices: options,
-            pageSize: 30,
-            filter: (val: string) => {
-                return val;
-            },
-        },
-    ]
-
-    const { inputText } = await inquirer.prompt(questions)
-    return inputText
-}
-
-export const showIntroduction = () => {
-    console.log(
-        chalk.green(
-            figlet.textSync('Wative', {
-                font: 'ANSI Shadow',
-                horizontalLayout: 'default',
-                verticalLayout: 'default',
-            })
-        )
-    )
-}
-
-export const getKeystorePath = async () => {
-    let keystore_path: string = await inputSomething(`Keystore storage located in (default: ${BASE_PATH})`);
-    if (!keystore_path) {
-        keystore_path = BASE_PATH
-    }
-
-    keystore_path = keystore_path.trim();
-    keystore_path = keystore_path.replace("~", USER_HOME);
-
-    if (!fs.existsSync(keystore_path)) {
-        fs.mkdirSync(keystore_path, { recursive: true });
-    }
-    return keystore_path;
-}
-
-export const getChainId = async (text: string, update: boolean = false) => {
-    for (let i = 0; i < 5; i++) {
-        const chain_id = await inputSomething(text);
-        if (chain_id === "" && update) {
-            return null
-        }
-
-        let reg = /^[0-9]*$/g;
-        if (reg.test(chain_id)) {
-            return chain_id;
-        }
-    }
-
-    return null;
-}
-
-export const getRpcUrl = async (chain_id: string, text: string, update: boolean = false) => {
-    for (let i = 0; i < 5; i++) {
-        let rpc_url = await inputSomething(text);
-        try {
-            if (rpc_url === "" && update) {
-                return null
-            }
-
-            if (getChainType(chain_id.toString()) === "solana") {
-                return rpc_url;
-            }
-            const new_chain_id = await getChainIdByEvm(rpc_url);
-            if (!new_chain_id.status) {
-                console.log(chalk.red(new_chain_id.output));
-                continue;
-            }
-            if (new_chain_id.output.toString() === chain_id.toString()) {
-                return rpc_url;
-            } else {
-                console.log(chalk.red("Rpc url not match chain id"));
-            }
-        } catch (err: any) {
-            console.log(chalk.red(err.message));
-        }
-    }
-
-    return null;
-}
-
-export const getMulticallAddress = async (text: string) => {
-    for (let i = 0; i < 5; i++) {
-        let multicall_address = await inputSomething(text);
-        if (multicall_address === "") {
-            return null
-        }
-
-        if (multicall_address !== "" && multicall_address.length !== 42) {
-            console.log(chalk.red("Multicall address length must be 42"));
-            continue;
-        }
-
-        return multicall_address;
-    }
-
-    return null;
-}
-
-export const getSymbol = async (text: string) => {
-    let reg = /^[A-Za-z][0-9a-zA-Z]*$/g;
-    for (let i = 0; i < 5; i++) {
-        let symbol = await inputSomething(text);
-        if (symbol === "") {
-            return null
-        }
-        if (reg.test(symbol)) {
-            return symbol
-        }
-    }
-    return null;
-}
-
-export const getColor = async (text: string) => {
-    let reg = /^#[0-9A-Fa-f]{6}$/g;
-    for (let i = 0; i < 5; i++) {
-        let color = await inputSomething(text);
-        if (color === "") {
-            return null
-        }
-
-        if (reg.test(color)) {
-            return color
-        }
-    }
-    return null;
-}
-
-export const getAccountNameByKeystoreSlug = (keystore_path: string, keystore_slug: string) => {
-    const networks = getNetworkInfo(keystore_path);
-    const account_name_list = networks.accounts;
-    const keystore_slug_list = batchGetKeystoreSlugByAccountName(account_name_list);
-    const index = keystore_slug_list.indexOf(keystore_slug);
-    if (index !== -1) {
-        return account_name_list[index];
-    }
-    return keystore_slug;
-}
-
-export const getKeystoreSlugByAccountName = (account_name: string) => {
-    account_name = account_name.trim();
-    account_name = account_name.toLocaleLowerCase();
-    account_name = account_name.replace(/\s+/g, "-").trim();
-    account_name = account_name.replace(/\-+/g, "-").trim();
-    return account_name;
-}
-
-export const batchGetKeystoreSlugByAccountName = (account_name_list: string[]) => {
-    let keystore_slug_list: string[] = [];
-    for (let i = 0; i < account_name_list.length; i++) {
-        keystore_slug_list.push(
-            getKeystoreSlugByAccountName(account_name_list[i])
-        );
-    }
-    return keystore_slug_list;
-}
-
-
-export const getAccountName = async (text: string, account_name_list: string[]) => {
-    let keystore_slug_list = batchGetKeystoreSlugByAccountName(account_name_list);
-    let reg = /^(?![-_])[a-zA-Z0-9_-]{4,40}(?<![-_])$/g;
-    for (let i = 0; i < 5; i++) {
-        let account_name = await inputSomething(text);
-        account_name = account_name.trim();
-        let keystore_slug = getKeystoreSlugByAccountName(account_name);
-
-        if (reg.test(keystore_slug)) {
-            if (keystore_slug_list.includes(keystore_slug)) {
-                console.log(chalk.red("Account name already exists"));
-                continue;
-            } else {
-                return account_name;
-            }
-        }
-    }
-    return null;
-}
-
-const passwordValidator = function (value: string) {
-    let validatorInfo = "Password must contain at least: \n";
-    let myReg;
-    let access = true;
-    let tabspace = "  ";
-    let green_string = chalk.green('\u2714');
-    let red_string = chalk.red('\u2716');
-
-    if (value.length >= 8) {
-        validatorInfo += tabspace + green_string + " 8 characters\n";
-    } else {
-        validatorInfo += tabspace + red_string + " 8 characters\n";
-        access = false;
-    }
-
-    myReg = /[0-9]/;
-    if (myReg.test(value)) {
-        validatorInfo += tabspace + green_string + " One numerical character\n";
-    } else {
-        validatorInfo += tabspace + red_string + " One numerical character\n";
-        access = false;
-    }
-
-    myReg = /[A-Z]/;
-    if (myReg.test(value)) {
-        validatorInfo += tabspace + green_string + " One uppercase letter\n";
-    } else {
-        validatorInfo += tabspace + red_string + " One uppercase letter\n";
-        access = false;
-    }
-
-    myReg = /[!@#$%]/;
-    if (myReg.test(value)) {
-        validatorInfo += tabspace + green_string + " One sepcial character (i.e. !@#$%)\n";
-    } else {
-        validatorInfo += tabspace + red_string + " One sepcial character (i.e. !@#$%)\n";
-        access = false;
-    }
-
-    if (access) {
-        return true;
-    } else {
-        return validatorInfo;
-    }
-};
-
-export const inputMaskedPassword = async (text: string, validate_func?: Function) => {
-    const questions = [
-        {
-            name: 'inputText',
-            type: 'password',
-            mask: '#',
-            message: `${text}:`,
-            validate: validate_func
-        },
-    ]
-    const { inputText } = await inquirer.prompt(questions)
-    return inputText.trim().toString()
-}
-
-export const inputPasswordWithoutValidator = async (text: string) => {
-    const questions = [
-        {
-            name: 'password',
-            type: 'password',
-            mask: '#',
-            message: `${text}:`
-        }
-    ]
-
-    let { password } = await inquirer.prompt(questions);
-    return password;
-}
-
-export const importMaskedPassphrase = async (text: string, validate_func?: Function) => {
-    const questions = [
-        {
-            name: 'inputText',
-            type: 'input',
-            message: `${text}:`,
-            validate: validate_func,
-            transformer: (input: any) => {
-                const parts = input.split(' ');
-                const transformed = parts.map((part: any, index: any) => {
-                    if (index < parts.length - 1) {
-                        return '#'.repeat(part.length);
-                    }
-                    return part;
-                });
-                return transformed.join(' ');
-            }
-        },
-    ]
-    const { inputText } = await inquirer.prompt(questions)
-    return inputText.trim().toString()
-}
-
-
-export const inputPassword = async (text: string) => {
-    let count = 0;
-
-    const questions = [
-        {
-            name: 'password',
-            type: 'password',
-            mask: '#',
-            message: `${text}:`,
-            validate: (fieldValue: string) => {
-                if (count >= 3) {
-                    return true
-                }
-
-                return passwordValidator(fieldValue);
-            }
-        }
-    ]
-
-    let { password } = await inquirer.prompt(questions);
-    if (count >= 3) {
-        password = null;
-    }
-
-    return password;
-}
-
-export const confirmSomething = async (text: string, _default = true) => {
-    const questions = [
-        {
-            name: 'confirm',
-            type: 'confirm',
-            message: `${text}`,
-            default: _default
-        }
-    ]
-    const { confirm } = await inquirer.prompt(questions);
-    return confirm;
-}
-
-export const editorSomething = async (text: string, validate_func?: Function) => {
-    const questions = [
-        {
-            name: 'editor',
-            type: 'editor',
-            message: `${text}`,
-            validate: validate_func
-        }
-    ]
-    const { editor } = await inquirer.prompt(questions);
-    return editor.trim().toString()
-};
-
-export const hexValidator = function (value: string) {
-    let reg = /^0x[0-9a-fA-F]*$/g;
-    if (reg.test(value.trim())) {
-        return true;
-    } else {
-        return false;
-    }
-};
-
-export interface Result {
-    status: boolean;
-    output: any;
-}
-
-export const excutePromiseFunction = async (fn: Function, params: any): Promise<Result> => {
-    let result: Result;
-    try {
-        let output = await fn(...params);
-        result = {
-            status: true,
-            output
-        };
-    } catch (err: any) {
-        result = {
-            status: false,
-            output: err.toString()
-        }
-    }
-    return result;
-}
-
-export const getAccountChainType = (account_address: string) => {
-    if (account_address.startsWith("0x") && account_address.length === 42) {
-        return "evm";
-    }
-
-    if (/^[A-HJ-NP-Za-km-z1-9]*$/.test(account_address) && account_address.length <= 44 && account_address.length >= 32) {
-        return "solana";
-    }
-    return "unknown";
-}
-
-export const checkFileExistence = (file_path: string): boolean => {
-    file_path = file_path.trim()
-    return fs.existsSync(file_path);
-}
-
-export const chunkArray = (array: any, size: number) => {
-    let result: any = [];
-    for (let i = 0; i < array.length; i += size) {
-        result.push(array.slice(i, i + size));
-    }
-    return result;
-}
-
-export const sleep = (ms: number) => {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export const formatAddr = (addr: string, force_full_addr: boolean = true) => {
-    if (force_full_addr) {
-        return addr;
-    }
-
-    if (addr.startsWith("0x")) {
-        return addr.slice(0, 8) + "..." + addr.slice(-6);
-    }
-
-    return addr.slice(0, 6) + "..." + addr.slice(-6);
-}
-
-// 提取账户地址的辅助函数
-const extractAccountFromChoice = (choice: any, is_evm: boolean): string | null => {
-    if (!choice.name) {
-        return null;
-    }
-
-    let account: any = null;
-
-    if (is_evm) {
-        account = /0x[0-9a-fA-f]{40}/.exec(choice.name);
-        account = account ? account[0] : null;
-    } else {
-        let re_result = /\s+([0-9a-zA-Z]*)/.exec(choice.name);
-        account = re_result ? re_result[1] : null;
-
-        if (account === "Back") {
-            account = null;
-        }
-    }
-
-    return account;
-};
-
-// 计算分页索引的辅助函数
-const calculatePageIndices = (selected: number, pageSize: number, accountsLength: number): { fromIndex: number, toIndex: number } => {
-    let fromIndex: number, toIndex: number;
-    
-    if (selected < pageSize / 2) {
-        if (accountsLength / 2 <= pageSize) {
-            fromIndex = 0;
-            toIndex = accountsLength / 2;
-        } else {
-            fromIndex = 0;
-            toIndex = pageSize;
-        }
-    } else {
-        if (accountsLength / 2 <= pageSize) {
-            fromIndex = 0;
-            toIndex = accountsLength / 2;
-        } else {
-            fromIndex = selected - pageSize / 2 + 1;
-            toIndex = selected + pageSize / 2 + 1;
-        }
-    }
-    
-    return { fromIndex, toIndex };
-};
-
-// 提取账户列表的辅助函数
-const extractAccountsList = (choices: any[], is_evm: boolean): (string | null)[] => {
-    const accounts: (string | null)[] = [];
-    
-    for (let i = 0; i < choices.length; i++) {
-        const account = extractAccountFromChoice(choices[i], is_evm);
-        accounts.push(account);
-    }
-    
-    return accounts.concat(accounts);
-};
-
-// 处理账户余额显示的辅助函数
-const processAccountBalanceDisplay = (
-    choices: any[],
-    accounts: (string | null)[],
-    batchBalanceOf: any,
-    pad_index_map: any,
-    gas_token_name: string,
-    show_gas_token: boolean,
-    show_extended_token: boolean,
-    fromIndex: number,
-    toIndex: number
-) => {
-    for (let i = fromIndex; i < toIndex; i++) {
-        let _index = i >= accounts.length / 2 ? i - accounts.length / 2 : i;
-        let _choice = choices[_index];
-        if (!_choice.name) {
-            continue;
-        }
-
-        let name = _choice.name;
-        let account_address = accounts[i];
-        let token_message = '';
-        if (!account_address) {
-            continue;
-        }
-
-        for (let token_name in batchBalanceOf[account_address]) {
-            if (!show_gas_token && token_name === gas_token_name) {
-                continue;
-            }
-            if (!show_extended_token && token_name !== gas_token_name) {
-                continue;
-            }
-
-            if (name.includes(token_name)) {
-                continue;
-            }
-
-            token_message += `${token_name}:${batchBalanceOf[account_address][token_name].padEnd(pad_index_map[token_name])} `;
-        }
-
-        let nameList = name.split('(');
-        if (nameList.length > 1) {
-            let tag = nameList[1];
-            choices[_index].name = nameList[0] + ` ${token_message}` + `(${tag}`;
-        } else {
-            choices[_index].name = nameList[0] + ` ${token_message}`;
-        }
-    }
-};
-
-export const listWithLazyBalanceLoading = async (
-    options: string[],
-    is_evm: boolean,
-    keystore_path: string,
-    asset_info_list: any,
-    network_info: any,
-    show_gas_token: boolean,
-    show_extended_token: boolean,
-    direct_display: boolean,
-    message?: string,
-    default_account?: any
-) => {
-    const questions = [
-        {
-            type: 'list',
-            name: 'inputText',
-            message: message || 'Choose an option',
-            choices: options,
-            pageSize: 30,
-            default: default_account,
-            loop: true,
-            filter: (val: string) => {
-                return val;
-            },
-        },
-    ];
-
-    const promise: any = inquirer.prompt(questions);
-
-    let selected = 0;
-    let round = 0;
-    let pre_selected: any;
-    
-    while (!promise.ui.activePrompt.answers[promise.ui.activePrompt.opt.name]) {
-        if (!direct_display) {
-            await sleep(1000);
-        }
-
-        if (pre_selected === promise.ui.activePrompt.selected) {
-            continue;
-        }
-
-        if (selected === promise.ui.activePrompt.selected) {
-            round = round + 1;
-        } else {
-            round = 0;
-            selected = promise.ui.activePrompt.selected;
-        }
-
-        if (direct_display) {
-            round = 6;
-            direct_display = false;
-
-            const pageSize = promise.ui.activePrompt.opt.pageSize;
-            const accounts = extractAccountsList(promise.ui.activePrompt.opt.choices.choices, is_evm);
-            const { fromIndex, toIndex } = calculatePageIndices(selected, pageSize, accounts.length);
-            const active_account: any = accounts.slice(fromIndex, toIndex);
-
-            let has_balance = batchHasTokenBalance(network_info.chainId.toString(), active_account);
-            if (!has_balance) {
-                round = 0;
-                continue;
-            }
-        }
-
-        if (round < 5) {
-            continue;
-        }
-        
-        round = 0;
-        const pageSize = promise.ui.activePrompt.opt.pageSize;
-        const accounts = extractAccountsList(promise.ui.activePrompt.opt.choices.choices, is_evm);
-        const { fromIndex, toIndex } = calculatePageIndices(selected, pageSize, accounts.length);
-        const active_account: any = accounts.slice(fromIndex, toIndex);
-
-        let batchBalanceOf = await getBatchAccountBalance(
-            keystore_path,
-            active_account,
-            asset_info_list,
-            network_info.rpcUrl,
-            network_info.name,
-            show_gas_token,
-            show_extended_token
-        );
-
-        let pad_index_map: any = {};
-
-        for (let account_address in batchBalanceOf) {
-            for (let token_name in batchBalanceOf[account_address]) {
-                let balance = batchBalanceOf[account_address][token_name];
-                let new_pad_index = balance.length + 1;
-                if (!pad_index_map[token_name]) {
-                    pad_index_map[token_name] = new_pad_index;
-                } else if (pad_index_map[token_name] < new_pad_index) {
-                    pad_index_map[token_name] = new_pad_index;
-                }
-            }
-        }
-
-        const gas_token_name = network_info.nativeCurrency.symbol;
-        processAccountBalanceDisplay(
-            promise.ui.activePrompt.opt.choices.choices,
-            accounts,
-            batchBalanceOf,
-            pad_index_map,
-            gas_token_name,
-            show_gas_token,
-            show_extended_token,
-            fromIndex,
-            toIndex
-        );
-        
-        promise.ui.activePrompt.screen.render('');
-        promise.ui.activePrompt.render();
-        pre_selected = selected;
-    }
-
-    return promise.ui.activePrompt.answers[promise.ui.activePrompt.opt.name];
-};
-
-export const updateStorage = (keystore_path: string) => {
-    const network_path = path.resolve(keystore_path, 'network.json');
-    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
-
-    if (!networks.status) {
-        networks.status = {
-            fullAddr: true,
-            gasToken: false,
-            extendedToken: false
-        }
-    }
-
-    if (!networks.showTokens) {
-        networks.showTokens = {};
-    }
-
-    let account_list_len = networks.accounts.length;
-    for (let i = 0; i < account_list_len; i++) {
-        let account_name = networks.accounts[account_list_len - 1 - i];
-        let keystore_slug = getKeystoreSlugByAccountName(account_name);
-        let keystore_slug_path = path.resolve(keystore_path, `accounts/${keystore_slug}.json`);
-
-        if (!fs.existsSync(keystore_slug_path)) {
-            networks.accounts.splice(account_list_len - 1 - i, 1);
-        }
-    }
-
-    fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
-    let account_name_list = networks.accounts;
-    let keystore_slug_list = batchGetKeystoreSlugByAccountName(account_name_list);
-
-    for (let i = 0; i < keystore_slug_list.length; i++) {
-        let keystore_slug_path = path.resolve(keystore_path, `accounts/${keystore_slug_list[i]}.json`);
-        let account_info = JSON.parse(fs.readFileSync(keystore_slug_path, 'utf8'));
-        if (account_info.account_type === "PP") {
-            continue;
-        }
-        if ("data" in account_info) {
-            continue;
-        }
-        account_info.data = [
-            {
-                ciphertexts: account_info.ciphertexts
-            }
-        ];
-        delete account_info.ciphertexts;
-        fs.writeFileSync(keystore_slug_path, JSON.stringify(account_info, null, 4));
-    }
-}