wative 1.2.7 → 1.2.10

package/src/ssh/types.ts

@@ -1,50 +0,0 @@
-type SubAccountMessageParams = {
-    rootAccount: string,
-    chainId: string,
-    startIndex?: number,
-    endIndex?: number
-}
-
-type SignMessageParams = {
-    txParams: any,
-    rpcUrl: string
-}
-
-type SSHServiceConfig = {
-    name: string;
-    description?: string;
-    ssh: {
-        listen: string;
-        port: number;
-        log: {
-            size: number;
-            backups: number;
-        };
-    };
-    keystore: {
-        path: string;
-        allowed_keystores: string[];
-    };
-    clients: {
-        name: string;
-        public_key_path: string;
-        allowed_keystores: string[];
-    }[];
-    server_keys: {
-        private_key_path: string;
-        passphrase: string;
-    };
-}
-
-type ServiceInstance = {
-    config: SSHServiceConfig;
-    passwords: { [keystoreId: string]: string };
-    server: any;
-}
-
-export {
-    SubAccountMessageParams,
-    SignMessageParams,
-    SSHServiceConfig,
-    ServiceInstance
-}

package/src/ssh/utils.ts

@@ -1,89 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ini from 'ini';
-import { execSync } from 'child_process';
-import { getNetworkInfo } from '../account';
-import { batchGetKeystoreSlugByAccountName } from '../utils';
-
-
-/**
- * Check the existence of the file
- * @filePath 
-*/
-const checkFileExistence = (filePath: string) => {
-    filePath = filePath.trim()
-    let isExists = fs.existsSync(filePath)
-    if (!isExists) {
-        throw new Error('File not exists')
-    }
-}
-
-function sleep(time = 0) {
-    return new Promise((resolve, reject) => {
-        setTimeout(() => {
-            resolve(true)
-        }, time)
-    })
-}
-
-const createSSHKeyPair = async () => {
-    const configDir = "/etc/wative";
-    const idRsaServerPublicKeyPath = path.join(configDir, 'id_rsa_server.pub');
-    const idRsaServerPrivateKeyPath = path.join(configDir, 'id_rsa_server');
-
-    if (!fs.existsSync(idRsaServerPublicKeyPath) || !fs.existsSync(idRsaServerPrivateKeyPath)) {
-        console.log('Generating SSH key pair...');
-        execSync(`ssh-keygen -t rsa -f ${idRsaServerPrivateKeyPath} -N 'wative_server'`, { stdio: 'inherit' });
-    }
-
-    const idRsaDetakePublicKeyPath = path.join(configDir, 'id_rsa_detake.pub');
-    const idRsaDetakePrivateKeyPath = path.join(configDir, 'id_rsa_detake');
-
-    if (!fs.existsSync(idRsaDetakePublicKeyPath) || !fs.existsSync(idRsaDetakePrivateKeyPath)) {
-        console.log('Generating SSH key pair...');
-        execSync(`ssh-keygen -t rsa -f ${idRsaDetakePrivateKeyPath} -N 'wative_detake'`, { stdio: 'inherit' });
-    }
-}
-
-
-const getAndGenerateConfig = async (keystorePath: string) => {
-    const configDir = "/etc/wative";
-    if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir);
-    }
-
-    await createSSHKeyPair();
-    const configPath = path.join(configDir, 'config.ini');
-    if (!fs.existsSync(configPath)) {
-        const networks = getNetworkInfo(keystorePath);
-        const account_name_list = networks.accounts;
-        const keystore_slug_list = batchGetKeystoreSlugByAccountName(account_name_list);
-        const keystore: any = {
-            path: keystorePath,
-            allowed_keystores: keystore_slug_list,
-        }
-        const ssh: any = {
-            listen: '127.0.0.1',
-            port: 5678,
-            log: {
-                size: 10485760,
-                backups: 3
-            }
-        }
-        const config = {
-            keystore,
-            ssh,
-        }
-        let text = ini.stringify(config);
-        fs.writeFileSync(configPath, text);
-    }
-
-    const config = ini.parse(fs.readFileSync(configPath, 'utf-8'));
-    return config;
-}
-
-export {
-    checkFileExistence,
-    sleep,
-    getAndGenerateConfig,
-}

package/src/ssh/wative_server.ts

@@ -1,534 +0,0 @@
-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");
-log4js.configure({
-    appenders: {
-        file: {
-            type: 'file',
-            filename: process.env.HOME + '/.wative/logs/wative.log',
-            maxLogSize: 10485760,
-            backups: 3,
-            compress: true,
-            keepFileExt: true,
-            layout: {
-                type: 'pattern',
-                pattern: '%d{yyyy-MM-dd hh:mm:ss.SSS} [%p] %c - %m'
-            },
-            encoding: 'utf-8'
-        },
-        console: { type: 'console' }
-    },
-    categories: {
-        default: { appenders: ['file', 'console'], level: 'info' }
-    }
-})
-
-const logger = log4js.getLogger("file");
-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) {
-        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;