wative 1.0.1

package/src/account.ts

@@ -0,0 +1,558 @@
+const chalk = require('chalk');
+import * as fs from "fs";
+import * as path from "path";
+import {
+    getAccountLabel,
+    selectSomething,
+    inputPassword,
+    inputSomething,
+    tagValidator,
+    passphraseValidator,
+    expandAmountValidator,
+    lastAccountNoValidator,
+} from "./utils";
+import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getPKAccountAddress, selectDefaultNetwork, switchNetworkByAccountLabel, switchPPNetwork } from "./network";
+import { showAssets } from './assets';
+import { selectToolsOptions } from './tools';
+
+const cliProgress = require('cli-progress');
+const { WativeCore } = require("wative-core");
+
+const preAccountImport = async (keystore_path: string) => {
+    const networks = getNetworkInfo(keystore_path)
+
+    let account_label_list: string[] = [];
+    if (networks.accounts) {
+        account_label_list = networks.accounts;
+    }
+
+    let account_label = await getAccountLabel('Account Label', account_label_list);
+    if (account_label === null) {
+        return null;
+    }
+
+    let password = await inputPassword(`Please set a password for Account [${account_label}]`);
+    let selected_default_network = await selectDefaultNetwork(keystore_path);
+
+    let pre_account_info = {
+        account_label,
+        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 inputSomething('Please enter a mnemonic [split by space]', passphraseValidator);
+    passphrase = passphrase.replace(/\s+/g, " ");
+
+    const passphrase_account = wative_core.account.generatePPAccount(pre_account_info.account_label, passphrase, pre_account_info.password);
+    if (!passphrase_account.status) {
+        console.log(
+            chalk.red(passphrase_account.output)
+        );
+        return;
+    }
+    let account_info_path = path.join(keystore_path, `accounts/${pre_account_info.account_label}.json`);
+
+    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);
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
+}
+
+const importPrivateKey = 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);
+
+    let privatekey_account = await wative_core.account.generatePKAccount(pre_account_info.account_label, private_key, pre_account_info.password, network_info.chainId);
+    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`);
+
+    privatekey_account.output.default_network = pre_account_info.selected_default_network;
+    fs.writeFileSync(account_info_path, JSON.stringify(privatekey_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);
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
+}
+
+const createAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
+    const create_account_options = [
+        '> Import Passphrase',
+        '> Import Private Key',
+        '> 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 importPrivateKey(keystore_path, wative_core);
+            break;
+        }
+        case '> Back': {
+            return;
+        }
+    }
+}
+
+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, account_label: string) => {
+    const account_info_path = path.join(keystore_path, `accounts/${account_label}.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`);
+    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);
+    if (is_login) {
+        return 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;
+    }
+}
+
+const selectAccount = async (keystore_path: string, wative_core: typeof WativeCore) => {
+    const networks = getNetworkInfo(keystore_path);
+    const account_label_list = networks.accounts;
+
+    let select_account_options = [
+        "> Back"
+    ];
+
+    const account_label_len = account_label_list.length;
+    if (account_label_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 account_info = getAccountInfo(keystore_path, account_label);
+        if (account_info.account_type === "PP") {
+            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]`);
+        }
+    }
+
+    const selected_account = await selectSomething(select_account_options, "Select an account");
+    if (selected_account === "> Back") {
+        return;
+    }
+
+    const selected_account_label = account_label_list[select_account_options.indexOf(selected_account) - 1];
+    let login_result = await loginIn(selected_account_label, wative_core);
+    if (login_result) {
+        await accountManager(keystore_path, selected_account_label, wative_core);
+    }
+
+    await selectAccount(keystore_path, wative_core);
+}
+
+
+const accountManager = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+    let account_info = await getAccountInfo(keystore_path, account_label);
+
+    let account_manager_options: string[];
+
+    if (account_info.account_type === "PP") {
+        account_manager_options = [
+            '1.Address List',
+            '2.Expand Address',
+            '3.Slice Address',
+            '4.Reset Account Password',
+            `5.Switch Networks [${account_info.default_network}]`,
+            '> Back'
+        ];
+    } else {
+        account_manager_options = [
+            '1.Address List',
+            '2.Reset Account Password',
+            `3.Switch Networks [${account_info.default_network}]`,
+            '> 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);
+            }
+            break;
+        }
+        case '2.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, account_label, Number(count), wative_core);
+            break;
+        }
+        case '3.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.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 `3.Switch Networks [${account_info.default_network}]`: {
+            await switchNetworkByAccountLabel(keystore_path, account_label, true);
+            break;
+        }
+        case `5.Switch Networks [${account_info.default_network}]`: {
+            await switchNetworkByAccountLabel(keystore_path, account_label, true);
+            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);
+}
+
+const showPPAccounts = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+    const account_info = await getAccountInfo(keystore_path, account_label);
+    let option_accounts = [
+        '> Back'
+    ];
+
+    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 tag = "";
+        if ("tag" in account_info.data[i]) {
+            tag = `(${account_info.data[i].tag})`;
+        }
+
+        if (network_type === "evm") {
+            option_accounts.push(`#${i} ${account_info.data[i].ciphertexts.evm.address} ${tag} [${default_network}]`);
+        } else if (network_type === "solana") {
+            option_accounts.push(`#${i} ${account_info.data[i].ciphertexts.solana.address} ${tag} [${default_network}]`);
+        }
+    }
+
+    let selected_account = await selectSomething(option_accounts, "Select an account");
+    if (selected_account === "> Back") {
+        return;
+    }
+
+    let selected_account_id = option_accounts.indexOf(selected_account) - 1;
+
+    await showPPAccountDetail(keystore_path, account_label, selected_account_id, wative_core);
+    await showPPAccounts(keystore_path, account_label, wative_core);
+}
+
+const showPPAccountDetail = 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;
+    }
+
+    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}`)
+        );
+    } 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 = [
+        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.data[selected_account_id] && account_info.data[selected_account_id].tag !== "") {
+                cureent_tag = `Current tag (${account_info.data[selected_account_id].tag})`;
+            }
+            let tag = await inputSomething(cureent_tag, tagValidator);
+            tag = tag.replace(/\s+/g, " ").trim();
+            account_info.data[selected_account_id].tag = tag.toLocaleLowerCase();
+            saveAccountInfo(keystore_path, account_label, account_info);
+            break;
+        }
+        case '> Switch network': {
+            await switchPPNetwork(keystore_path, account_label, selected_account_id);
+            break;
+        }
+        case '> Assets': {
+            await showAssets(keystore_path, account_address, default_network);
+            break;
+        }
+        case '> Tools': {
+            await selectToolsOptions(keystore_path, account_label, account_address, wative_core);
+            break;
+        }
+        case '> Dump private key': {
+            let account_address = getAccountAddress(keystore_path, account_label, 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 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;
+    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);
+        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, account_label, account_info);
+}
+
+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);
+    account_info.data = account_info.data.slice(0, last_account_no + 1);
+    saveAccountInfo(keystore_path, account_label, account_info);
+    wative_core.account.reloadAccount();
+}
+
+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'
+    ];
+
+    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);
+}