wative 1.0.1

package/src/tx_gas_utils.ts

@@ -0,0 +1,119 @@
+const {
+    BN
+} = require('bn.js');
+const {
+    stripHexPrefix
+} = require('ethereumjs-util');
+const { BigNumber } = require('bignumber.js');
+import Web3 from 'web3';
+
+function hexToBn(inputHex: typeof BN) {
+    return new BN(stripHexPrefix(inputHex.toString('hex')), 16);
+}
+
+const addHexPrefix = (str: string) => {
+    if (str.match(/^-?0x/u)) {
+        return str;
+    }
+
+    if (str.match(/^-?0X/u)) {
+        return str.replace('0X', '0x');
+    }
+
+    if (str.startsWith('-')) {
+        return str.replace('-', '-0x');
+    }
+
+    return `0x${str}`;
+};
+
+function BnMultiplyByFraction(targetBN: typeof BN, numerator: number, denominator: number) {
+    const numBN = new BN(numerator);
+    const denomBN = new BN(denominator);
+    return targetBN.mul(numBN).div(denomBN);
+}
+
+function bnToHex(inputBn: typeof BN) {
+    return addHexPrefix(inputBn.toString(16));
+}
+
+export class GasUtil {
+    query: any;
+    constructor(rpcUrl: string) {
+        this.query = (new Web3(Web3.givenProvider || rpcUrl)).eth;
+    }
+
+    async analyzeGasUsage(txParams: any) {
+        const block = await this.query.getBlock('latest', false);
+        const blockGasLimitBN = hexToBn(block.gasLimit);
+        const saferGasLimitBN = BnMultiplyByFraction(blockGasLimitBN, 19, 20);
+        let estimatedGasHex = bnToHex(saferGasLimitBN);
+        let simulationFails;
+        try {
+            estimatedGasHex = await this.estimateTxGas(txParams);
+        } catch (error: any) {
+            simulationFails = {
+                reason: error.message,
+                errorKey: error.errorKey,
+                debug: {
+                    blockNumber: block.number,
+                    blockGasLimit: block.gasLimit
+                },
+            };
+        }
+
+        return {
+            blockGasLimit: block.gasLimit,
+            estimatedGasHex,
+            simulationFails
+        };
+    }
+
+    async estimateTxGas(txParams: any) {
+        let gasLimit = await this.query.estimateGas(txParams);
+        gasLimit = (new BigNumber(gasLimit.toString())).multipliedBy(1.3).toFixed(0);
+        return gasLimit;
+    }
+
+    addGasBuffer(initialGasLimitHex: string, blockGasLimitHex: string, multiplier = 1.3) {
+        const initialGasLimitBn = hexToBn(initialGasLimitHex);
+        const blockGasLimitBn = hexToBn(blockGasLimitHex);
+        const upperGasLimitBn = blockGasLimitBn.muln(0.9);
+        const bufferedGasLimitBn = initialGasLimitBn.muln(multiplier);
+        if (initialGasLimitBn.gt(upperGasLimitBn)) {
+            return bnToHex(initialGasLimitBn);
+        }
+        if (bufferedGasLimitBn.lt(upperGasLimitBn)) {
+            return bnToHex(bufferedGasLimitBn);
+        }
+        return bnToHex(upperGasLimitBn);
+    }
+
+    async getBufferedGasLimit(txParams: any, multiplier: number) {
+        const {
+            blockGasLimit,
+            estimatedGasHex,
+            simulationFails,
+        } = await this.analyzeGasUsage(txParams);
+        const gasLimit = this.addGasBuffer(
+            addHexPrefix(estimatedGasHex),
+            blockGasLimit,
+            multiplier,
+        );
+
+        return {
+            gasLimit,
+            simulationFails
+        };
+    }
+
+    async getGasPrice() {
+        const gasPrice = await this.query.getGasPrice();
+        return gasPrice;
+    }
+
+    async getTransactionCount(account: string) {
+        const nonce = await this.query.getTransactionCount(account);
+        return nonce;
+    }
+}

package/src/utils.ts

@@ -0,0 +1,381 @@
+/* tslint:disable no-var-requires */
+const chalk = require('chalk')
+import * as figlet from 'figlet'
+import inquirer from 'inquirer'
+import * as fs from 'fs'
+
+import { getChainIdByEvm } from "./web3";
+import { MNEMONIC_WORDS } from './config';
+import { getChainType } from './chain';
+
+const USER_HOME: any = process.env.HOME || process.env.USERPROFILE
+const BASE_PATH = `${USER_HOME}/.wative`
+
+export const inputSomething = async (text: string, validate_func?: Function) => {
+    const questions = [
+        {
+            name: 'inputText',
+            type: 'input',
+            message: `${text}:`,
+            validate: validate_func
+        },
+    ]
+    const { inputText } = await inquirer.prompt(questions)
+    return inputText.trim().toString()
+}
+
+export const tagValidator = (tag: string) => {
+    if (tag === "") {
+        return true;
+    }
+
+    tag = tag.replace(/\s+/g, " ").trim();
+
+    if (tag.length > 10) {
+        return "Tag length should be less than 10";
+    }
+
+    if (/^[0-9a-zA-Z\s]*$/g.test(tag) === false) {
+        return "Tag should be alphanumeric";
+    }
+
+    return true;
+}
+
+export const numberValidator = (value: string) => {
+    if (isNaN(Number(value))) {
+        return "Value should be a number";
+    }
+    return true;
+}
+
+export const passphraseValidator = (passphrase: string) => {
+    passphrase = passphrase.replace(/\s+/g, " ");
+    const mnemonic_word_list = passphrase.split(/\s+/g);
+    if (mnemonic_word_list.length === 12) {
+        return "Passphrase should be equal to 12 words";
+    }
+    for (let i = 0; i < mnemonic_word_list.length; i++) {
+        if (MNEMONIC_WORDS.includes(mnemonic_word_list[i]) === false) {
+            return "Passphrase word should be valid";
+        }
+    }
+    return true;
+}
+
+export const expandAmountValidator = (amount: string) => {
+    let amount_number = Number(amount);
+
+    if (isNaN(amount_number)) {
+        return "Amount should be a number";
+    }
+
+    if (amount_number > 2000) {
+        return "Amount should be less than 2000";
+    }
+
+    return true;
+}
+
+export const lastAccountNoValidator = (last_account_no: string) => {
+    let last_account_no_number = Number(last_account_no);
+
+    if (isNaN(last_account_no_number)) {
+        return "Last account no should be a number";
+    }
+    return true;
+}
+
+export const chainAddressValidator = (chain_address: string) => {
+    let account_chain_type = getAccountChainType(chain_address);
+
+    if (account_chain_type == "unknown") {
+        return "Address should be valid";
+    }
+
+    return true;
+}
+
+export const selectSomething = async (options: any[], message?: string, _default?: any) => {
+    const questions = [
+        {
+            type: 'list',
+            name: 'inputText',
+            message: message || 'Choose an option',
+            default: _default,
+            choices: options,
+            pageSize: 30,
+            filter: (val: string) => {
+                return val;
+            },
+        },
+    ]
+    const { inputText } = await inquirer.prompt(questions)
+    return inputText.toString()
+}
+
+export const showIntroduction = () => {
+    console.log(
+        chalk.green(
+            figlet.textSync('Wative', {
+                font: 'Ghost',
+                horizontalLayout: 'default',
+                verticalLayout: 'default',
+            })
+        )
+    )
+}
+
+export const getKeystorePath = async () => {
+    let keystore_path: string = await inputSomething(`Keystore storage located in (default: ${BASE_PATH})`);
+    if (!keystore_path) {
+        keystore_path = BASE_PATH
+    }
+
+    keystore_path = keystore_path.trim();
+    keystore_path = keystore_path.replace("~", USER_HOME);
+
+    if (!fs.existsSync(keystore_path)) {
+        fs.mkdirSync(keystore_path, { recursive: true });
+    }
+    return keystore_path;
+}
+
+export const getChainId = async (text: string, update: boolean = false) => {
+    for (let i = 0; i < 5; i++) {
+        const chain_id = await inputSomething(text);
+        if (chain_id === "" && update) {
+            return null
+        }
+
+        let reg = /^[0-9]*$/g;
+        if (reg.test(chain_id)) {
+            return chain_id;
+        }
+    }
+
+    return null;
+}
+
+export const getRpcUrl = async (chain_id: string, text: string, update: boolean = false) => {
+    for (let i = 0; i < 5; i++) {
+        let rpc_url = await inputSomething(text);
+        try {
+            if (rpc_url === "" && update) {
+                return null
+            }
+
+            if (getChainType(chain_id) === "solana") {
+                return rpc_url;
+            }
+            const new_chain_id = await getChainIdByEvm(rpc_url);
+            if (!new_chain_id.status) {
+                console.log(chalk.red(new_chain_id.output));
+                continue;
+            }
+            if (new_chain_id.output.toString() === chain_id.toString()) {
+                return rpc_url;
+            } else {
+                console.log(chalk.red("Rpc url not match chain id"));
+            }
+        } catch (err: any) {
+            console.log(chalk.red(err.message));
+        }
+    }
+
+    return null;
+}
+
+export const getMulticallAddress = async (text: string) => {
+    for (let i = 0; i < 5; i++) {
+        let multicall_address = await inputSomething(text);
+        if (multicall_address === "") {
+            return null
+        }
+
+        if (multicall_address !== "" && multicall_address.length !== 42) {
+            console.log(chalk.red("Multicall address length must be 42"));
+            continue;
+        }
+    }
+
+    return null;
+}
+
+export const getSymbol = async (text: string) => {
+    let reg = /^[A-Za-z][0-9a-zA-Z]*$/g;
+    for (let i = 0; i < 5; i++) {
+        let symbol = await inputSomething(text);
+        if (symbol === "") {
+            return null
+        }
+        if (reg.test(symbol)) {
+            return symbol
+        }
+    }
+    return null;
+}
+
+export const getColor = async (text: string) => {
+    let reg = /^#[0-9A_F]{6}$/g;
+    for (let i = 0; i < 5; i++) {
+        let color = await inputSomething(text);
+        if (color === "") {
+            return null
+        }
+
+        if (reg.test(color)) {
+            return color
+        }
+    }
+    return null;
+}
+
+export const getAccountLabel = async (text: string, account_label_list: string[]) => {
+    let reg = /^[a-zA-Z0-9]{2,20}$/g;
+    for (let i = 0; i < 5; i++) {
+        let account_label = await inputSomething(text);
+        account_label = account_label.trim();
+        if (reg.test(account_label)) {
+            if (account_label_list.includes(account_label)) {
+                console.log(chalk.red("Account label already exists"));
+                continue;
+            } else {
+                return account_label.toLocaleLowerCase();
+            }
+        }
+    }
+    return null;
+}
+
+const passwordValidator = function (value: string) {
+    let validatorInfo = "Password must contain at least: \n";
+    let myReg;
+    let access = true;
+    let tabspace = "  ";
+    let green_string = chalk.green('\u2714');
+    let red_string = chalk.red('\u2716');
+
+    if (value.length >= 8) {
+        validatorInfo += tabspace + green_string + " 8 characters\n";
+    } else {
+        validatorInfo += tabspace + red_string + " 8 characters\n";
+        access = false;
+    }
+
+    myReg = /[0-9]/;
+    if (myReg.test(value)) {
+        validatorInfo += tabspace + green_string + " One numerical character\n";
+    } else {
+        validatorInfo += tabspace + red_string + " One numerical character\n";
+        access = false;
+    }
+
+    myReg = /[A-Z]/;
+    if (myReg.test(value)) {
+        validatorInfo += tabspace + green_string + " One uppercase letter\n";
+    } else {
+        validatorInfo += tabspace + red_string + " One uppercase letter\n";
+        access = false;
+    }
+
+    myReg = /[!@#$%]/;
+    if (myReg.test(value)) {
+        validatorInfo += tabspace + green_string + " One sepcial character (i.e. !@#$%)\n";
+    } else {
+        validatorInfo += tabspace + red_string + " One sepcial character (i.e. !@#$%)\n";
+        access = false;
+    }
+
+    if (access) {
+        return true;
+    } else {
+        return validatorInfo;
+    }
+};
+
+export const inputPassword = async (text: string) => {
+    const questions = [
+        {
+            name: 'password',
+            type: 'password',
+            mask: '#',
+            message: `${text}:`,
+            validate: passwordValidator
+        }
+    ]
+    const { password } = await inquirer.prompt(questions);
+    return password;
+}
+
+export const confirmSomething = async (text: string) => {
+    const questions = [
+        {
+            name: 'confirm',
+            type: 'confirm',
+            message: `${text}`,
+        }
+    ]
+    const { confirm } = await inquirer.prompt(questions);
+    return confirm;
+}
+
+export const editorSomething = async (text: string, validate_func?: Function) => {
+    const questions = [
+        {
+            name: 'editor',
+            type: 'editor',
+            message: `${text}`,
+            validate: validate_func
+        }
+    ]
+    const { editor } = await inquirer.prompt(questions);
+    return editor.trim().toString()
+};
+
+export const hexValidator = function (value: string) {
+    let reg = /^0x[0-9a-fA-F]*$/g;
+    if (reg.test(value)) {
+        return true;
+    } else {
+        return false;
+    }
+};
+
+export interface Result {
+    status: boolean;
+    output: any;
+}
+
+export const excutePromiseFunction = async (fn: Function, params: any): Promise<Result> => {
+    let result: Result;
+    try {
+        let output = await fn(...params);
+        result = {
+            status: true,
+            output
+        };
+    } catch (err: any) {
+        result = {
+            status: false,
+            output: err.toString()
+        }
+    }
+    return result;
+}
+
+export const getAccountChainType = (account_address: string) => {
+    if (account_address.startsWith("0x") && account_address.length === 42) {
+        return "evm";
+    }
+
+    if (/^[A-HJ-NP-Za-km-z1-9]*$/.test(account_address) && account_address.length <= 44 && account_address.length >= 32) {
+        return "solana";
+    }
+    return "unknown";
+}
+
+export const checkFileExistence = (file_path: string): boolean => {
+    file_path = file_path.trim()
+    return fs.existsSync(file_path);
+}