wative 1.0.8 → 1.0.10

package/src/assets.ts

@@ -2,10 +2,11 @@ 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";
 
 
 // symbol; name; address; decimals
@@ -47,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"));
@@ -59,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;
@@ -86,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 = {};
@@ -97,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)) {
@@ -132,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
     );
 }
 
@@ -157,22 +246,23 @@ export const showAssets = async (
     default_network: string
 ) => {
     const options_assets_list = [
-        "> Show Assets",
-        "> Add Asset",
-        "> Back"
+        '> Show Assets',
+        '> Add Asset',
+        new inquirer.Separator('----------------------------------'),
+        '> Back'
     ];
 
     const selected_option = await selectSomething(options_assets_list);
     switch (selected_option) {
-        case "> Show Assets": {
+        case '> Show Assets': {
             await showAssetsDetail(keystore_path, default_network, account_address);
             break;
         }
-        case "> Add Asset": {
+        case '> Add Asset': {
             await addAsset(keystore_path, default_network);
             break;
         }
-        case "> Back": {
+        case '> Back': {
             return;
         }
     }
@@ -184,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 = [];
@@ -216,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'));