wative 1.0.9 → 1.0.11

package/src/assets.ts

@@ -2,10 +2,10 @@ const chalk = require('chalk');
 import * as path from "path";
 import * as fs from 'fs';
 import { BigNumber } from 'bignumber.js';
-import { isEvmAddress, isSolanaAddress } from "./chain";
+import { getChainType, isEvmAddress, isSolanaAddress } from "./chain";
 import { getNetworkInfoByName, getNetworkTypeByName } from "./network";
-import { chainAddressValidator, checkFileExistence, inputSomething, selectSomething } from "./utils";
-import { getTokenBalanceInEvm, getTokenBalanceInSolana, getTokenInfoInEvm, getTokenInfoInSolana } from './web3';
+import { chainAddressValidator, checkFileExistence, inputSomething, numberValidator, selectSomething } from "./utils";
+import { deleteTokenBalance, getTokenBalance, getTokenBalanceInEvm, getTokenBalanceInSolana, getTokenInfoInEvm, getTokenInfoInSolana, updateBalance } from './web3';
 import inquirer from "inquirer";
 
 
@@ -48,8 +48,8 @@ export const showAssetsDetail = async (
     default_network: string,
     account_address: string
 ) => {
-    const network_type = getNetworkTypeByName(keystore_path, default_network);
     const network_info = getNetworkInfoByName(keystore_path, default_network);
+    const network_type = getChainType(network_info.chainId);
     const asset_list = await getAssetList(keystore_path, network_info.chainId.toString());
     if (!asset_list) {
         console.log(chalk.red("No asset found"));
@@ -60,7 +60,8 @@ export const showAssetsDetail = async (
         account_address,
         asset_list,
         network_info.rpcUrl,
-        network_type
+        network_type,
+        network_info.chainId
     );
 
     let asset_id = 1;
@@ -87,7 +88,8 @@ export const saveAsset = async (
     asset_address: string,
     symbol: string,
     name: string,
-    decimals: number
+    decimals: number,
+    display_decimals: number
 ) => {
     let json_data_path = path.join(keystore_path, `assets.json`);
     let assets_mapping: any = {};
@@ -98,23 +100,103 @@ export const saveAsset = async (
     if (assets_mapping[chain_id] === undefined) {
         assets_mapping[chain_id] = [];
     }
+
+    for (let i = 0; i < assets_mapping[chain_id].length; i++) {
+        if (assets_mapping[chain_id][i].address === asset_address) {
+            assets_mapping[chain_id][i] = {
+                address: asset_address,
+                symbol,
+                name,
+                decimals,
+                display_decimals
+            };
+
+            fs.writeFileSync(json_data_path, JSON.stringify(assets_mapping, null, 4));
+            return;
+        }
+    }
+
     assets_mapping[chain_id].push({
         address: asset_address,
         symbol,
         name,
-        decimals
+        decimals,
+        display_decimals
     });
     fs.writeFileSync(json_data_path, JSON.stringify(assets_mapping, null, 4));
 }
 
+export const addToken = async (
+    keystore_path: string,
+) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    let options: any = [];
+    let network_list = networks.networks;
+    for (let i = 0; i < network_list.length; i++) {
+        options.push(`${i + 1}. ${network_list[i].name}`);
+    }
+
+    let selected_option = await selectSomething(options);
+    let network_name = selected_option.split(".")[1].trim();
+    const network_type = getNetworkTypeByName(keystore_path, network_name);
+    const network_info = getNetworkInfoByName(keystore_path, network_name);
+
+    const token_address = await inputSomething("Enter contract address", chainAddressValidator);
+
+    let token_info_result: any;
+    if (network_type === "evm") {
+        if (!isEvmAddress(token_address)) {
+            console.log(chalk.red("evm address format error"));
+            return;
+        }
+        token_info_result = await getTokenInfoInEvm(token_address, network_info.rpcUrl);
+    } else {
+        if (!isSolanaAddress(token_address)) {
+            console.log(chalk.red("solana address format error"));
+            return;
+        }
+        token_info_result = await getTokenInfoInSolana(token_address, network_info.rpcUrl);
+    }
+    if (!token_info_result.status) {
+        console.log(chalk.red(token_info_result.output));
+        return;
+    }
+
+    if (!token_info_result.output.name) {
+        token_info_result.output.name = await inputSomething("Please input token name");
+    }
+    if (!token_info_result.output.symbol) {
+        token_info_result.output.symbol = await inputSomething("Please input token symbol");
+    }
+
+    console.log(
+        chalk.green(`Token ${token_info_result.output.name} loaded successfully.`)
+    );
+
+    let display_decimals = await inputSomething("Enter decimals for display", numberValidator);
+    display_decimals = parseInt(display_decimals);
+    await saveAsset(
+        keystore_path,
+        network_info.chainId.toString(),
+        token_address,
+        token_info_result.output.symbol,
+        token_info_result.output.name,
+        token_info_result.output.decimals,
+        display_decimals
+    );
+}
+
 export const addAsset = async (
     keystore_path: string,
     default_network: string
 ) => {
-    const token_address = await inputSomething("Please input Token address", chainAddressValidator);
     const network_type = getNetworkTypeByName(keystore_path, default_network);
     const network_info = getNetworkInfoByName(keystore_path, default_network);
 
+    const token_address = await inputSomething("Enter contract address", chainAddressValidator);
+
     let token_info_result: any;
     if (network_type === "evm") {
         if (!isEvmAddress(token_address)) {
@@ -133,22 +215,28 @@ export const addAsset = async (
         console.log(chalk.red(token_info_result.output));
         return;
     }
+
     if (!token_info_result.output.name) {
         token_info_result.output.name = await inputSomething("Please input token name");
     }
     if (!token_info_result.output.symbol) {
         token_info_result.output.symbol = await inputSomething("Please input token symbol");
     }
+
+    console.log(
+        chalk.green(`Token ${token_info_result.output.name} loaded successfully.`)
+    );
+
+    let display_decimals = await inputSomething("Enter decimals for display", numberValidator);
+    display_decimals = parseInt(display_decimals);
     await saveAsset(
         keystore_path,
         network_info.chainId.toString(),
         token_address,
         token_info_result.output.symbol,
         token_info_result.output.name,
-        token_info_result.output.decimals
-    );
-    console.log(
-        chalk.green("Asset added successfully")
+        token_info_result.output.decimals,
+        display_decimals
     );
 }
 
@@ -158,10 +246,10 @@ export const showAssets = async (
     default_network: string
 ) => {
     const options_assets_list = [
-        '> Back',
-        new inquirer.Separator('----------------------------------'),
         '> Show Assets',
-        '> Add Asset'
+        '> Add Asset',
+        new inquirer.Separator('----------------------------------'),
+        '> Back'
     ];
 
     const selected_option = await selectSomething(options_assets_list);
@@ -186,7 +274,8 @@ export const batchGetTokenBalance = async (
     account_address: string,
     asset_info_list: any,
     rpc_url: string,
-    chain_type: string
+    chain_type: string,
+    chain_id: string
 ) => {
     let asset_list_len = asset_info_list.length;
     let promise_list: any = [];
@@ -218,6 +307,64 @@ export const batchGetTokenBalance = async (
             symbol: asset_info.symbol,
             balance: asset_balance
         });
+        deleteTokenBalance(
+            chain_id,
+            account_address,
+            asset_info.address
+        );
     }
+
+    deleteTokenBalance(
+        chain_id,
+        account_address,
+        "0"
+    )
     return asset_balance_info_list;
+}
+
+export const getBatchAccountBalance = async (
+    keystore_path: string,
+    account_address_list: string[],
+    asset_info_list: any,
+    rpc_url: string,
+    network_name: string,
+    show_gas_token: boolean,
+    show_extended_token: boolean,
+) => {
+    let asset_info_list_len = asset_info_list.length;
+
+    let network_info = getNetworkInfoByName(keystore_path, network_name);
+    let chain_type = getChainType(network_info.chainId.toString());
+    let is_evm = chain_type === "evm";
+    if (show_gas_token) {
+        await updateBalance(
+            account_address_list,
+            "0",
+            network_info.chainId.toString(),
+            rpc_url,
+            is_evm
+        );
+    }
+
+    if (show_extended_token) {
+        for (let i = 0; i < asset_info_list_len; i++) {
+            let asset_info = asset_info_list[i];
+            let token_address = asset_info.address;
+            await updateBalance(
+                account_address_list,
+                token_address,
+                network_info.chainId.toString(),
+                rpc_url,
+                is_evm
+            );
+        }
+    }
+    let batchAccountBalanceOf: any = getTokenBalance(
+        network_info.chainId.toString(),
+        account_address_list,
+        asset_info_list,
+        network_info
+    );
+
+    return batchAccountBalanceOf;
 }

package/src/home_page.ts

@@ -1,5 +1,5 @@
-import { inputSomething, selectSomething } from "./utils";
-import { showAvailableNetworks, showNetwork } from "./network";
+import { selectSomething } from "./utils";
+import { showNetwork } from "./network";
 import { accountSetting } from "./account";
 import { showTools } from "./tools";
 const { WativeCore } = require("wative-core");

package/src/index.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import { showIntroduction, getKeystorePath } from "./utils";
+import { showIntroduction, getKeystorePath, updateStorage } from "./utils";
 import { createNetwork } from "./network";
 import { showHomePage } from "./home_page";
 
@@ -16,6 +16,7 @@ const main = async () => {
 
     const keystore_path = await getKeystorePath();
     await createNetwork(keystore_path);
+    updateStorage(keystore_path);
 
     const network_path = path.resolve(keystore_path, 'network.json');
     const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));

package/src/network.ts

@@ -13,14 +13,16 @@ import {
     getSymbol,
     getColor,
     Result,
-    getAccountChainType
+    getAccountChainType,
+    formatAddr
 } from "./utils";
 import {
     getAccountInfo,
     saveAccountInfo
 } from "./account";
-import { getAccountBalanceInEvm, getAccountBalanceInSolana } from "./web3";
+import { deleteTokenBalance, getAccountBalanceInEvm, getAccountBalanceInSolana } from "./web3";
 import { getChainType, getNativeTokenDecimals } from "./chain";
+import { addToken } from "./assets";
 
 export const createNetwork = async (keystore_path: string) => {
     const network_path = path.resolve(keystore_path, 'network.json');
@@ -40,8 +42,6 @@ export const createNetwork = async (keystore_path: string) => {
 
 export const selectOrEditNetwork = async (keystore_path: string, selected_network: any) => {
     let options: any[] = [
-        '> Back',
-        new inquirer.Separator('----------------------------------'),
         '> Edit'
     ];
 
@@ -49,6 +49,9 @@ export const selectOrEditNetwork = async (keystore_path: string, selected_networ
         options.push('> Remove');
     }
 
+    options.push(new inquirer.Separator('----------------------------------'));
+    options.push('> Back');
+
     const selected_network_info = await selectSomething(options);
 
     switch (selected_network_info) {
@@ -229,7 +232,11 @@ export const showAvailableNetworks = async (keystore_path: string) => {
         }
     }
 
-    let options: any = ['> Back', new inquirer.Separator(`----Networks(evm)----`)];
+    let options: any = [
+        '> Back',
+        '+ Add Network',
+        new inquirer.Separator(`----Networks(evm)----`)
+    ];
 
     for (let i = 0; i < evm_ids.length; i++) {
         const evm_id = evm_ids[i];
@@ -261,35 +268,172 @@ export const showAvailableNetworks = async (keystore_path: string) => {
         return;
     }
 
+    if (selected_option === '+ Add Network') {
+        await addNetwork(keystore_path);
+        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]];
+    if (option_id < evm_ids.length + 3) {
+        select_network = networks.networks[evm_ids[option_id - 3]];
     } else {
-        select_network = networks.networks[solana_ids[option_id - evm_ids.length - 3]];
+        select_network = networks.networks[solana_ids[option_id - evm_ids.length - 4]];
     }
 
     await selectOrEditNetwork(keystore_path, select_network);
     await showAvailableNetworks(keystore_path);
 }
 
+export const showDataview = async (keystore_path: string) => {
+    let options: any = [
+        '> Enhanced Balance Display',
+        new inquirer.Separator('----------------------------------'),
+        '> Back',
+    ];
+
+    const selected_option = await selectSomething(options);
+    switch (selected_option) {
+        case '> Enhanced Balance Display': {
+            await enhancedBalanceDisplay(keystore_path);
+            break;
+        }
+        case '> Back': {
+            return;
+        }
+    }
+
+    await showDataview(keystore_path);
+}
+
+export const updateStatus = async (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    if (!("status" in networks)) {
+        networks.status = {
+            fullAddr: false,
+            gasToken: false,
+            extendedToken: false
+        }
+    }
+
+    let options = [
+        `> Show Full Address  [${networks.status.fullAddr ? "ON" : "OFF"}]`,
+        `> Show Gas Token     [${networks.status.gasToken ? "ON" : "OFF"}]`,
+        `> Show Extended Token[${networks.status.extendedToken ? "ON" : "OFF"}]`,
+        new inquirer.Separator('----------------------------------'),
+        '> Back',
+    ];
+
+    const selected_option = await selectSomething(options);
+
+    if (selected_option === '> Back') {
+        return;
+    }
+
+    if (selected_option.includes('Full Address')) {
+        networks.status.fullAddr = await selectFlag();
+    } else if (selected_option.includes('Gas Token')) {
+        networks.status.gasToken = await selectFlag();
+    } else if (selected_option.includes('Extended Token')) {
+        networks.status.extendedToken = await selectFlag();
+    }
+
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 2));
+}
+
+export const selectFlag = async () => {
+    let options = [
+        '> On',
+        '> Off'
+    ];
+
+    const selected_option = await selectSomething(options);
+    switch (selected_option) {
+        case '> On': {
+            return true;
+        }
+        case '> Off': {
+            return false;
+        }
+    }
+}
+
+export const showTokenList = async (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+
+    let network_settings_map: any = {};
+    for (let network_info of networks.networks) {
+        network_settings_map[network_info.chainId.toString()] = network_info.name;
+    }
+
+    const assets_path = path.resolve(keystore_path, 'assets.json');
+    const assets = JSON.parse(fs.readFileSync(assets_path, 'utf8'));
+
+    for (let chain_id in assets) {
+        console.log(`----- Networks (${network_settings_map[chain_id]}) -------`);
+
+        let token_list_len = assets[chain_id].length;
+        for (let i = 0; i < token_list_len; i++) {
+            let token_info = assets[chain_id][i];
+            console.log(`${i + 1}.${token_info.symbol} CA: ${chalk.green(`${formatAddr(token_info.address)}`)
+                }  Decimals: ${token_info.display_decimals ? token_info.display_decimals : "4"}`);
+        }
+    }
+}
+
+export const enhancedBalanceDisplay = async (keystore_path: string) => {
+    const options = [
+        '> Status',
+        '> Token List',
+        '> Add Token',
+        new inquirer.Separator('----------------------------------'),
+        '> Back',
+    ];
+
+    const selected_option = await selectSomething(options);
+
+    switch (selected_option) {
+        case '> Status': {
+            await updateStatus(keystore_path);
+            break;
+        }
+        case '> Token List': {
+            await showTokenList(keystore_path);
+            break;
+        }
+        case '> Add Token': {
+            await addToken(keystore_path);
+            break;
+        }
+        case '> Back': {
+            return;
+        }
+    }
+
+    await enhancedBalanceDisplay(keystore_path);
+}
+
 export const showNetwork = async (keystore_path: string) => {
     let network_info_list = [
-        '> Back',
+        '> Networks',
+        '> Dataview',
         new inquirer.Separator('----------------------------------'),
-        '> Available Networks',
-        '> Add Network'
+        '> Back'
     ];
 
     const selected_network_info = await selectSomething(network_info_list);
 
     switch (selected_network_info) {
-        case '> Available Networks': {
+        case '> Networks': {
             await showAvailableNetworks(keystore_path);
             break;
         }
-        case '> Add Network': {
-            await addNetwork(keystore_path);
+        case '> Dataview': {
+            await showDataview(keystore_path);
             break;
         }
         case '> Back': {
@@ -341,10 +485,11 @@ export const getNetworkInfoByName = (keystore_path: string, network_name: string
 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;
+    if (account_info.account_type === "PK") {
+        return account_info.data[account_id].ciphertexts.address;
     }
+
+    let default_network = account_info.default_network;
     let network_type = getNetworkTypeByName(keystore_path, default_network);
 
     if (network_type === "solana") {
@@ -422,6 +567,44 @@ export const switchPPNetwork = async (keystore_path: string, account_label: stri
     );
 }
 
+export const showAllAccounts = async (keystore_path: string, account_label: string, account_index: 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 default_network = account_info.default_network;
+
+    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;
+        }
+
+        let account_address: string;
+        if (account_info.account_type === "PK") {
+            account_address = account_info.data[account_index].ciphertexts.address;
+        } else {
+            if (this_network_type === "evm") {
+                account_address = account_info.data[account_index].ciphertexts.evm.address;
+            } else {
+                account_address = account_info.data[account_index].ciphertexts.solana.address;
+            }
+        }
+
+        if (network.name === default_network) {
+            console.log(`● ${account_address} [${network.name}]`);
+        } else {
+            console.log(`○ ${account_address} [${network.name}]`);
+        }
+    }
+}
+
 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'));
@@ -523,6 +706,8 @@ export const getAccountBalance = async (account: string, keystore_path: string,
         let balance = new BigNumber(result.output.toString());
         result.output = balance.dividedBy(Math.pow(10, decimals)).toFixed(4, BigNumber.ROUND_FLOOR);
     }
+
+    deleteTokenBalance(network_info.chainId.toString(), account, "0");
     return result;
 }
 
@@ -560,3 +745,8 @@ export const getEvmNetworks = (keystore_path: string) => {
     return result;
 }
 
+export const getStatus = (keystore_path: string) => {
+    const network_path = path.resolve(keystore_path, 'network.json');
+    const networks = JSON.parse(fs.readFileSync(network_path, 'utf8'));
+    return networks.status;
+}

package/src/tools.ts

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 import { BigNumber } from 'bignumber.js';
 import inquirer from 'inquirer';
-import { chainAddressValidator, confirmSomething, editorSomething, getAccountChainType, hexValidator, inputSomething, numberValidator, selectSomething } from "./utils";
+import { addrValidator, chainAddressValidator, confirmSomething, editorSomething, getAccountChainType, hexValidator, inputSomething, numberValidator, selectSomething } from "./utils";
 import { loginIn } from './account';
 import { getAccountBalance, getDefaultNetworkByAddress, getEvmNetworks, getNetworkInfoByName, getNetworkTypeByName } from './network';
 import { GasUtil } from './tx_gas_utils';
@@ -638,10 +638,10 @@ const excuteTools = async (keystore_path: string, account_label: string, account
     );
 
     const option_send_tx = [
-        '> Back',
-        new inquirer.Separator('----------------------------------'),
         '> Send Raw Tx',
-        '> Send Token'
+        '> Send Token',
+        new inquirer.Separator('----------------------------------'),
+        '> Back',
     ];
 
     const selected_send_tx = await selectSomething(option_send_tx);
@@ -697,10 +697,10 @@ const excuteTools = async (keystore_path: string, account_label: string, account
 
 export const selectToolsOptions = async (keystore_path: string, account_label: string, account_address: string, wative_core: typeof WativeCore) => {
     const tools_options = [
-        '> Back',
-        new inquirer.Separator('----------------------------------'),
         '> SendTx',
-        '> SignMessage'
+        '> SignMessage',
+        new inquirer.Separator('----------------------------------'),
+        '> Back'
     ];
 
     const selected_tools_option = await selectSomething(tools_options);
@@ -729,15 +729,44 @@ export const selectToolsOptions = async (keystore_path: string, account_label: s
 }
 
 export const showTools = async (keystore_path: string, wative_core: typeof WativeCore) => {
-    const account_address = await inputSomething("Input the address to send tx", chainAddressValidator);
-    const account_label = wative_core.account.getAccountLabel(account_address);
+    let options = [
+        "> Send Tx",
+        "> Search Accounts",
+        new inquirer.Separator('----------------------------------'),
+        "> Back"
+    ];
+
+    let selected_option = await selectSomething(options);
+
+    if (selected_option === "> Back") {
+        return;
+    }
+
+    let account_address: any;
+    if (selected_option === "> Send Tx") {
+        account_address = await inputSomething("Input address to send tx", chainAddressValidator);
+    }
+
+    if (selected_option === "> Search Accounts") {
+        account_address = await inputSomething("Input part address to send tx", addrValidator);
+    }
+
+    let account_label_info = wative_core.account.getAccountLabel(account_address);
+    if (account_label_info === null) {
+        console.log(chalk.red("Account not found"));
+        await showTools(keystore_path, wative_core);
+        return;
+    }
+
+    let account_label = account_label_info.account_label;
+    account_address = account_label_info.account_address;
     if (account_label === null) {
         console.log(chalk.red("Account not found"));
         await showTools(keystore_path, wative_core);
         return;
     }
     let login_result = await loginIn(account_label, wative_core);
-    if (!login_result) {
+    if (!login_result.isLoginIn) {
         await showTools(keystore_path, wative_core);
         return;
     }