wative 1.0.5 → 1.0.7

package/src/account.ts

@@ -10,10 +10,14 @@ import {
     passphraseValidator,
     expandAmountValidator,
     lastAccountNoValidator,
+    getAccountIndex,
+    getAccountRange,
+    confirmSomething,
 } from "./utils";
 import { getAccountAddress, getAccountBalance, getNetworkInfoByName, getNetworkTypeByName, getPKAccountAddress, selectDefaultNetwork, switchNetworkByAccountLabel, switchPPNetwork } from "./network";
 import { showAssets } from './assets';
 import { selectToolsOptions } from './tools';
+import inquirer from "inquirer";
 
 const cliProgress = require('cli-progress');
 const { WativeCore } = require("wative-core");
@@ -199,6 +203,145 @@ const selectAccount = async (keystore_path: string, wative_core: typeof WativeCo
     await selectAccount(keystore_path, wative_core);
 }
 
+const setDisableAddress = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
+    const account_info = await getAccountInfo(keystore_path, account_label);
+
+    let disable_address_options = [
+        "> Back",
+        "1.Disabled Slots",
+        "2.Add Single",
+        "3.Add Range"
+    ];
+
+    const selected_disable_address = await selectSomething(disable_address_options);
+    switch (selected_disable_address) {
+        case "> Back": {
+            return;
+        }
+        case "1.Disabled Slots": {
+            let disabled_slots = account_info.disabled_slots;
+            if (!disabled_slots || disabled_slots.length === 0) {
+                console.log(
+                    chalk.red("No disabled slots here yet")
+                )
+                break;
+            }
+
+            let account_data = account_info.data;
+
+            let disabled_slots_options = [
+                "> Back",
+            ];
+
+            let default_network = account_info.default_network;
+            for (let i = 0; i < disabled_slots.length; i++) {
+                let from = disabled_slots[i].from;
+                let to = disabled_slots[i].to;
+
+                let from_default_network = default_network;
+                let to_default_network = default_network;
+
+                if ("default_network" in account_data[from]) {
+                    from_default_network = account_data[from].default_network;
+                }
+
+                if ("default_network" in account_data[to]) {
+                    to_default_network = account_data[to].default_network;
+                }
+
+                let from_network_type = getNetworkTypeByName(keystore_path, from_default_network);
+                let to_network_type = getNetworkTypeByName(keystore_path, to_default_network);
+
+                if (from_network_type !== "evm" && from_network_type !== "solana") {
+                    throw new Error(`Invalid network type: ${from_network_type}`);
+                }
+
+                if (to_network_type !== "evm" && to_network_type !== "solana") {
+                    throw new Error(`Invalid network type: ${to_network_type}`);
+                }
+
+                let from_address: string;
+                let to_address: string;
+
+                if (from_network_type === "evm") {
+                    from_address = account_data[from].ciphertexts.evm.address;
+                } else {
+                    from_address = account_data[to].ciphertexts.solana.address;
+                }
+
+                if (to_network_type === "evm") {
+                    to_address = account_data[to].ciphertexts.evm.address;
+                } else {
+                    to_address = account_data[to].ciphertexts.solana.address;
+                }
+
+                if (from === to) {
+                    disabled_slots_options.push(`${i + 1}. ${from_address}[${from}]`);
+                } else {
+                    disabled_slots_options.push(`${i + 1}. ${from_address}[${from}]-${to_address}[${to}]`);
+                }
+            }
+
+            let selected_disabled_slots = await selectSomething(disabled_slots_options);
+
+            if (selected_disabled_slots === "> Back") {
+                break;
+            }
+
+            let confirm = await confirmSomething(`Are you sure to delete the ${selected_disabled_slots}?`);
+            if (!confirm) {
+                break;
+            }
+            let selected_disabled_slots_index = disabled_slots_options.indexOf(selected_disabled_slots) - 1;
+
+            account_info.disabled_slots.splice(selected_disabled_slots_index, 1);
+            saveAccountInfo(keystore_path, account_label, account_info);
+
+            break;
+        }
+        case "2.Add Single": {
+            let account_index_or_address = await getAccountIndex(account_info, "Input address or index");
+            if (account_index_or_address === null) {
+                console.log(chalk.red("Invalid account index"));
+                break;
+            }
+
+            if (account_info.disabled_slots) {
+                account_info.disabled_slots.push({
+                    from: account_index_or_address,
+                    to: account_index_or_address
+                });
+            } else {
+                account_info.disabled_slots = [{
+                    from: account_index_or_address,
+                    to: account_index_or_address
+                }];
+            }
+
+            saveAccountInfo(keystore_path, account_label, account_info);
+            break;
+        }
+        case "3.Add Range": {
+            let account_range = await getAccountRange(account_info);
+            if (!account_range) {
+                console.log(chalk.red("Invalid account range"));
+                break;
+            }
+
+            if (account_info.disabled_slots) {
+                account_info.disabled_slots.push(account_range);
+            } else {
+                account_info.disabled_slots = [account_range];
+            }
+
+            saveAccountInfo(keystore_path, account_label, account_info);
+            break;
+        }
+    }
+
+    await setDisableAddress(keystore_path, account_label, wative_core);
+}
+
 
 const accountManager = async (keystore_path: string, account_label: string, wative_core: typeof WativeCore) => {
     let account_info = await getAccountInfo(keystore_path, account_label);
@@ -210,8 +353,9 @@ const accountManager = async (keystore_path: string, account_label: string, wati
             '1.Address List',
             '2.Expand Address',
             '3.Slice Address',
-            '4.Reset Account Password',
-            `5.Switch Networks [${account_info.default_network}]`,
+            '4.Disable Address',
+            '5.Reset Account Password',
+            `6.Switch Networks [${account_info.default_network}]`,
             '> Back'
         ];
     } else {
@@ -250,7 +394,11 @@ const accountManager = async (keystore_path: string, account_label: string, wati
             await sliceAddress(keystore_path, account_label, Number(last_account_no), wative_core);
             break;
         }
-        case '4.Reset Account Password': {
+        case '4.Disable Address': {
+            await setDisableAddress(keystore_path, account_label, wative_core);
+            break;
+        }
+        case '5.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}]`);
 
@@ -268,7 +416,7 @@ const accountManager = async (keystore_path: string, account_label: string, wati
             await switchNetworkByAccountLabel(keystore_path, account_label, true);
             break;
         }
-        case `5.Switch Networks [${account_info.default_network}]`: {
+        case `6.Switch Networks [${account_info.default_network}]`: {
             await switchNetworkByAccountLabel(keystore_path, account_label, true);
             break;
         }
@@ -296,11 +444,13 @@ const accountManager = async (keystore_path: string, account_label: string, wati
 
 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 = [
+    let option_accounts: any = [
         '> Back'
     ];
 
+    let disabled_slots = account_info.disabled_slots;
     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;
@@ -313,10 +463,24 @@ const showPPAccounts = async (keystore_path: string, account_label: string, wati
             tag = `(${account_info.data[i].tag})`;
         }
 
+        let is_disable_address = wative_core.account.checkIsDisableAddress(disabled_slots, i);
         if (network_type === "evm") {
-            option_accounts.push(`#${i} ${account_info.data[i].ciphertexts.evm.address} ${tag} [${default_network}]`);
+            if (is_disable_address) {
+                option_accounts.push(new inquirer.Separator(
+                    chalk.yellow(`#${i} ${account_info.data[i].ciphertexts.evm.address} ${tag} [${default_network}]`)
+                ))
+            } else {
+                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}]`);
+            if (is_disable_address) {
+                option_accounts.push(new inquirer.Separator(
+                    chalk.yellow(`#${i} ${account_info.data[i].ciphertexts.solana.address} ${tag} [${default_network}]`)
+                ))
+            } else {
+                option_accounts.push(`#${i} ${account_info.data[i].ciphertexts.solana.address} ${tag} [${default_network}]`);
+            }
         }
     }
 

package/src/index.ts

@@ -19,7 +19,7 @@ const main = async () => {
 
     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);
+    const wative_core = new WativeCore(keystore_path, networks.accounts, null, true);
     await showHomePage(keystore_path, wative_core);
 }
 

package/src/tools.ts

@@ -202,7 +202,8 @@ export const sendSolanaRawTransaction = async (chain_rpc_url: string, chain_symb
         return;
     }
 
-    const unitsConsumed = new BigNumber(simulate_result.output.value.unitsConsumed.toString());
+    let baseUnitsConsumed = new BigNumber(simulate_result.output.value.unitsConsumed.toString()).multipliedBy(1.2).toFixed(0, BigNumber.ROUND_CEIL);
+    let unitsConsumed = new BigNumber(baseUnitsConsumed);
     const prioritization_fee_result = await getPrioritizationFee(chain_rpc_url);
     if (!prioritization_fee_result.status) {
         console.log(chalk.red(prioritization_fee_result.output));
@@ -247,7 +248,7 @@ export const sendSolanaRawTransaction = async (chain_rpc_url: string, chain_symb
     let transactions = new Transaction();
     transactions.add(
         ComputeBudgetProgram.setComputeUnitLimit({
-            units: Math.ceil(Number(unitsConsumed) * 2)
+            units: Number(unitsConsumed)
         })
     );
     transactions.add(
@@ -549,7 +550,8 @@ const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url:
         return;
     }
 
-    const unitsConsumed = new BigNumber(simulate_result.output.value.unitsConsumed.toString());
+    let unitsConsumed = new BigNumber(simulate_result.output.value.unitsConsumed.toString());
+    unitsConsumed = new BigNumber(Math.ceil(Number(unitsConsumed) * 1.2));
     const prioritization_fee_result = await getPrioritizationFee(chain_rpc_url);
     if (!prioritization_fee_result.status) {
         console.log(chalk.red(prioritization_fee_result.output));
@@ -569,7 +571,7 @@ const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url:
 
     transactions.add(
         ComputeBudgetProgram.setComputeUnitLimit({
-            units: Math.ceil(Number(unitsConsumed) * 1.2)
+            units: Number(unitsConsumed)
         })
     );
     transactions.add(

package/src/utils.ts

@@ -24,6 +24,64 @@ export const inputSomething = async (text: string, validate_func?: Function) =>
     return inputText.trim().toString()
 }
 
+export const getAccountRange = async (account_info: any) => {
+    for (let i = 0; i < 5; i++) {
+        let start_address_index = await getAccountIndex(account_info, "Input start address or index");
+        if (!start_address_index) {
+            console.log(chalk.red("Invalid start account index"));
+            return null;
+        }
+        let end_address_index = await getAccountIndex(account_info, "Input end address or index");
+        if (!end_address_index) {
+            console.log(chalk.red("Invalid end account index"));
+            return null;
+        }
+        if (start_address_index > end_address_index) {
+            console.log(chalk.red("Invalid address range"));
+            continue;
+        }
+        return {
+            from: start_address_index,
+            to: end_address_index
+        };
+    }
+    return null;
+}
+
+export const getAccountIndex = async (account_info: any, message: string) => {
+    let account_data = account_info.data;
+    let account_length = account_data.length;
+    if (account_length === 0) {
+        return null;
+    }
+
+    let evm_account_list: any = [];
+    let solana_account_list: any = [];
+
+    for (let i = 0; i < account_length; i++) {
+        evm_account_list.push(account_data[i].ciphertexts.evm.address.toLocaleLowerCase());
+        solana_account_list.push(account_data[i].ciphertexts.solana.address.toLocaleLowerCase());
+    }
+    let max_account_index = account_length - 1;
+    for (let i = 0; i < 5; i++) {
+        let account_index_or_address = await inputSomething(message, accountIndexOrAddressValidator);
+        let account_chain_type = getAccountChainType(account_index_or_address);
+        if (account_chain_type === "unknown") {
+            if (Number(account_index_or_address) > max_account_index) {
+                console.log(chalk.red("Invalid account index"));
+                continue;
+            }
+            return Number(account_index_or_address);
+        } else if (account_chain_type === "evm" && evm_account_list.indexOf(account_index_or_address.toLocaleLowerCase()) !== -1) {
+            return evm_account_list.indexOf(account_index_or_address.toLocaleLowerCase());
+        } else if (account_chain_type === "solana" && solana_account_list.indexOf(account_index_or_address.toLocaleLowerCase()) !== -1) {
+            return solana_account_list.indexOf(account_index_or_address.toLocaleLowerCase());
+        }
+    }
+
+    return null;
+}
+
 export const tagValidator = (tag: string) => {
     if (tag === "") {
         return true;
@@ -86,6 +144,13 @@ export const lastAccountNoValidator = (last_account_no: string) => {
     return true;
 }
 
+export const accountIndexOrAddressValidator = (account_index_or_address: string) => {
+    if (isNaN(Number(account_index_or_address)) === false) {
+        return true;
+    }
+    return chainAddressValidator(account_index_or_address);
+}
+
 export const chainAddressValidator = (chain_address: string) => {
     let account_chain_type = getAccountChainType(chain_address);