wative 1.0.9 → 1.0.10

package/src/utils.ts

@@ -3,10 +3,12 @@ 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 } from "./web3";
 import { MNEMONIC_WORDS } from './config';
 import { getChainType } from './chain';
+import { getBatchAccountBalance } from './assets';
 
 const USER_HOME: any = process.env.HOME || process.env.USERPROFILE
 const BASE_PATH = `${USER_HOME}/.wative`
@@ -100,6 +102,13 @@ export const tagValidator = (tag: string) => {
     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";
@@ -230,7 +239,7 @@ export const getRpcUrl = async (chain_id: string, text: string, update: boolean
                 return null
             }
 
-            if (getChainType(chain_id) === "solana") {
+            if (getChainType(chain_id.toString()) === "solana") {
                 return rpc_url;
             }
             const new_chain_id = await getChainIdByEvm(rpc_url);
@@ -297,7 +306,7 @@ export const getColor = async (text: string) => {
 }
 
 export const getAccountLabel = async (text: string, account_label_list: string[]) => {
-    let reg = /^[a-zA-Z0-9]{2,20}$/g;
+    let reg = /^(?![-_]).*?[a-zA-Z0-9_-]{4,20}(?<![-_])$/g;
     for (let i = 0; i < 5; i++) {
         let account_label = await inputSomething(text);
         account_label = account_label.trim();
@@ -306,7 +315,7 @@ export const getAccountLabel = async (text: string, account_label_list: string[]
                 console.log(chalk.red("Account label already exists"));
                 continue;
             } else {
-                return account_label.toLocaleLowerCase();
+                return account_label;
             }
         }
     }
@@ -360,16 +369,29 @@ const passwordValidator = function (value: string) {
 };
 
 export const inputPassword = async (text: string) => {
+    let count = 0;
+
     const questions = [
         {
             name: 'password',
             type: 'password',
             mask: '#',
             message: `${text}:`,
-            validate: passwordValidator
+            validate: (fieldValue: string) => {
+                if (count >= 3) {
+                    return true
+                }
+
+                return passwordValidator(fieldValue);
+            }
         }
     ]
-    const { password } = await inquirer.prompt(questions);
+
+    let { password } = await inquirer.prompt(questions);
+    if (count >= 3) {
+        password = null;
+    }
+
     return password;
 }
 
@@ -443,4 +465,212 @@ export const getAccountChainType = (account_address: string) => {
 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);
+}
+
+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,
+    message?: string,
+    default_account?: any
+) => {
+    const questions = [
+        {
+            type: 'list',
+            name: 'inputText',
+            message: message || 'Choose an option',
+            choices: options,
+            pageSize: 30,
+            default: default_account,
+            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]) {
+        await sleep(2000);
+        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 (round < 5) {
+            continue;
+        }
+        round = 0;
+        const pageSize = promise.ui.activePrompt.opt.pageSize;
+
+        let accounts: any = [];
+        for (let i = 0; i < promise.ui.activePrompt.opt.choices.choices.length; i++) {
+            if (!promise.ui.activePrompt.opt.choices.choices[i].name) {
+                accounts.push(null);
+                continue;
+            }
+
+            let account: any = null;
+
+            if (is_evm) {
+                account = /0x[0-9a-fA-f]{40}/.exec(promise.ui.activePrompt.opt.choices.choices[i].name);
+                account = account ? account[0] : null;
+            } else {
+                let re_result = account = /\s+([0-9a-zA-Z]*)/.exec(promise.ui.activePrompt.opt.choices.choices[i].name);
+                account = re_result ? re_result[1] : null;
+
+                if (account === "Back") {
+                    account = null;
+                }
+            }
+
+            if (account) {
+                accounts.push(account)
+            } else {
+                accounts.push(null);
+            }
+        }
+        accounts = accounts.concat(accounts);
+        let fromIndex: number, toIndex: number;
+        if (selected < pageSize / 2) {
+            if (accounts.length / 2 <= pageSize) {
+                fromIndex = 0;
+                toIndex = accounts.length / 2;
+            } else {
+                fromIndex = 0;
+                toIndex = pageSize;
+            }
+        } else {
+            if (accounts.length / 2 <= pageSize) {
+                fromIndex = 0;
+                toIndex = accounts.length / 2;
+            } else {
+                fromIndex = selected - pageSize / 2 + 1;
+                toIndex = selected + pageSize / 2 + 1;
+            }
+        }
+
+        let 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 gas_token_name = network_info.nativeCurrency.symbol;
+        for (let i = fromIndex; i < toIndex; i++) {
+            let _index = i >= accounts.length / 2 ? i - accounts.length / 2 : i;
+            let _choice = promise.ui.activePrompt.opt.choices.choices[_index];
+            if (!_choice.name) {
+                continue;
+            }
+
+            let name = _choice.name;
+            let account_address = accounts[i];
+            let token_message = '';
+
+            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]} `;
+            }
+
+            let nameList = name.split('(');
+            if (nameList.length > 1) {
+                let tag = nameList[1];
+                promise.ui.activePrompt.opt.choices.choices[_index].name = nameList[0] + ` ${token_message}` + `(${tag}`;
+            } else {
+                promise.ui.activePrompt.opt.choices.choices[_index].name = nameList[0] + ` ${token_message}`;
+            }
+        }
+        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
+        }
+    }
+
+    fs.writeFileSync(network_path, JSON.stringify(networks, null, 4));
+    let account_label_list = networks.accounts;
+
+    for (let i = 0; i < account_label_list.length; i++) {
+        let account_label_path = path.resolve(keystore_path, `accounts/${account_label_list[i]}.json`);
+        let account_info = JSON.parse(fs.readFileSync(account_label_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(account_label_path, JSON.stringify(account_info, null, 4));
+    }
 }

package/src/web3.ts

@@ -1,8 +1,11 @@
 import Web3 from 'web3';
-import { excutePromiseFunction } from './utils';
+import { chunkArray, excutePromiseFunction, sleep } from './utils';
 import { Connection, PublicKey } from "@solana/web3.js";
 import { getMint, getAssociatedTokenAddressSync } from "@solana/spl-token"
-import { Metaplex } from "@metaplex-foundation/js";
+import { Metaplex, token } from "@metaplex-foundation/js";
+import { BigNumber } from "bignumber.js";
+
+const chainIdAccountBalanceMap: any = {};
 
 export const getChainIdByEvm = async (rpc_url: string) => {
     let web3 = new Web3(rpc_url);
@@ -265,4 +268,101 @@ export const getAccountInfoInSolana = async (account: string, rpc_url: string) =
         status: true,
         output: result.output
     }
+}
+
+export const updateBalance = async (account_address_list: string[], token_address: string, chain_id: string, rpc_url: string, is_evm: boolean) => {
+    let accountBalanceMap: any;
+    if (chain_id in chainIdAccountBalanceMap) {
+        accountBalanceMap = chainIdAccountBalanceMap[chain_id][token_address] || {};
+    } else {
+        chainIdAccountBalanceMap[chain_id] = {};
+        accountBalanceMap = {};
+    }
+
+    for (const account of account_address_list) {
+        if (!account) {
+            continue;
+        }
+
+        if (!(account in accountBalanceMap)) {
+            let result: any;
+            if (token_address === "0") {
+                if (is_evm) {
+                    result = await getAccountBalanceInEvm(account, rpc_url);
+                } else {
+                    result = await getAccountBalanceInSolana(account, rpc_url);
+                }
+            } else {
+                if (is_evm) {
+                    result = await getTokenBalanceInEvm(account, token_address, rpc_url);
+
+                } else {
+                    result = await getTokenBalanceInSolana(account, token_address, rpc_url);
+                }
+            }
+
+            if (result.status) {
+                accountBalanceMap[account] = result.output;
+            }
+            await sleep(200);
+        }
+    }
+
+    chainIdAccountBalanceMap[chain_id][token_address] = accountBalanceMap;
+
+    return chainIdAccountBalanceMap;
+}
+
+export const getTokenBalance = (
+    chain_id: string,
+    account_address_list: any,
+    asset_info_list: any,
+    network_info: any
+) => {
+    let batchAccountBalanceOf: any = {};
+
+    if (!(chain_id in chainIdAccountBalanceMap)) {
+        return batchAccountBalanceOf;
+    }
+
+    asset_info_list.unshift({
+        address: "0",
+        name: network_info.nativeCurrency.name,
+        symbol: network_info.nativeCurrency.symbol,
+        decimals: network_info.nativeCurrency.decimals,
+        display_decimals: 4
+    });
+    let account_address_list_len = account_address_list.length;
+    for (let i = 0; i < account_address_list_len; i++) {
+        let account_address = account_address_list[i];
+
+        if (!account_address) {
+            continue;
+        }
+
+        for (let j = 0; j < asset_info_list.length; j++) {
+            let asset_info = asset_info_list[j];
+            let token_balance = "0";
+            if (!chainIdAccountBalanceMap[chain_id][asset_info.address]) {
+                continue;
+            }
+
+            if (account_address in chainIdAccountBalanceMap[chain_id][asset_info.address]) {
+                let balance = new BigNumber(chainIdAccountBalanceMap[chain_id][asset_info.address][account_address]);
+                token_balance = balance.dividedBy(10 ** asset_info.decimals).toFixed(asset_info.display_decimals || 4, BigNumber.ROUND_FLOOR);
+            }
+            if (!batchAccountBalanceOf[account_address]) {
+                batchAccountBalanceOf[account_address] = {};
+            }
+            batchAccountBalanceOf[account_address][asset_info.symbol] = token_balance;
+        }
+    }
+
+    return batchAccountBalanceOf;
+}
+
+export const deleteTokenBalance = (chain_id: string, account_address: string, token_address: string) => {
+    try {
+        delete chainIdAccountBalanceMap[chain_id][token_address][account_address];
+    } catch (error) { }
 }

package/rollup.config.js

@@ -1,30 +0,0 @@
-import { terser } from 'rollup-plugin-terser';
-import commonjs from '@rollup/plugin-commonjs';
-import typescript from 'rollup-plugin-typescript2';
-
-export default {
-    input: 'src/index.ts',
-    output: [
-        {
-            file: 'lib/index.esm.js',
-            format: 'es',
-        },
-        {
-            file: 'lib/index.umd.js',
-            format: 'umd',
-            name: 'demo',
-        },
-    ],
-    plugins: [
-        terser(),
-        commonjs(),
-        typescript({
-            tsconfigOverride: {
-                compilerOptions: {
-                    module: "ESNext"
-                },
-                include: ['src/**/*'],
-            },
-        })
-    ]
-};