wative 1.0.37 → 1.0.39

package/src/ssh/wative_server.ts

@@ -0,0 +1,515 @@
+import * as path from "path";
+import { readFileSync } from 'fs';
+import { utils, Server } from 'ssh2';
+import { timingSafeEqual } from 'crypto';
+import { checkFileExistence } from './utils';
+import { SignMessageParams, SubAccountMessageParams } from './types';
+import * as log4js from "log4js";
+import { ethers } from 'ethers';
+
+const { WativeCore } = require("wative-core");
+const { Connection, PublicKey, VersionedTransaction, VersionedMessage } = require("@solana/web3.js");
+const bs58 = require("bs58");
+const { Keypair, TransactionMessage, ComputeBudgetInstruction, TransactionInstruction, ComputeBudgetProgram } = require("@solana/web3.js");
+const { Wallet } = require("@coral-xyz/anchor");
+const logger = log4js.getLogger();
+logger.level = "info";
+
+export class WativeWielderServer {
+    private wativeCore: any;
+    private _allowedAppIds: Buffer[] = [];
+    private _allowedPubKeys: any[] = [];
+    private _allowedKeystoreIds: string[][] = [];
+
+    private _idRsaPrivatePath: string;
+    private _idRsaPassphrase: string | undefined;
+
+    private _keystoreDirectoryPath: string;
+    private _sessionIdAppIdMap: any = {};
+
+    public constructor(
+        idRsaPrivatePath: string,
+        idRsaPassphrase: string | undefined,
+
+        allowedAppIds: string[],
+        allowedPublicKeyPath: string[],
+        allowedKeystoreIds: string[][],
+
+        keystoreDirectoryPath: string,
+        keystoreIds: string[],
+        passwords: string[],
+    ) {
+        checkFileExistence(idRsaPrivatePath);
+
+        if (
+            allowedAppIds.length === 0 ||
+            allowedPublicKeyPath.length === 0 ||
+            allowedKeystoreIds.length === 0 ||
+            allowedAppIds.length !== allowedPublicKeyPath.length ||
+            allowedAppIds.length !== allowedKeystoreIds.length
+        ) {
+            throw new Error('WativeWielderServer:: constructor: Invaild AllowedApp');
+        }
+
+        for (let i = 0; i < allowedKeystoreIds.length; i++) {
+            for (let j = 0; j < allowedKeystoreIds[i].length; j++) {
+                const keystoreId = allowedKeystoreIds[i][j];
+
+                if (!keystoreIds.includes(keystoreId)) {
+                    throw new Error('WativeWielderServer:: constructor: Invaild AllowedKeystoreIds');
+                }
+            }
+        }
+
+        for (let allowedAppId of allowedAppIds) {
+            this._allowedAppIds.push(
+                Buffer.from(allowedAppId)
+            )
+        }
+
+        for (let _allowedPublicKeyFilePath of allowedPublicKeyPath) {
+            let _parsedKey = utils.parseKey(readFileSync(_allowedPublicKeyFilePath));
+            this._allowedPubKeys.push(_parsedKey)
+        }
+
+        this.wativeCore = new WativeCore(keystoreDirectoryPath, keystoreIds, passwords);
+
+        this._idRsaPrivatePath = idRsaPrivatePath;
+        this._idRsaPassphrase = idRsaPassphrase;
+        this._allowedKeystoreIds = allowedKeystoreIds;
+
+        this._keystoreDirectoryPath = keystoreDirectoryPath;
+    }
+
+    public listen(host: string, port: number) {
+        new Server({
+            hostKeys: [{
+                key: readFileSync(this._idRsaPrivatePath),
+                passphrase: this._idRsaPassphrase
+            }]
+        }, (client: any) => {
+            client.on('authentication', (ctx: any) => {
+                let allowed = true;
+
+                if (this)
+                    if (!this.checkValue(Buffer.from(ctx.username), 'appId')) {
+                        allowed = false;
+                    }
+
+                if (ctx.method === 'publickey' && allowed) {
+                    let allowedAppIndex = this.getBytesIndex(Buffer.from(ctx.username), this._allowedAppIds);
+
+                    let allowedPubKey = this._allowedPubKeys[allowedAppIndex];
+
+                    if (ctx.key.algo !== allowedPubKey.type
+                        || !this.checkValue(ctx.key.data, 'publicKey')
+                        || (ctx.signature && allowedPubKey.verify(ctx.blob, ctx.signature, ctx.hashAlgo) !== true)) {
+                        return ctx.reject();
+                    }
+                } else {
+                    return ctx.reject();
+                }
+
+                if (allowed) {
+                    const sessionID = client._protocol._kex.sessionID.toString('hex');
+                    this._sessionIdAppIdMap[sessionID] = Buffer.from(ctx.username);
+                    ctx.accept();
+                } else {
+                    ctx.reject();
+                }
+            }).on('ready', () => {
+
+                client.on('session', (accept: any, reject: any) => {
+                    const session = accept();
+                    session.once('exec', async (accept: any, reject: any, info: any) => {
+                        const sessionID = client._protocol._kex.sessionID.toString('hex');
+                        const result = await this.web3Request(sessionID, info.command);
+                        const stream = accept();
+                        if (!stream) {
+                            return;
+                        }
+
+                        if (!JSON.stringify(result)) {
+                            stream.write("ssh2 connect error");
+                            stream.exit(0);
+                            stream.end();
+                        } else {
+                            stream.write(JSON.stringify(result));
+                            stream.exit(0);
+                            stream.end();
+                        }
+                    })
+                });
+            }).on('close', () => {
+                logger.info('Client disconnected');
+            }).on('error', (err: any) => {
+                logger.error('err: ', err.message);
+            });
+        }).listen(port, host, function () {
+            logger.info('Listening on port ' + port);
+        })
+    }
+
+    private async web3Request(sessionID: string, message: string) {
+        try {
+            const appId = this._sessionIdAppIdMap[sessionID];
+            const appIndex = this.getBytesIndex(appId, this._allowedAppIds);
+            if (appIndex < 0) {
+                return { status: false, msg: 'app not found' };
+            }
+
+            let messageData = JSON.parse(message);
+            logger.info("sign message: ", message);
+            let _messageMethod: string = messageData.method;
+            let _keystoreId: string = messageData.keystoreId || messageData.params.keystoreId;
+            let _chainId: string = messageData.chainId || messageData.params.chainId;
+
+            const allowedKeystoreIds = this._allowedKeystoreIds[appIndex];
+            if (!allowedKeystoreIds.includes(_keystoreId)) {
+                return { status: false, msg: 'keystore not allowed' };
+            }
+
+            let _data: any;
+            if (_messageMethod === "get_root_account") {
+                _data = this.getRootAccount(_keystoreId, _chainId);
+                // _data = this.wativeCore.account.getRootAccounts(_keystoreId);
+
+            } else if (_messageMethod === "get_sub_account") {
+                let _message: SubAccountMessageParams = messageData.params;
+
+                _data = this.getSubAccount(_keystoreId, _message.chainId, _message?.startIndex, _message?.endIndex);
+            } else if (_messageMethod === "sign") {
+                let _message: SignMessageParams = messageData.params;
+                try {
+                    _data = await this.wativeCore.account.signTransaction(_message.txParams.from, _message.txParams, _message.rpcUrl);
+                } catch (err: any) {
+                    logger.error("sign error: ", err.message);
+                    return { status: false, msg: err.msg };
+                }
+            } else if (_messageMethod === "sign_and_send") {
+                let _message: SignMessageParams = messageData.params;
+                try {
+                    let txHash = await this.wativeCore.account.signAndSendTx(_message.txParams, _message.rpcUrl);
+                    _data = {
+                        transactionHash: txHash
+                    }
+                } catch (err: any) {
+                    return { status: false, msg: err.msg };
+                }
+            } else if (_messageMethod === "solana_sign") {
+                try {
+                    let _message = messageData.params;
+                    _data = await this.signSolanaTransaction(_message.txParams.from, _message.txParams.data, _message.txParams.lookup_tables, _message.rpcUrl, _message.priority_fee);
+                } catch (err: any) {
+                    logger.error("sign error: ", err.message);
+                    return { status: false, msg: err.msg };
+                }
+            } else if (_messageMethod === "solana_send") {
+                try {
+                    let _message = messageData.params;
+                    _data = await this.sendSignedSolanaTransaction(_message.txParams.from, _message.txParams.signature, _message.txParams.data, _message.rpcUrl);
+                } catch (err: any) {
+                    logger.error("sign error: ", err.message);
+                    return { status: false, msg: err.msg };
+                }
+
+            } else if (_messageMethod === "sign_message") {
+                try {
+                    let _message = messageData.params;
+                    logger.debug("sign message: ", _message);
+                    _data = await this.signMessage(_message.account, _message.message);
+                } catch (err: any) {
+                    logger.error("sign error: ", err.message);
+                    return { status: false, msg: err.msg };
+                }
+            } else if (_messageMethod === "sign_typed_data") {
+                try {
+                    let _message = messageData.params;
+                    logger.debug("sign message: ", _message);
+                    _data = await this.signTypedData(_message.account, _message.domain, _message.types_name, _message.types, _message.message)
+                } catch (err: any) {
+                    logger.error("sign error: ", err.message);
+                    return { status: false, msg: err.msg };
+                }
+            } else {
+                return { status: false, msg: 'message method not find' };
+            }
+
+            return { status: true, data: _data };
+        } catch (err: any) {
+            logger.error("sign error: ", err.message);
+            return { status: false, msg: err.msg };
+        }
+    }
+
+    private checkValue(input: Buffer, checkTypes: string) {
+
+        if (checkTypes !== 'appId' && checkTypes !== 'publicKey') {
+            return false;
+        }
+
+        let allowedSize = this._allowedAppIds.length;
+        for (let i = 0; i < allowedSize; i++) {
+            let allowed: Buffer;
+            if (checkTypes === 'appId') {
+                allowed = this._allowedAppIds[i];
+            } else {
+                allowed = this._allowedPubKeys[i].getPublicSSH();
+            }
+
+            const autoReject = (input.length !== allowed.length);
+            if (autoReject) {
+                allowed = input;
+            }
+            const isMatch = timingSafeEqual(input, allowed);
+
+            if (!autoReject && isMatch) {
+                return true;
+            }
+        }
+    }
+
+    private getBytesIndex(buf: Buffer, bufList: Buffer[]) {
+        let bufSize = bufList.length;
+
+        for (let i = 0; i < bufSize; i++) {
+            if (buf.length === bufList[i].length && timingSafeEqual(buf, bufList[i])) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private getRootAccount(keystoreId: string, chainId: string) {
+        const keystore_path = path.resolve(this._keystoreDirectoryPath, `accounts/${keystoreId}.json`);
+        let keystore_info: any = readFileSync(keystore_path);
+        keystore_info = JSON.parse(keystore_info.toString());
+
+        let chainType = this.getChainType(chainId);
+
+        let root_address;
+        if (chainType === "SOLANA") {
+            root_address = keystore_info.data[0].ciphertexts.solana.address;
+        } else {
+            root_address = keystore_info.data[0].ciphertexts.evm.address;
+        }
+        return [{
+            id: 0,
+            address: root_address,
+            children: keystore_info.data.length,
+            type: "M"
+        }];
+    }
+
+
+    private getChainType(chainId: string) {
+        if (chainId === "901" || chainId === "902" || chainId === "903") {
+            return "SOLANA";
+        }
+        return "EVM";
+    }
+
+    private getSubAccount(keystoreId: string, chainId: string, startIndex?: number, endIndex?: number) {
+        const keystore_path = path.resolve(this._keystoreDirectoryPath, `accounts/${keystoreId}.json`);
+        let keystore_info: any = readFileSync(keystore_path);
+        keystore_info = JSON.parse(keystore_info.toString());
+
+        let keystore_info_len = keystore_info.data.length;
+        let _endIndex = keystore_info_len - 1;
+        if (endIndex && endIndex < _endIndex) {
+            _endIndex = endIndex;
+        }
+
+        let _startIndex = 0;
+        if (startIndex && startIndex > 0) {
+            _startIndex = startIndex;
+        }
+
+        if (_startIndex > _endIndex) {
+            return [];
+        }
+
+        let chainType = this.getChainType(chainId);
+        let result: any = [];
+        for (let i = _startIndex; i <= _endIndex; i++) {
+            result.push(keystore_info.data[i].ciphertexts[chainType.toLocaleLowerCase()].address);
+        }
+
+        return result;
+    }
+
+    private async signMessage(account: string, message: string) {
+        let signature = await this.wativeCore.account.signMessage(account, message);
+        console.log(signature);
+        return signature;
+    }
+
+    private async signTypedData(account: string, message_domain: string, message_types_name: string, message_types: string, message_data: string) {
+        console.log("111");
+        let domain = JSON.parse(message_domain);
+        let types = JSON.parse(message_types);
+        let data = JSON.parse(message_data);
+
+        console.log(domain);
+        console.log(types);
+        console.log(data);
+        let pkl = this.wativeCore.account.showPrivateKey(account);
+        let wallet: any = new ethers.Wallet(pkl);
+        let signature = await wallet.signTypedData(domain, {
+            [message_types_name]: types
+        }, data);
+
+        console.log(signature);
+        return {
+            "status": true,
+            "output": signature
+        };
+    }
+
+    private async signSolanaTransaction(from: string, data: string, lookup_table_addresses: any, rpc_url: string, prioritization_fee: any) {
+        let connection = new Connection(rpc_url);
+
+        let lookup_table_list: any = [];
+        if (lookup_table_addresses) {
+            for (let lookup_table_address of lookup_table_addresses) {
+                let lookup_table = (await connection.getAddressLookupTable(new PublicKey(lookup_table_address))).value;
+                lookup_table_list.push(lookup_table);
+                await sleep(1000);
+            }
+        }
+
+        let versionedMessage = VersionedMessage.deserialize(Uint8Array.from(Buffer.from(data, "hex")));
+        let decompiled_transaction_message = TransactionMessage.decompile(versionedMessage);
+        decompiled_transaction_message.instructions.push(
+            ComputeBudgetProgram.setComputeUnitLimit({
+                units: 2000000
+            })
+        );
+        decompiled_transaction_message.instructions.push(
+            ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: 1000
+            })
+        );
+
+        versionedMessage = decompiled_transaction_message.compileToV0Message(lookup_table_list);
+        versionedMessage.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+
+        await sleep(3000);
+        let versionedTransaction = new VersionedTransaction(versionedMessage);
+        let pkl = this.wativeCore.account.showPrivateKey(from);
+        const owner = Keypair.fromSecretKey(new Uint8Array(bs58.decode(pkl)));
+        const wallet = new Wallet(owner);
+
+        let simulate_transaction_result = await connection.simulateTransaction(versionedTransaction);
+        if (!simulate_transaction_result || !simulate_transaction_result.value || simulate_transaction_result.value.unitsConsumed === 0 || simulate_transaction_result.value.err) {
+            return {
+                status: false,
+                output: simulate_transaction_result.value.err
+            }
+        }
+
+        let message_instruction_length = decompiled_transaction_message.instructions.length;
+        let units_consumed = Math.trunc(simulate_transaction_result.value.unitsConsumed * 1.2);
+        decompiled_transaction_message.instructions[message_instruction_length - 2] = ComputeBudgetProgram.setComputeUnitLimit({
+            units: units_consumed
+        });
+
+        if (!prioritization_fee || prioritization_fee == "null") {
+            try {
+                prioritization_fee = await this.getPrioritizationFee(rpc_url);
+            } catch (err) {
+                prioritization_fee = 200000;
+            }
+        }
+
+        if (prioritization_fee < 10000) {
+            prioritization_fee = 10000;
+        }
+
+        if (prioritization_fee > 500000) {
+            prioritization_fee = 500000;
+        }
+
+        decompiled_transaction_message.instructions[message_instruction_length - 1] = ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: prioritization_fee
+        })
+
+        versionedMessage = decompiled_transaction_message.compileToV0Message(lookup_table_list);
+        await sleep(1000);
+        versionedMessage.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+        versionedTransaction = new VersionedTransaction(versionedMessage);
+
+        versionedTransaction.feePayer = wallet.publicKey;
+        await sleep(3000);
+        let signedTransaction = await this.wativeCore.account.signTransaction(from, versionedTransaction, rpc_url);
+        let new_versioned_transaction = new VersionedTransaction(signedTransaction.output.message, signedTransaction.output.signatures);
+        let new_message = new_versioned_transaction.message.serialize();
+        new_message = Buffer.from(new_message).toString("hex");
+
+        let tx_hash = bs58.encode(signedTransaction.output.signatures[0]);
+        return {
+            status: true,
+            output: {
+                transactionHash: tx_hash,
+                message: new_message,
+                compute_units: simulate_transaction_result.value.unitsConsumed.toString()
+            }
+        }
+    }
+
+    private async sendSignedSolanaTransaction(from: string, signature: string, data: string, rpc_url: string) {
+        let signatures = [
+            bs58.decode(signature)
+        ];
+
+        let versionedMessage = VersionedMessage.deserialize(Uint8Array.from(Buffer.from(data, "hex")));
+        let versionedTransaction = new VersionedTransaction(versionedMessage, signatures);
+
+        return await this.wativeCore.account.sendSignedTransaction(from, versionedTransaction, rpc_url);
+    }
+
+    private async getPrioritizationFee(rpc_url: string) {
+        let program_id = new PublicKey("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4");
+        const connection = new Connection(rpc_url, "confirmed");
+        let signatures_info: any = await connection.getSignaturesForAddress(program_id, { limit: 5 });
+        await sleep(2000);
+
+        let signatures: any = [];
+        for (let i = 0; i < signatures_info.length; i++) {
+            signatures.push(signatures_info[i].signature);
+        }
+        let transaction: any = await connection.getParsedTransactions(signatures, {
+            maxSupportedTransactionVersion: 0,
+        });
+
+        let total_prioritization_fee = 0;
+        for (let i = 0; i < transaction.length; i++) {
+            let instructions_list = transaction[i].transaction.message.instructions;
+            for (let j = 0; j < instructions_list.length; j++) {
+                if (instructions_list[j].programId.toBase58() === "ComputeBudget111111111111111111111111111111") {
+                    let data = instructions_list[j].data;
+                    try {
+                        let instruction = new TransactionInstruction({
+                            keys: [],
+                            programId: new PublicKey("ComputeBudget111111111111111111111111111111"),
+                            data: Buffer.from(bs58.decode(data))
+                        });
+
+                        let { microLamports } = ComputeBudgetInstruction.decodeSetComputeUnitPrice(instruction)
+                        total_prioritization_fee += Number(microLamports);
+                        continue;
+                    } catch (error) { }
+                }
+            }
+        }
+
+        return Math.ceil(total_prioritization_fee / 5)
+    }
+}
+
+export const sleep = (ms: number) => {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export default WativeWielderServer;

package/src/tools.ts

@@ -83,6 +83,13 @@ const sendEvmRawTransaction = async (chain_id: string, chain_rpc_url: string, ch
         return;
     }
 
+    let transfer_gas_limit: string;
+    if (chain_id === "42161" || chain_id === "421614") {
+        transfer_gas_limit = "1700000";
+    } else {
+        transfer_gas_limit = "21000";
+    }
+
     let data: string;
     let value: any;
     if (code_result.output === "0x") {
@@ -95,7 +102,7 @@ const sendEvmRawTransaction = async (chain_id: string, chain_rpc_url: string, ch
         }
         let account_balance = new BigNumber(account_balance_result.output);
         let tx_gas_price = new BigNumber(gasPrice);
-        let max_value = account_balance.minus(tx_gas_price.multipliedBy(21000)).toFixed(0, BigNumber.ROUND_FLOOR);
+        let max_value = account_balance.minus(tx_gas_price.multipliedBy(Number(transfer_gas_limit))).toFixed(0, BigNumber.ROUND_FLOOR);
         let total_balance = (new BigNumber(max_value)).dividedBy(1e18).toFixed(4, BigNumber.ROUND_FLOOR);
 
         if (new BigNumber(total_balance) < new BigNumber(0)) {
@@ -127,7 +134,7 @@ const sendEvmRawTransaction = async (chain_id: string, chain_rpc_url: string, ch
     };
 
     if (data === '0x') {
-        txParams['gas'] = "21000";
+        txParams['gas'] = transfer_gas_limit;
     } else {
         let sendGasPrice = txParams.gasPrice;
         delete txParams.gasPrice;
@@ -421,7 +428,11 @@ const sendEvmTokenTransaction = async (keystore_path: string, chain_rpc_url: str
     };
 
     if (data === '0x') {
-        txParams['gas'] = "21000";
+        if (chain_id === "42161" || chain_id === "421614") {
+            txParams['gas'] = "1700000";
+        } else {
+            txParams['gas'] = "21000";
+        }
     } else {
         let sendGasPrice = txParams.gasPrice;
         delete txParams.gasPrice;

package/src/utils.ts

@@ -428,6 +428,20 @@ const passwordValidator = function (value: string) {
     }
 };
 
+export const inputMaskedPassword = async (text: string, validate_func?: Function) => {
+    const questions = [
+        {
+            name: 'inputText',
+            type: 'password',
+            mask: '#',
+            message: `${text}:`,
+            validate: validate_func
+        },
+    ]
+    const { inputText } = await inquirer.prompt(questions)
+    return inputText.trim().toString()
+}
+
 export const inputPasswordWithoutValidator = async (text: string) => {
     const questions = [
         {