wative 1.0.1

package/src/home_page.ts

@@ -0,0 +1,36 @@
+import { inputSomething, selectSomething } from "./utils";
+import { showAvailableNetworks, showNetwork } from "./network";
+import { accountSetting } from "./account";
+import { showTools } from "./tools";
+const { WativeCore } = require("wative-core");
+
+export const showHomePage = async (keystore_path: string, wative_core: typeof WativeCore) => {
+    const home_page_list = [
+        '> System & Settings',
+        '> Accounts',
+        '> Tools',
+        '> Exit'
+    ];
+
+    const selected_home_page = await selectSomething(home_page_list);
+
+    switch (selected_home_page) {
+        case '> System & Settings': {
+            await showNetwork(keystore_path);
+            break;
+        }
+        case '> Accounts': {
+            await accountSetting(keystore_path, wative_core);
+            break;
+        }
+        case '> Tools': {
+            await showTools(keystore_path, wative_core);
+            break;
+        }
+        case '> Exit': {
+            return;
+        }
+    }
+
+    await showHomePage(keystore_path, wative_core);
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+declare module 'wative-core';

package/src/index.ts

@@ -0,0 +1,35 @@
+import * as fs from "fs";
+import * as path from "path";
+import { showIntroduction, getKeystorePath } from "./utils";
+import { createNetwork } from "./network";
+import { showHomePage } from "./home_page";
+
+const { WativeCore } = require("wative-core");
+const packageJson = require('../package.json');
+const Event = require('events');
+Event.EventEmitter.defaultMaxListeners = 0;
+
+const main = async () => {
+    console.log("version:", packageJson.version);
+
+    showIntroduction();
+
+    const keystore_path = await getKeystorePath();
+    await createNetwork(keystore_path);
+
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+    const wative_core = new WativeCore(keystore_path, networks.accounts);
+    await showHomePage(keystore_path, wative_core);
+}
+
+process.on('unhandledRejection', (reason, p) => {
+    console.log('Unhandled Rejection at:', p, 'reason:', reason);
+});
+
+main()
+    .then(() => process.exit(0))
+    .catch((error: any) => {
+        console.log(error.message);
+        process.exit(1)
+    })

package/src/network.ts

@@ -0,0 +1,559 @@
+import * as fs from "fs";
+const chalk = require('chalk')
+import * as path from "path";
+import inquirer from 'inquirer';
+import { BigNumber } from 'bignumber.js';
+import { DEFAULT_NETWORK } from "./config";
+import {
+    getChainId,
+    getRpcUrl,
+    inputSomething,
+    selectSomething,
+    getMulticallAddress,
+    getSymbol,
+    getColor,
+    Result,
+    getAccountChainType
+} from "./utils";
+import {
+    getAccountInfo,
+    saveAccountInfo
+} from "./account";
+import { getAccountBalanceInEvm, getAccountBalanceInSolana } from "./web3";
+import { getChainType, getNativeTokenDecimals } from "./chain";
+
+export const createNetwork = async (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+
+    if (fs.existsSync(network_path)) {
+        return;
+    }
+
+    const networks = {
+        networks: DEFAULT_NETWORK,
+        currentNetwork: "Ethereum Mainnet",
+        accounts: []
+    };
+
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 2));
+}
+
+export const selectOrEditNetwork = async (keystore_path: string, selected_network: any) => {
+    let options: string[] = [
+        "> Edit"
+    ];
+
+    if (selected_network.name !== "Ethereum Mainnet" && selected_network.name !== "Solana Mainnet") {
+        options.push("> Remove");
+    }
+
+    options.push("> Back");
+
+    const selected_network_info = await selectSomething(options);
+
+    switch (selected_network_info) {
+        case "> Edit": {
+            await updateNetwork(keystore_path, selected_network);
+            break;
+        }
+        case "> Remove": {
+            await removeNetwork(keystore_path, selected_network);
+            break;
+        }
+        case "> Back": {
+            break;
+        }
+    }
+}
+
+export const updateNetwork = async (keystore_path: string, default_network: any) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    let exist_chain_name_list: string[] = [];
+    for (let i = 0; i < networks.networks.length; i++) {
+        const network = networks.networks[i];
+        exist_chain_name_list.push(network.name);
+    }
+
+    let rpc_url: string = default_network.rpcUrl,
+        chain_id: string = default_network.chainId.toString(),
+        symbol: string = default_network.nativeCurrency.symbol,
+        chain_name: string = default_network.name,
+        multicall_address: string | null = default_network.multicallAddress,
+        color: string | null = default_network.color;
+    if (default_network.name === "Ethereum Mainnet" || default_network.name === "Solana Mainnet") {
+        rpc_url = await getRpcUrl(default_network.chainId.toString(), `Rpc Url (default: ${default_network.rpcUrl})`, true);
+    } else {
+        chain_name = await inputSomething(`Chain Name (default: ${default_network.name})`);
+        if (chain_name && chain_name !== default_network.name && exist_chain_name_list.includes(chain_name)) {
+            console.log(
+                chalk.red('Chain Name already exists')
+            );
+            return;
+        }
+
+        chain_id = await getChainId(`Chain Id (default: ${default_network.chainId})`, true);
+        rpc_url = await getRpcUrl(chain_id || default_network.chainId, `RPC Url (default: ${default_network.rpcUrl})`, true);
+        symbol = await getSymbol(`Symbol (default: ${default_network.nativeCurrency.symbol})`);
+        multicall_address = await getMulticallAddress(
+            default_network.multicallAddress ?
+                `Multicall Address (Optional) (default: ${default_network.multicallAddress})` :
+                'Multicall Address (Optional)'
+        );
+        color = await getColor(
+            default_network.color ?
+                `Color (Optional): (default: ${default_network.color})` :
+                'Color (Optional)'
+        );
+    }
+
+    let decimals = getNativeTokenDecimals(chain_id);
+    let network: any = {
+        name: chain_name || default_network.name,
+        chainId: Number(chain_id) || default_network.chainId,
+        rpcUrl: rpc_url || default_network.rpcUrl,
+        nativeCurrency: {
+            name: symbol || default_network.nativeCurrency.symbol,
+            symbol: symbol || default_network.nativeCurrency.symbol,
+            decimals: decimals || default_network.nativeCurrency.decimals
+        }
+    };
+    if (multicall_address || default_network.multicallAddress) {
+        network["multicallAddress"] = multicall_address || default_network.multicallAddress;
+    }
+    if (color || default_network.color) {
+        network["color"] = color || default_network.color;
+    }
+
+    for (let i = 0; i < networks.networks.length; i++) {
+        if (networks.networks[i].name === default_network.name) {
+            networks.networks[i] = network;
+            break;
+        }
+    }
+
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 2));
+}
+
+export const removeNetwork = async (keystore_path: string, default_network: any) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    let networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    for (let i = 0; i < networks.networks.length; i++) {
+        if (networks.networks[i].name === default_network.name) {
+            networks.networks.splice(i, 1);
+            break;
+        }
+    }
+
+    if (default_network.name === networks.currentNetwork) {
+        networks.currentNetwork = "Ethereum Mainnet";
+    }
+
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 2));
+}
+
+export const addNetwork = async (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    let exist_chain_name_list: string[] = [];
+    for (let i = 0; i < networks.networks.length; i++) {
+        const network = networks.networks[i];
+        exist_chain_name_list.push(network.name);
+    }
+    console.log(
+        chalk.green('Please input someting about network')
+    );
+    const chain_name = await inputSomething('Chain Name');
+    if (exist_chain_name_list.includes(chain_name)) {
+        console.log(
+            chalk.red('Chain Name already exists')
+        );
+        return;
+    }
+
+    const chain_id = await getChainId('Chain Id');
+    if (!chain_id) {
+        return;
+    }
+
+    const rpc_url = await getRpcUrl(chain_id, 'RPC Url');
+    if (!rpc_url) {
+        return;
+    }
+
+    const symbol = await getSymbol('Symbol');
+    if (!symbol) {
+        return;
+    }
+    const multicall_address = await getMulticallAddress('Multicall Address (Optional)');
+    const color = await getColor('Color (Optional)');
+
+    let decimals = getNativeTokenDecimals(chain_id);
+    let network: any = {
+        name: chain_name,
+        chainId: Number(chain_id),
+        rpcUrl: rpc_url,
+        nativeCurrency: {
+            name: symbol,
+            symbol: symbol,
+            decimals: decimals
+        }
+    };
+    if (multicall_address) {
+        network["multicallAddress"] = multicall_address;
+    }
+    if (color) {
+        network["color"] = color;
+    }
+
+    networks.networks.push(network);
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 2));
+}
+
+export const showAvailableNetworks = async (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    let evm_ids: number[] = [], solana_ids: number[] = [];
+
+    for (let i = 0; i < networks.networks.length; i++) {
+        const network = networks.networks[i];
+
+        if (getChainType(network.chainId.toString()) === "solana") {
+            solana_ids.push(i);
+        } else {
+            evm_ids.push(i);
+        }
+    }
+
+    let options: any = ["> Back", new inquirer.Separator(`----Networks(evm)----`)];
+
+    for (let i = 0; i < evm_ids.length; i++) {
+        const evm_id = evm_ids[i];
+        let network: any = networks.networks[evm_id];
+
+        let select_key = `${i + 1}.${network.name}`;
+        if (i === 0) {
+            select_key += ' 🔒';
+        }
+
+        options.push(select_key);
+    }
+
+    options.push(new inquirer.Separator(`----Networks(solana)----`));
+
+    for (let i = 0; i < solana_ids.length; i++) {
+        const solana_id = solana_ids[i];
+        let network: any = networks.networks[solana_id];
+
+        let select_key = `${i + 1}.${network.name}`;
+        if (i === 0) {
+            select_key += ' 🔒';
+        }
+        options.push(select_key);
+    }
+
+    const selected_option = await selectSomething(options);
+    if (selected_option === "> Back") {
+        return;
+    }
+
+    let option_id = options.indexOf(selected_option);
+    let select_network: any;
+    if (option_id < evm_ids.length + 2) {
+        select_network = networks.networks[evm_ids[option_id - 2]];
+    } else {
+        select_network = networks.networks[solana_ids[option_id - evm_ids.length - 3]];
+    }
+
+    await selectOrEditNetwork(keystore_path, select_network);
+    await showAvailableNetworks(keystore_path);
+}
+
+export const showNetwork = async (keystore_path: string) => {
+    let network_info_list = [
+        "> Available Networks",
+        "> Add Network",
+        "> Back"
+    ];
+
+    const selected_network_info = await selectSomething(network_info_list);
+
+    switch (selected_network_info) {
+        case "> Available Networks": {
+            await showAvailableNetworks(keystore_path);
+            break;
+        }
+        case "> Add Network": {
+            await addNetwork(keystore_path);
+            break;
+        }
+        case "> Back": {
+            return;
+        }
+    }
+
+    await showNetwork(keystore_path);
+}
+
+export const selectDefaultNetwork = async (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+    const network_name_list = networks.networks.map((network: { name: string; }) => {
+        return `> ${network.name}`
+    });
+    const selected_network_name = await selectSomething(network_name_list, 'Please select a default network');
+    return selected_network_name.slice(2,);
+}
+
+export const getNetworkTypeByName = (keystore_path: string, network_name: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    for (let i = 0; i < networks.networks.length; i++) {
+        const network = networks.networks[i];
+        if (network.name === network_name) {
+            return getChainType(network.chainId.toString());
+        }
+    }
+
+    return "unknown";
+}
+
+export const getNetworkInfoByName = (keystore_path: string, network_name: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    for (let i = 0; i < networks.networks.length; i++) {
+        const network = networks.networks[i];
+        if (network.name === network_name) {
+            return network;
+        }
+    }
+
+    return null;
+}
+
+export const getAccountAddress = (keystore_path: string, account_label: string, account_id: number) => {
+    const account_info = getAccountInfo(keystore_path, account_label);
+
+    let default_network = account_info.default_network;
+    if (account_info.data[account_id].default_network && account_info.data[account_id].default_network !== "") {
+        default_network = account_info.data[account_id].default_network;
+    }
+    let network_type = getNetworkTypeByName(keystore_path, default_network);
+
+    if (network_type === "solana") {
+        return account_info.data[account_id].ciphertexts.solana.address;
+    } else if (network_type === "evm") {
+        return account_info.data[account_id].ciphertexts.evm.address;
+    }
+
+    return null;
+}
+
+export const getPKAccountAddress = (keystore_path: string, account_label: string) => {
+    const account_info = getAccountInfo(keystore_path, account_label);
+    return account_info.ciphertexts.address;
+}
+
+export const switchPPNetwork = async (keystore_path: string, account_label: string, account_id: number) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+    const network_list = networks.networks;
+    const network_len = network_list.length;
+
+    let account_info = getAccountInfo(keystore_path, account_label);
+    let options_switch_network = [
+        "> Back"
+    ];
+
+    let default_network = account_info.data[account_id].default_network;
+    if (!default_network || default_network === "") {
+        options_switch_network.push("● Same as the account setting");
+    } else {
+        options_switch_network.push(`○ Same as the account setting`);
+    }
+
+    for (let i = 0; i < network_len; i++) {
+        const network = network_list[i];
+        let account_address: string;
+        if (getChainType(network.chainId.toString())) {
+            account_address = account_info.data[account_id].ciphertexts.solana.address;
+        } else {
+            account_address = account_info.data[account_id].ciphertexts.evm.address;
+        }
+
+        if (network.name === default_network) {
+            options_switch_network.push(`● ${account_address} [${network.name}]`);
+        } else {
+            options_switch_network.push(`○ ${account_address} [${network.name}]`);
+        }
+    }
+
+    const selected_network = await selectSomething(options_switch_network);
+
+    if (selected_network === "> Back") {
+        return;
+    }
+
+    let selected_network_id = options_switch_network.indexOf(selected_network);
+    if (selected_network_id === 1) {
+        delete account_info.data[account_id].default_network;
+    } else {
+        account_info.data[account_id].default_network = network_list[selected_network_id - 2].name;
+    }
+
+    saveAccountInfo(keystore_path, account_label, account_info);
+
+    let new_default_network = account_info.default_network;
+    if ("default_network" in account_info.data[account_id] && account_info.data[account_id].default_network !== "") {
+        new_default_network = account_info.data[account_id].default_network;
+    }
+
+    let new_network = getNetworkInfoByName(keystore_path, new_default_network);
+    console.log(
+        chalk.green(`  Address No: #${account_id}\n  Network: ${new_default_network}\n  ${new_network.nativeCurrency.symbol} Balance: 0`)
+    );
+}
+
+export const switchNetworkByAccountLabel = async (keystore_path: string, account_label: string, is_account_label: boolean) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+    const network_list = networks.networks;
+    const network_len = network_list.length;
+
+    let account_info = getAccountInfo(keystore_path, account_label);
+    let options_switch_network = [
+        "> Back"
+    ];
+
+    let default_network = account_info.default_network;
+
+    let account_address = "";
+    if (!is_account_label) {
+        account_address = account_info.ciphertexts.address;
+    }
+    let option_network_name_list: string[] = [];
+    const network_type = getNetworkTypeByName(keystore_path, default_network);
+
+    for (let i = 0; i < network_len; i++) {
+        const network = network_list[i];
+
+        const this_network_type = getNetworkTypeByName(keystore_path, network.name);
+        if (account_info.account_type === "PK" && network_type !== this_network_type) {
+            continue;
+        }
+        if (network.name === default_network) {
+            if (is_account_label) {
+                options_switch_network.push(`● ${network.name}`);
+            } else {
+                options_switch_network.push(`● ${account_address} [${network.name}]`);
+            }
+        } else {
+            if (is_account_label) {
+                options_switch_network.push(`○ ${network.name}`);
+            } else {
+                options_switch_network.push(`○ ${account_address} [${network.name}]`);
+            }
+        }
+        option_network_name_list.push(network.name);
+    }
+
+    const selected_network = await selectSomething(options_switch_network);
+    if (selected_network === "> Back") {
+        return;
+    }
+
+    let selected_network_id = options_switch_network.indexOf(selected_network);
+    account_info.default_network = option_network_name_list[selected_network_id - 1];
+    saveAccountInfo(keystore_path, account_label, account_info);
+
+    if (!is_account_label) {
+        let new_default_network = account_info.default_network;
+        let new_network = getNetworkInfoByName(keystore_path, new_default_network);
+        console.log(
+            chalk.green(`  Address No: #0\n  Network: ${new_default_network}\n  ${new_network.nativeCurrency.symbol} Balance: 0`)
+        );
+    }
+}
+
+export const accountBalanceLog = async (account_label: string, account_id: number, keystore_path: string, default_network: string) => {
+    const account_info = getAccountInfo(keystore_path, account_label);
+
+    let account_address: string;
+    if (account_info.account_type === "PK") {
+        account_address = getAccountAddress(keystore_path, account_label, account_id);
+    } else {
+        account_address = getPKAccountAddress(keystore_path, account_label);
+    }
+
+    const balance_result = await getAccountBalance(account_address, keystore_path, default_network);
+    if (balance_result.status) {
+        console.log(
+            chalk.green(`  Address No: #${account_id}\n  Network: ${default_network}\n  ${balance_result.output}`)
+        );
+    } else {
+        console.log(
+            chalk.green(`  Address No: #${account_id}\n  Network: ${default_network}\n  ${balance_result.output}`)
+        );
+    }
+}
+
+export const getAccountBalance = async (account: string, keystore_path: string, default_network: string) => {
+    const network_info = getNetworkInfoByName(keystore_path, default_network);
+
+    const rpc_url = network_info.rpcUrl;
+    const decimals = network_info.nativeCurrency.decimals;
+
+    let result: Result;
+    if (getChainType(network_info.chainId.toString()) === "solana") {
+        result = await getAccountBalanceInSolana(account, rpc_url);
+    } else {
+        result = await getAccountBalanceInEvm(account, rpc_url);
+    }
+
+    if (result.status) {
+        let balance = new BigNumber(result.output.toString());
+        result.output = balance.dividedBy(Math.pow(10, decimals)).toFixed(4, BigNumber.ROUND_FLOOR);
+    }
+    return result;
+}
+
+export const getDefaultNetworkByAddress = (keystore_path: string, account_label: string, account_address: string) => {
+    const account_info = getAccountInfo(keystore_path, account_label);
+    if (account_info.account_type === "PK") {
+        return account_info.default_network;
+    }
+    for (let i = 0; i < account_info.data.length; i++) {
+        if (
+            account_info.data[i].ciphertexts.solana.address === account_address ||
+            account_info.data[i].ciphertexts.evm.address === account_address
+        ) {
+            if ("default_network" in account_info.data[i]) {
+                return account_info.data[i].default_network;
+            } else {
+                return account_info.default_network;
+            }
+        }
+    }
+    return null;
+}
+
+export const getEvmNetworks = (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+    const network_list = networks.networks;
+    const network_len = network_list.length;
+    let result: any = [];
+    for (let i = 0; i < network_len; i++) {
+        if (getChainType(network_list[i].chainId.toString()) === "evm") {
+            result.push(network_list[i].name);
+        }
+    }
+    return result;
+}
+