wative 1.0.1

package/src/tools.ts

@@ -0,0 +1,742 @@
+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 { loginIn } from './account';
+import { getAccountBalance, getDefaultNetworkByAddress, getEvmNetworks, getNetworkInfoByName, getNetworkTypeByName } from './network';
+import { GasUtil } from './tx_gas_utils';
+import { getAccountBalanceInEvm, getAccountBalanceInSolana, getAccountInfoInSolana, getCodeInEvm, getPrioritizationFee, getTokenBalanceInEvm, getTokenBalanceInSolana, getTokenInfoInEvm, getTokenInfoInSolana, getTransferTokenData } from './web3';
+import { getAssetListByTokenName } from './assets';
+import { ComputeBudgetProgram, PublicKey, SystemProgram, Transaction } from '@solana/web3.js';
+import {
+    getAssociatedTokenAddressSync,
+    createTransferInstruction,
+    createAssociatedTokenAccountInstruction
+} from "@solana/spl-token";
+
+const { WativeCore } = require("wative-core");
+
+const confirmEvmRawTransaction = async (tx_params: any) => {
+    let option_send_evm_raw_transaction_list: any = [
+        new inquirer.Separator("————Tx Detail—————-"),
+        `from: ${tx_params.from}`,
+        `to: ${tx_params.to}`,
+        `nonce: ${tx_params.nonce}`,
+        `gasPrice: ${tx_params.gasPrice}`,
+        `data: ${tx_params.data}`,
+        `value: ${tx_params.value}`,
+        `gas: ${tx_params.gas}`,
+        new inquirer.Separator("——————————————-"),
+        "Send it now",
+    ];
+
+    let selected_send_evm_raw_transaction = await selectSomething(option_send_evm_raw_transaction_list);
+    let option_id = option_send_evm_raw_transaction_list.indexOf(selected_send_evm_raw_transaction);
+
+    if (option_id === 1) {
+        tx_params.from = await inputSomething("from", chainAddressValidator);
+    }
+    if (option_id === 2) {
+        tx_params.to = await inputSomething("to", chainAddressValidator);
+    }
+    if (option_id === 3) {
+        tx_params.nonce = await inputSomething("nonce");
+    }
+    if (option_id === 4) {
+        tx_params.gasPrice = await inputSomething("gasPrice");
+    }
+    if (option_id === 5) {
+        tx_params.data = await editorSomething("data");
+    }
+    if (option_id === 6) {
+        tx_params.value = await inputSomething("value");
+    }
+    if (option_id === 7) {
+        tx_params.gas = await inputSomething("gas");
+    }
+
+    if (option_id === 9) {
+        return tx_params;
+    }
+
+    await confirmEvmRawTransaction(tx_params);
+}
+
+const sendEvmRawTransaction = async (chain_rpc_url: string, chain_symbols: string, account_address: string, wative_core: typeof WativeCore) => {
+    const to = await inputSomething("to", chainAddressValidator);
+    const gasUtil = new GasUtil(chain_rpc_url);
+    const estimateGasPrice = await gasUtil.getGasPrice();
+    const estimateGasPriceEthers = (new BigNumber(estimateGasPrice.toString())).dividedBy(1e9);
+    const _estimateGasPrice = estimateGasPriceEthers.toFixed(4, BigNumber.ROUND_FLOOR);
+    const inputGasPrice = await inputSomething(`Gas price (${_estimateGasPrice}), agree or enter`);
+    let gasPrice = inputGasPrice ? inputGasPrice : _estimateGasPrice;
+    gasPrice = (new BigNumber(gasPrice)).multipliedBy(1e9).toFixed(0);
+
+    let code_result = await getCodeInEvm(to, chain_rpc_url);
+    if (!code_result.status) {
+        console.log(chalk.red(code_result.output));
+        return;
+    }
+
+    let data: string;
+    let value: any;
+    if (code_result.output === "0x") {
+        data = "0x";
+
+        let account_balance_result = await getAccountBalanceInEvm(account_address, chain_rpc_url);
+        if (!account_balance_result.status) {
+            console.log(chalk.red(account_balance_result.output));
+            return;
+        }
+        let account_balance = new BigNumber(account_balance_result.output);
+        let tx_gas_price = new BigNumber(gasPrice);
+        let max_vaule = account_balance.minus(tx_gas_price.multipliedBy(21000)).toFixed(0, BigNumber.ROUND_FLOOR);
+        let total_balance = (new BigNumber(max_vaule)).dividedBy(1e18).toFixed(4, BigNumber.ROUND_FLOOR);
+
+        if (new BigNumber(total_balance) < new BigNumber(0)) {
+            console.log(chalk.red("Not enough balance"));
+            return
+        }
+
+        let option_select_vaule_list: any = [
+            "> Input value",
+            `> Total Balance (${total_balance} ${chain_symbols})`
+        ]
+        let selected_vaule = await selectSomething(option_select_vaule_list);
+        let vaule_id = option_select_vaule_list.indexOf(selected_vaule);
+        if (vaule_id === 0) {
+            let input_value = await inputSomething("value", numberValidator);
+            value = new BigNumber(input_value).multipliedBy(1e18).toFixed(0, BigNumber.ROUND_FLOOR);
+        } else if (vaule_id === 1) {
+            value = max_vaule;
+        }
+
+        if ((new BigNumber(value)).isGreaterThan(new BigNumber(max_vaule))) {
+            console.log(chalk.red("Not enough balance"));
+            return;
+        }
+    } else {
+        data = await editorSomething("data", hexValidator);
+        value = await inputSomething("value", numberValidator);
+    }
+
+    const estimateNonce = await gasUtil.getTransactionCount(account_address);
+    const _nonce = await inputSomething(`Nonce (${estimateNonce}), agree or enter`);
+    const nonce = _nonce ? _nonce : estimateNonce.toString();
+    let txParams: any = {
+        from: account_address,
+        to: to,
+        nonce: nonce,
+        gasPrice: gasPrice,
+        data: data,
+        value: value
+    };
+
+    if (data === '0x') {
+        txParams['gas'] = "21000";
+    } else {
+        let sendGasPrice = txParams.gasPrice;
+        delete txParams.gasPrice;
+        try {
+            txParams['gas'] = (await gasUtil.estimateTxGas(txParams)).toString();
+        } catch (err) {
+            console.log(
+                chalk.red("Error: " + err)
+            );
+            return;
+        }
+
+        txParams.gasPrice = sendGasPrice;
+    }
+    txParams = await confirmEvmRawTransaction(txParams);
+    const signed_message_result = await wative_core.account.signTransaction(
+        account_address,
+        txParams,
+        chain_rpc_url
+    );
+
+    if (!signed_message_result.status) {
+        console.log(chalk.red(signed_message_result.output));
+        return;
+    }
+    let transaction_receipt_result = await wative_core.account.sendSignedTransaction(account_address, signed_message_result.output.rawTransaction, chain_rpc_url);
+    if (!transaction_receipt_result.status) {
+        console.log(chalk.red(transaction_receipt_result.output));
+        return;
+    }
+
+    console.log(chalk.green(`Transaction hash: ${transaction_receipt_result.output.transactionHash}`));
+}
+
+export const sendSolanaRawTransaction = async (chain_rpc_url: string, chain_symbols: string, account_address: string, wative_core: typeof WativeCore) => {
+    const to = await inputSomething("to", chainAddressValidator);
+
+    let transaction = new Transaction().add(SystemProgram.transfer({
+        fromPubkey: new PublicKey(account_address),
+        toPubkey: new PublicKey(to),
+        lamports: 1
+    }));
+    transaction.add(
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 200000
+        })
+    );
+    transaction.add(
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: 1000
+        })
+    );
+
+    const simulate_result = await wative_core.account.simulateTransaction(
+        account_address,
+        chain_rpc_url,
+        transaction
+    );
+    if (!simulate_result.status) {
+        console.log(chalk.red(simulate_result.output));
+        return;
+    }
+
+    if (!simulate_result.output || !simulate_result.output.value || simulate_result.output.value.unitsConsumed === 0 || simulate_result.output.value.err) {
+        console.log(chalk.red("Simulate error"));
+        return;
+    }
+
+    const unitsConsumed = new BigNumber(simulate_result.output.value.unitsConsumed.toString());
+    const prioritization_fee_result = await getPrioritizationFee(chain_rpc_url);
+    if (!prioritization_fee_result.status) {
+        console.log(chalk.red(prioritization_fee_result.output));
+        return;
+    }
+
+    const prioritization_fee = new BigNumber(prioritization_fee_result.output.toString());
+    const used_prioritization_fee = unitsConsumed.multipliedBy(prioritization_fee).toFixed(0, BigNumber.ROUND_CEIL);
+
+    const account_balance_result = await getAccountBalanceInSolana(account_address, chain_rpc_url);
+    if (!account_balance_result.status) {
+        console.log(chalk.red(account_balance_result.output));
+        return;
+    }
+
+    const account_balance = new BigNumber(account_balance_result.output);
+    const max_vaule = account_balance.minus(5000).minus(used_prioritization_fee);
+    let total_balance = (new BigNumber(max_vaule)).dividedBy(1e9).toFixed(4, BigNumber.ROUND_FLOOR);
+    if (new BigNumber(total_balance) < new BigNumber(0)) {
+        console.log(chalk.red("Not enough balance"));
+        return
+    }
+
+    let option_select_vaule_list: any = [
+        "> Input value",
+        `> Total Balance (${total_balance} ${chain_symbols})`
+    ]
+    let selected_vaule = await selectSomething(option_select_vaule_list);
+    let vaule_id = option_select_vaule_list.indexOf(selected_vaule);
+    let transfer_amount: string = "0";
+    if (vaule_id === 0) {
+        let input_value = await inputSomething("value", numberValidator);
+        transfer_amount = new BigNumber(input_value).multipliedBy(1e9).toFixed(0, BigNumber.ROUND_FLOOR);
+        if ((new BigNumber(transfer_amount)).isGreaterThan(new BigNumber(max_vaule))) {
+            console.log(chalk.red("Not enough balance"));
+            return;
+        }
+    } else if (vaule_id === 1) {
+        transfer_amount = max_vaule.toString();
+    }
+
+    let transactions = new Transaction();
+    transactions.add(
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: Math.ceil(Number(unitsConsumed) * 2)
+        })
+    );
+    transactions.add(
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: Number(prioritization_fee)
+        })
+    );
+    transactions.add(SystemProgram.transfer({
+        fromPubkey: new PublicKey(account_address),
+        toPubkey: new PublicKey(to),
+        lamports: Number(transfer_amount)
+    }));
+
+    const signed_message_result = await wative_core.account.signTransaction(
+        account_address,
+        transactions,
+        chain_rpc_url
+    );
+
+    if (!signed_message_result.status) {
+        console.log(chalk.red(signed_message_result.output));
+        return;
+    }
+    let transaction_receipt_result = await wative_core.account.sendSignedTransaction(account_address, signed_message_result.output, chain_rpc_url);
+    if (!transaction_receipt_result.status) {
+        console.log(chalk.red(transaction_receipt_result.output));
+        return;
+    }
+
+    console.log(chalk.green(`Transaction hash: ${transaction_receipt_result.output}`));
+}
+
+const sendEvmTokenTransaction = async (keystore_path: string, chain_rpc_url: string, chain_id: string, account_address: string, wative_core: typeof WativeCore) => {
+    const option_token_address_list = [
+        "> Input token ticker",
+        "> Input token contract address"
+    ];
+    let selected_token_address = await selectSomething(option_token_address_list);
+
+    let token_address: any;
+    let token_decimals: any;
+    switch (selected_token_address) {
+        case "> Input token ticker":
+            let token_name = await inputSomething("token ticker");
+
+            let token_address_list = await getAssetListByTokenName(keystore_path, chain_id, token_name);
+            if (token_address_list.length === 0) {
+                console.log(chalk.red("Token not found"));
+                return;
+            }
+
+            let option_token_address_list: string[] = [];
+            for (let i = 0; i < token_address_list.length; i++) {
+                const token_balance_result = await getTokenBalanceInEvm(account_address, token_address_list[i].address, chain_rpc_url);
+                if (!token_balance_result.status) {
+                    console.log(chalk.red(token_balance_result.output));
+                    return;
+                }
+
+
+                let raw_token_balance = new BigNumber(token_balance_result.output);
+                let token_balance = raw_token_balance.dividedBy(10 ** Number(token_address_list[i].decimals)).toFixed(4, BigNumber.ROUND_FLOOR);
+                if (token_address_list.length === 1) {
+                    option_token_address_list.push(
+                        `> 1. ${token_name} Balance: ${token_balance}`
+                    );
+                    break;
+                }
+
+                option_token_address_list.push(
+                    `> ${i + 1}. ${token_name} Balance: ${token_balance}(${token_address_list[i].address})`
+                );
+
+                option_token_address_list.push(token_address_list[i].address);
+            }
+            let selected_token_address = await selectSomething(option_token_address_list);
+            const token_ticker_info = token_address_list[option_token_address_list.indexOf(selected_token_address)];
+            token_address = token_ticker_info.address;
+            token_decimals = Number(token_ticker_info.decimals);
+            break;
+        case "> Input token contract address":
+            token_address = await inputSomething("token contract address", chainAddressValidator);
+            let token_info: any = await getTokenInfoInEvm(token_address, chain_rpc_url);
+            if (!token_info.status) {
+                console.log(chalk.red(token_info.output));
+                return;
+            }
+            token_decimals = Number(token_info.output.decimals);
+            break;
+    }
+
+    const receipt = await inputSomething("Receipt", chainAddressValidator);
+    const amount = await inputSomething("Amount", numberValidator);
+    const gasUtil = new GasUtil(chain_rpc_url);
+    const estimateGasPrice = await gasUtil.getGasPrice();
+    const estimateGasPriceEthers = (new BigNumber(estimateGasPrice.toString())).dividedBy(1e9);
+    const _estimateGasPrice = estimateGasPriceEthers.toFixed(4, BigNumber.ROUND_FLOOR);
+    const inputGasPrice = await inputSomething(`Gas price (${_estimateGasPrice}), agree or enter`);
+    let gasPrice = inputGasPrice ? inputGasPrice : _estimateGasPrice;
+    gasPrice = (new BigNumber(gasPrice)).multipliedBy(1e9).toFixed(0);
+
+    let transfer_amount = new BigNumber(amount).multipliedBy(Math.pow(10, token_decimals)).toFixed(0);
+    const data = await getTransferTokenData(receipt, transfer_amount, chain_rpc_url);
+
+    const estimateNonce = await gasUtil.getTransactionCount(account_address);
+    const _nonce = await inputSomething(`Nonce (${estimateNonce}), agree or enter`);
+    const nonce = _nonce ? _nonce : estimateNonce.toString();
+    let txParams: any = {
+        from: account_address,
+        to: token_address,
+        nonce: nonce,
+        gasPrice: gasPrice,
+        data: data,
+        value: "0",
+    };
+
+    if (data === '0x') {
+        txParams['gas'] = "21000";
+    } else {
+        let sendGasPrice = txParams.gasPrice;
+        delete txParams.gasPrice;
+        try {
+            txParams['gas'] = (await gasUtil.estimateTxGas(txParams)).toString();
+        } catch (err: any) {
+            console.log(
+                chalk.red("Failed to estimate gas, " + err.message)
+            );
+            return;
+        }
+
+        txParams.gasPrice = sendGasPrice;
+    }
+
+    txParams = await confirmEvmRawTransaction(txParams);
+    const signed_message_result = await wative_core.account.signTransaction(
+        account_address,
+        txParams,
+        chain_rpc_url
+    );
+
+    if (!signed_message_result.status) {
+        console.log(chalk.red(signed_message_result.output));
+        return;
+    }
+    let transaction_receipt_result = await wative_core.account.sendSignedTransaction(account_address, signed_message_result.output.rawTransaction, chain_rpc_url);
+    if (!transaction_receipt_result.status) {
+        console.log(chalk.red(transaction_receipt_result.output));
+        return;
+    }
+
+    console.log(chalk.green(`Transaction hash: ${transaction_receipt_result.output.transactionHash}`));
+}
+
+const sendSolanaTokenTransaction = async (keystore_path: string, chain_rpc_url: string, chain_id: string, account_address: string, wative_core: typeof WativeCore) => {
+    const option_token_address_list = [
+        "> Input token ticker",
+        "> Input token contract address"
+    ];
+    let selected_token_address = await selectSomething(option_token_address_list);
+
+    let token_address: any;
+    let token_decimals: any;
+    switch (selected_token_address) {
+        case "> Input token ticker":
+            let token_name = await inputSomething("token ticker");
+
+            let token_address_list = await getAssetListByTokenName(keystore_path, chain_id, token_name);
+            if (token_address_list.length === 0) {
+                console.log(chalk.red("Token not found"));
+                return;
+            }
+
+            let option_token_address_list: string[] = [];
+            for (let i = 0; i < token_address_list.length; i++) {
+                const token_balance_result = await getTokenBalanceInSolana(account_address, token_address_list[i].address, chain_rpc_url);
+                if (!token_balance_result.status) {
+                    console.log(chalk.red(token_balance_result.output));
+                    return;
+                }
+
+                let raw_token_balance = new BigNumber(token_balance_result.output);
+                let token_balance = raw_token_balance.dividedBy(10 ** Number(token_address_list[i].decimals)).toFixed(4, BigNumber.ROUND_FLOOR);
+                if (token_address_list.length === 1) {
+                    option_token_address_list.push(
+                        `> 1. ${token_name} Balance: ${token_balance}`
+                    );
+                    break;
+                }
+
+                option_token_address_list.push(
+                    `> ${i + 1}. ${token_name} Balance: ${token_balance}(${token_address_list[i].address})`
+                );
+
+                option_token_address_list.push(token_address_list[i].address);
+            }
+            let selected_token_address = await selectSomething(option_token_address_list);
+            const token_ticker_info = token_address_list[option_token_address_list.indexOf(selected_token_address)];
+
+            token_address = token_ticker_info.address;
+            token_decimals = Number(token_ticker_info.decimals);
+            break;
+        case "> Input token contract address":
+            token_address = await inputSomething("token contract address", chainAddressValidator);
+            let token_info: any = await getTokenInfoInSolana(token_address, chain_rpc_url);
+            if (!token_info.status) {
+                console.log(chalk.red(token_info.output));
+                return;
+            }
+            token_decimals = Number(token_info.output.decimals);
+            break;
+    }
+
+    const receipt = await inputSomething("Receipt", chainAddressValidator);
+    const amount = await inputSomething("Amount", numberValidator);
+
+    let transfer_amount = new BigNumber(amount).multipliedBy(Math.pow(10, token_decimals)).toFixed(0);
+    let from_token_account = getAssociatedTokenAddressSync(
+        new PublicKey(token_address),
+        new PublicKey(account_address),
+        true
+    );
+
+    const from_token_account_info_result = await getAccountInfoInSolana(from_token_account.toString(), chain_rpc_url);
+    if (!from_token_account_info_result.status) {
+        console.log(chalk.red(from_token_account_info_result.output));
+        return;
+    }
+
+    if (!from_token_account_info_result.output || from_token_account_info_result.output.owner.toString() === PublicKey.default) {
+        console.log(chalk.red("From token account not found"));
+        return;
+    }
+
+    let receipt_token_account = getAssociatedTokenAddressSync(
+        new PublicKey(token_address),
+        new PublicKey(receipt),
+        false
+    );
+    const receipt_token_account_info_result = await getAccountInfoInSolana(receipt_token_account.toString(), chain_rpc_url);
+    if (!receipt_token_account_info_result.status) {
+        console.log(chalk.red(receipt_token_account_info_result.output));
+        return;
+    }
+
+    let transaction = new Transaction();
+    let transactions = new Transaction();
+    if (!receipt_token_account_info_result.output || receipt_token_account_info_result.output.owner.toString() === PublicKey.default) {
+        transaction.add(
+            createAssociatedTokenAccountInstruction(
+                new PublicKey(account_address),
+                new PublicKey(receipt_token_account),
+                new PublicKey(receipt),
+                new PublicKey(token_address)
+            )
+        );
+        transactions.add(
+            createAssociatedTokenAccountInstruction(
+                new PublicKey(account_address),
+                new PublicKey(receipt_token_account),
+                new PublicKey(receipt),
+                new PublicKey(token_address)
+            )
+        );
+    }
+
+    transaction.add(
+        createTransferInstruction(
+            from_token_account,
+            receipt_token_account,
+            new PublicKey(account_address),
+            Number(transfer_amount)
+        )
+    );
+
+    transaction.add(
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: 200000
+        })
+    );
+    transaction.add(
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: 1000
+        })
+    );
+
+    const simulate_result = await wative_core.account.simulateTransaction(
+        account_address,
+        chain_rpc_url,
+        transaction
+    );
+
+    if (!simulate_result.status) {
+        console.log(chalk.red(simulate_result.output));
+        return;
+    }
+
+    if (!simulate_result.output || !simulate_result.output.value || simulate_result.output.value.unitsConsumed === 0 || simulate_result.output.value.err) {
+        console.log(chalk.red("Simulate error"));
+        return;
+    }
+
+    const unitsConsumed = new BigNumber(simulate_result.output.value.unitsConsumed.toString());
+    const prioritization_fee_result = await getPrioritizationFee(chain_rpc_url);
+    if (!prioritization_fee_result.status) {
+        console.log(chalk.red(prioritization_fee_result.output));
+        return;
+    }
+
+    const prioritization_fee = new BigNumber(prioritization_fee_result.output.toString());
+
+    transactions.add(
+        createTransferInstruction(
+            from_token_account,
+            receipt_token_account,
+            new PublicKey(account_address),
+            Number(transfer_amount)
+        )
+    );
+
+    transactions.add(
+        ComputeBudgetProgram.setComputeUnitLimit({
+            units: Math.ceil(Number(unitsConsumed) * 1.2)
+        })
+    );
+    transactions.add(
+        ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: Number(prioritization_fee)
+        })
+    );
+
+    const signed_message_result = await wative_core.account.signTransaction(
+        account_address,
+        transactions,
+        chain_rpc_url
+    );
+
+    if (!signed_message_result.status) {
+        console.log(chalk.red(signed_message_result.output));
+        return;
+    }
+    let transaction_receipt_result = await wative_core.account.sendSignedTransaction(account_address, signed_message_result.output, chain_rpc_url);
+    if (!transaction_receipt_result.status) {
+        console.log(chalk.red(transaction_receipt_result.output));
+        return;
+    }
+
+    console.log(chalk.green(`Transaction hash: ${transaction_receipt_result.output}`));
+}
+
+
+const excuteTools = async (keystore_path: string, account_label: string, account_address: string, wative_core: typeof WativeCore) => {
+    let default_network = getDefaultNetworkByAddress(keystore_path, account_label, account_address);
+    let network_type = getNetworkTypeByName(keystore_path, default_network);
+    let account_chain_type = getAccountChainType(account_address);
+
+    if (network_type !== account_chain_type) {
+        if (account_chain_type === "evm") {
+            default_network = "Ethereum Mainnet"
+        }
+        if (account_chain_type === "solana") {
+            default_network = "Solana Mainnet"
+        }
+
+        network_type = getNetworkTypeByName(keystore_path, default_network);
+    }
+
+    if (network_type === "evm") {
+        let confirm = await confirmSomething(`Network (${default_network}), want a change?`);
+        if (confirm) {
+            const evm_networks = getEvmNetworks(keystore_path);
+            const selected_network = await selectSomething(evm_networks, "Select a network");
+            default_network = selected_network;
+        }
+    }
+
+    let account_balance = await getAccountBalance(account_address, keystore_path, default_network);
+
+    if (!account_balance.status) {
+        console.log(chalk.red(account_balance.output));
+        return;
+    }
+    const network_info = getNetworkInfoByName(keystore_path, default_network);
+
+    console.log(
+        chalk.green(`  ${network_info.nativeCurrency.symbol} Balance: ${account_balance.output}`)
+    );
+
+    const option_send_tx = [
+        "> Send Raw Tx",
+        "> Send Token",
+        "> Back"
+    ];
+
+    const selected_send_tx = await selectSomething(option_send_tx);
+
+    switch (selected_send_tx) {
+        case "> Send Raw Tx": {
+            if (account_chain_type === "evm") {
+                await sendEvmRawTransaction(
+                    network_info.rpcUrl,
+                    network_info.nativeCurrency.symbol,
+                    account_address,
+                    wative_core
+                );
+            }
+
+            if (account_chain_type === "solana") {
+                await sendSolanaRawTransaction(
+                    network_info.rpcUrl,
+                    network_info.nativeCurrency.symbol,
+                    account_address,
+                    wative_core
+                );
+            }
+            break;
+        }
+        case "> Send Token": {
+            if (account_chain_type === "evm") {
+                await sendEvmTokenTransaction(
+                    keystore_path,
+                    network_info.rpcUrl,
+                    network_info.chainId.toString(),
+                    account_address,
+                    wative_core
+                );
+            }
+
+            if (account_chain_type === "solana") {
+                await sendSolanaTokenTransaction(
+                    keystore_path,
+                    network_info.rpcUrl,
+                    network_info.chainId.toString(),
+                    account_address,
+                    wative_core
+                );
+            }
+            break;
+        }
+        case "> Back": {
+            return;
+        }
+    }
+}
+
+export const selectToolsOptions = async (keystore_path: string, account_label: string, account_address: string, wative_core: typeof WativeCore) => {
+    const tools_options = [
+        "> SendTx",
+        "> SignMessage",
+        "> Back",
+    ];
+
+    const selected_tools_option = await selectSomething(tools_options);
+    switch (selected_tools_option) {
+        case "> SendTx": {
+            await excuteTools(keystore_path, account_label, account_address, wative_core);
+            break;
+        }
+        case "> SignMessage": {
+            const message = await editorSomething("Input the message to sign");
+            const signed_message = wative_core.account.signMessage(account_address, message);
+            if (!signed_message.status) {
+                console.log(chalk.red(signed_message.output));
+                break;
+            }
+            console.log(
+                chalk.green("Signature: " + signed_message.output)
+            );
+            break;
+        }
+        case "> Back": {
+            return;
+        }
+    }
+    await selectToolsOptions(keystore_path, account_label, account_address, wative_core);
+}
+
+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);
+    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) {
+        await showTools(keystore_path, wative_core);
+        return;
+    }
+    await selectToolsOptions(keystore_path, account_label, account_address, wative_core);
+    await showTools(keystore_path, wative_core);
+}