wative-core 1.0.0

package/src/account.ts

@@ -0,0 +1,582 @@
+import * as fs from "fs"
+import * as path from "path"
+import Web3 from 'web3';
+import * as nacl from "tweetnacl";
+import * as bs58 from 'bs58';
+import * as bip39 from 'bip39'
+import { Keypair, Connection } from '@solana/web3.js';
+import { Wallet } from "@coral-xyz/anchor"
+import * as CryptoJS from "crypto-js";
+import { EvmGasUtil, Result, checkAccountLabelsExistence, encryptMessage, decryptMessage, excutePromiseFunction, checkFileExistence, getJsonParams, setJsonParams, hexToUint8Array } from "./utils";
+import { checkMnemonic } from "./mnemonic";
+import { hdkey as evmHdKey } from 'ethereumjs-wallet';
+import { HDKey as solanaHdKey } from 'micro-ed25519-hdkey';
+
+
+const web3 = new Web3(Web3.givenProvider);
+
+export class Account {
+    private setting_path: string;
+    private account_labels: string[];
+    private account_passwords: any = {};
+    private account_ciphertexts: any = {};
+
+    constructor(setting_path: string, account_labels: string[], account_passwords?: string[]) {
+        this.setting_path = setting_path;
+        this.account_labels = account_labels;
+
+        if (account_labels.length === 0) {
+            return;
+        }
+
+        if (account_passwords) {
+            if (account_labels.length !== account_passwords.length) {
+                throw new Error("account_labels should have same length for account_passwords");
+            }
+
+            for (let i = 0; i < account_labels.length; i++) {
+                if (!this.checkPassword(account_labels[i], account_passwords[i].trim())) {
+                    throw new Error("account_passwords is not correct");
+                };
+                this.account_passwords[account_labels[i]] = account_passwords[i].trim();
+            }
+        }
+
+        this.reload();
+    }
+
+    public isLogin(account_label: string) {
+        return account_label in this.account_passwords;
+    }
+
+    public reloadAccount() {
+        this.reload();
+    }
+
+    public getAccountLabel(account_address: string) {
+        account_address = this.getAccountChecksumAddress(account_address);
+
+        if (!this.checkAccountIsExist(account_address)) {
+            return null;
+        }
+
+        return this.account_ciphertexts[account_address].account_labels;
+    }
+
+    public login(account_label: string, password: string) {
+        if (!this.checkPassword(account_label, password)) {
+            return {
+                status: false,
+                output: "Password is not correct"
+            }
+        };
+        this.account_passwords[account_label] = password;
+        this.account_labels.push(account_label);
+        this.reload();
+        return {
+            status: true,
+            output: "Login success"
+        }
+    }
+
+    public checkAccountLabelIsExist(account_label: string) {
+        return checkAccountLabelsExistence(this.setting_path, [account_label]);
+    }
+
+    public checkAccountIsExist(account_address: string) {
+        account_address = this.getAccountChecksumAddress(account_address);
+        if (account_address in this.account_ciphertexts) {
+            return true;
+        }
+
+        this.reload();
+        return account_address in this.account_ciphertexts;
+    }
+
+    public checkPassword(account_label: string, password: string) {
+        let json_data_path = path.join(this.setting_path, `accounts/${account_label}.json`);
+
+        if (!checkFileExistence(json_data_path)) {
+            return false;
+        }
+
+        let account_label_data = getJsonParams(json_data_path);
+
+        let message: any;
+        if (account_label_data.account_type === "PK") {
+            message = {
+                salt: password,
+                ...account_label_data.ciphertexts
+            };
+
+        } else {
+            message = {
+                slat: password,
+                data: account_label_data.pp_ciphertexts
+            };
+        }
+
+        let signature = CryptoJS.SHA256(JSON.stringify(message)).toString();
+
+        return account_label_data.signature === signature;
+    }
+
+    public showPrivateKey(account_address: string) {
+        let account_is_exist = this.checkAccountIsExist(account_address);
+        if (!account_is_exist) {
+            throw new Error("Account is not exist");
+        }
+
+        account_address = this.getAccountChecksumAddress(account_address);
+        let account_data = this.account_ciphertexts[account_address];
+        let password = this.account_passwords[account_data.account_labels];
+        return decryptMessage(account_data.data, password);
+    }
+
+    public getAccountChainType(account_address: string): string {
+        if (account_address.startsWith("0x") && account_address.length === 42) {
+            return "evm";
+        }
+
+        if (/^[A-HJ-NP-Za-km-z1-9]*$/.test(account_address)) {
+            return "solana";
+        }
+        return "unknown";
+    }
+
+    public generatePKAccount(account_label: string, pk: string, password: string, chain_id: string) {
+        if (this.checkAccountLabelIsExist(account_label)) {
+            throw new Error("Account labels already exist");
+        };
+
+        let ciphertext_data = encryptMessage(pk, password);
+        let ciphertexts = {
+            address: this.getAccountAddressByPrivateKey(pk, chain_id),
+            data: ciphertext_data
+        };
+        let message = {
+            salt: password,
+            ...ciphertexts
+        };
+        let signature = CryptoJS.SHA256(JSON.stringify(message)).toString();
+
+        let account = {
+            signature,
+            account_type: "PK",
+            tag: "",
+            ciphertexts
+        }
+
+        this.account_passwords[account_label] = password;
+        this.account_labels.push(account_label);
+        return {
+            status: true,
+            output: account
+        };
+    }
+
+    public generatePPAccount(account_label: string, pp: string, password: string) {
+        if (this.checkAccountLabelIsExist(account_label)) {
+            return {
+                status: false,
+                output: "Account labels already exist"
+            }
+        };
+
+        let pp_ciphertext_data = encryptMessage(pp, password);
+        let message = {
+            slat: password,
+            data: pp_ciphertext_data
+        }
+        let signature = CryptoJS.SHA256(JSON.stringify(message)).toString();
+        let evm_account_data = this.getSubAccount("evm", pp, 0);
+        if (evm_account_data.status === false) {
+            return {
+                status: false,
+                output: evm_account_data.output
+            }
+        }
+
+        let solana_account_data = this.getSubAccount("solana", pp, 0);
+        if (solana_account_data.status === false) {
+            return {
+                status: false,
+                output: solana_account_data.output
+            }
+        }
+
+        let account = {
+            signature,
+            account_type: "PP",
+            pp_ciphertexts: pp_ciphertext_data,
+            tag: "",
+            data: [{
+                ciphertexts: {
+                    evm: {
+                        address: evm_account_data.output.address,
+                        data: encryptMessage(evm_account_data.output.pk, password)
+                    },
+                    solana: {
+                        address: solana_account_data.output.address,
+                        data: encryptMessage(solana_account_data.output.pk, password)
+                    }
+                }
+            }]
+        }
+
+        this.account_passwords[account_label] = password;
+        this.account_labels.push(account_label);
+        return {
+            status: true,
+            output: account
+        };
+    }
+
+    public generateSubAccount(account_label: string, account_index: number) {
+        if (!this.checkAccountLabelIsExist(account_label)) {
+            return {
+                status: false,
+                output: "Account labels not exist"
+            }
+        };
+
+        let json_data_path = path.join(this.setting_path, `accounts/${account_label}.json`);
+        let account_label_data = getJsonParams(json_data_path);
+        let pp_ciphertexts = account_label_data.pp_ciphertexts;
+
+        let pp = decryptMessage(pp_ciphertexts, this.account_passwords[account_label]);
+
+        let evm_account_data = this.getSubAccount("evm", pp, account_index);
+        if (evm_account_data.status === false) {
+            return {
+                status: false,
+                output: evm_account_data.output
+            }
+        }
+
+        let solana_account_data = this.getSubAccount("solana", pp, account_index);
+        if (solana_account_data.status === false) {
+            return {
+                status: false,
+                output: solana_account_data.output
+            }
+        }
+
+        let sub_account = {
+            evm: {
+                address: evm_account_data.output.address,
+                data: encryptMessage(evm_account_data.output.pk, this.account_passwords[account_label])
+            },
+            solana: {
+                address: solana_account_data.output.address,
+                data: encryptMessage(solana_account_data.output.pk, this.account_passwords[account_label])
+            }
+        }
+
+        return {
+            status: true,
+            output: sub_account
+        };
+    }
+
+    public resetPassword(account_label: string, new_password: string) {
+        if (!this.checkAccountLabelIsExist(account_label)) {
+            return {
+                status: false,
+                output: "Account labels not exist"
+            }
+        };
+
+        if (!this.checkPassword(account_label, this.account_passwords[account_label])) {
+            return {
+                status: false,
+                output: "account passwords is not correct"
+            }
+        };
+
+        let json_data_path = path.join(this.setting_path, `accounts/${account_label}.json`);
+        let account_label_data = getJsonParams(json_data_path);
+
+        if (account_label_data.account_type === "PK") {
+            let old_ciphertexts_data = account_label_data.ciphertexts.data;
+            let pk = decryptMessage(old_ciphertexts_data, this.account_passwords[account_label]);
+            account_label_data.ciphertexts.data = encryptMessage(pk, new_password);
+            let message = {
+                salt: new_password,
+                ...account_label_data.ciphertexts
+            };
+            account_label_data.signature = CryptoJS.SHA256(JSON.stringify(message)).toString();
+            setJsonParams(account_label_data, json_data_path);
+            delete this.account_passwords[account_label];
+
+            return {
+                status: true,
+                output: "Password reset successfully"
+            };
+        }
+
+        let pp_ciphertext_data = decryptMessage(account_label_data.pp_ciphertexts, this.account_passwords[account_label]);
+        account_label_data.pp_ciphertexts = encryptMessage(pp_ciphertext_data, new_password);
+        let message = {
+            slat: new_password,
+            data: account_label_data.pp_ciphertexts
+        };
+        account_label_data.signature = CryptoJS.SHA256(JSON.stringify(message)).toString();
+
+        let accounts = account_label_data.data;
+        for (let i = 0; i < accounts.length; i++) {
+            let ppk = decryptMessage(accounts[i].ciphertexts.evm.data, this.account_passwords[account_label]);
+            accounts[i].ciphertexts.evm.data = encryptMessage(ppk, new_password);
+            let ppp = decryptMessage(accounts[i].ciphertexts.solana.data, this.account_passwords[account_label]);
+            accounts[i].ciphertexts.solana.data = encryptMessage(ppp, new_password);
+        }
+
+        setJsonParams(account_label_data, json_data_path);
+        delete this.account_passwords[account_label];
+
+        return {
+            status: true,
+            output: "Password reset successfully"
+        }
+    }
+
+    public signTransaction(account_address: string, transaction: any, rpc_url: string) {
+        account_address = this.getAccountChecksumAddress(account_address);
+        if (this.getAccountChainType(account_address) === "unknown") {
+            return {
+                status: false,
+                output: "Chain type unknown"
+            }
+        }
+        if (this.getAccountChainType(account_address) === "evm") {
+            return this.signEvmTransaction(transaction, rpc_url);
+        }
+
+        return this.signSolanaTransaction(account_address, rpc_url, transaction);
+    }
+
+    public sendSignedTransaction(account_address: string, signed_transaction: any, rpc_url: string) {
+        account_address = this.getAccountChecksumAddress(account_address);
+        if (this.getAccountChainType(account_address) === "unknown") {
+            return {
+                status: false,
+                output: "Chain type unknown"
+            }
+        }
+        if (this.getAccountChainType(account_address) === "evm") {
+            return this.sendEvmTransaction(signed_transaction, rpc_url);
+        }
+        return this.sendSolanaTransaction(signed_transaction, rpc_url);
+    }
+
+    public signMessage(account_address: string, message: string) {
+        account_address = this.getAccountChecksumAddress(account_address);
+        if (this.getAccountChainType(account_address) === "unknown") {
+            return {
+                status: false,
+                output: "Chain type unknown"
+            }
+        }
+        if (this.getAccountChainType(account_address) === "evm") {
+            return {
+                status: true,
+                output: this.signEvmMessage(message, account_address)
+            };
+        }
+        return {
+            status: true,
+            output: this.signSolanaMessage(message, account_address)
+        };
+    }
+
+    public async simulateTransaction(account_address: string, rpc_url: string, transaction: any) {
+        const connection = new Connection(rpc_url);
+        const private_key = this.showPrivateKey(account_address);
+
+        const signer = Keypair.fromSecretKey(bs58.decode(private_key));
+        const simulate_transaction_result = await excutePromiseFunction(connection.simulateTransaction.bind(connection), [transaction, [signer]]);
+        return simulate_transaction_result;
+    }
+
+    private async signEvmTransaction(tx_params: any, rpc_url: string): Promise<Result> {
+        if (!this.account_passwords) {
+            return {
+                status: false,
+                output: "Please set password first"
+            }
+        }
+
+        let account = tx_params.from;
+        if (!tx_params.gas) {
+            let evm_gas_util = new EvmGasUtil(rpc_url);
+            let result = await evm_gas_util.getEvmGasLimit(tx_params, rpc_url);
+            if (!result.status) {
+                return result;
+            }
+            tx_params.gas = result.output;
+        }
+        if (!tx_params.gasPrice) {
+            let evm_gas_util = new EvmGasUtil(rpc_url);
+            let result = await evm_gas_util.getEvmGasPrice();
+            if (!result.status) {
+                return result;
+            }
+            tx_params.gasPrice = result.output;
+        }
+        const private_key = this.showPrivateKey(account);
+        const current_web3 = new Web3(rpc_url);
+        let excute_result = await excutePromiseFunction(current_web3.eth.accounts.signTransaction.bind(current_web3.eth.accounts), [tx_params, private_key]);
+        return excute_result;
+    }
+
+    private async sendEvmTransaction(signed_transaction: any, rpc_url: string) {
+        const current_web3 = new Web3(rpc_url);
+        let excute_result = await excutePromiseFunction(current_web3.eth.sendSignedTransaction.bind(current_web3.eth), [signed_transaction]);
+        return excute_result;
+    }
+
+    private async signSolanaTransaction(account_address: string, rpc_url: string, transaction: any) {
+        const private_key = this.showPrivateKey(account_address);
+        const owner = Keypair.fromSecretKey(bs58.decode(private_key));
+        const wallet = new Wallet(owner);
+        if (!("recentBlockhash" in transaction) || !transaction.recentBlockhash) {
+            const connection = new Connection(rpc_url);
+            let current_blockhash_result = await excutePromiseFunction(connection.getLatestBlockhash.bind(connection), []);
+            if (!current_blockhash_result.status) {
+                return {
+                    status: false,
+                    output: "Failed to get latest blockhash"
+                }
+            }
+            transaction.recentBlockhash = current_blockhash_result.output.blockhash;
+        }
+        transaction.feePayer = wallet.publicKey;
+        let excute_result = await excutePromiseFunction(wallet.signTransaction.bind(wallet), [transaction]);
+        return excute_result;
+    }
+
+    private async sendSolanaTransaction(signed_transaction: any, rpc_url: string) {
+        const connection = new Connection(rpc_url);
+        let excute_result = await excutePromiseFunction(connection.sendRawTransaction.bind(connection), [signed_transaction.serialize()]);
+        return excute_result;
+    }
+
+    private signEvmMessage(message: any, account_address: string) {
+        const private_key = this.showPrivateKey(account_address);
+        const signedData = web3.eth.accounts.sign(message, private_key);
+        return signedData.signature;
+    }
+
+    private signSolanaMessage(message: any, account_address: string) {
+        const private_key = this.showPrivateKey(account_address);
+        const signature = nacl.sign.detached(
+            hexToUint8Array(message),
+            bs58.decode(private_key)
+        );
+        return bs58.encode(signature);
+    }
+
+    private reload() {
+        if (!checkAccountLabelsExistence(this.setting_path, this.account_labels)) {
+            throw new Error("Account labels not exist");
+        }
+
+        let account_labels_size = this.account_labels.length;
+        for (let i = 0; i < account_labels_size; i++) {
+            let account_path = path.join(this.setting_path, `accounts/${this.account_labels[i]}.json`);
+            let account_data: any = JSON.parse(fs.readFileSync(account_path, 'utf8'));
+
+            if (account_data.account_type === "PK") {
+                this.account_ciphertexts[account_data.ciphertexts.address] = {
+                    account_labels: this.account_labels[i],
+                    data: account_data.ciphertexts.data
+                };
+                continue;
+            }
+
+            let account_data_len = account_data.data.length;
+
+            for (let j = 0; j < account_data_len; j++) {
+                this.account_ciphertexts[account_data.data[j].ciphertexts.evm.address] = {
+                    account_labels: this.account_labels[i],
+                    data: account_data.data[j].ciphertexts.evm.data
+                };
+                this.account_ciphertexts[account_data.data[j].ciphertexts.solana.address] = {
+                    account_labels: this.account_labels[i],
+                    data: account_data.data[j].ciphertexts.solana.data
+                };
+            }
+        }
+    }
+
+    private getAccountChecksumAddress(account_address: string) {
+        let account_type = this.getAccountChainType(account_address);
+        if (account_type === "evm") {
+            account_address = web3.utils.toChecksumAddress(account_address);
+        }
+        return account_address;
+    }
+
+    private getAccountAddressByPrivateKey(private_key: string, chain_id: string) {
+        let network_type = this.getNetworkTypeByChainId(chain_id);
+
+        if (network_type === "evm") {
+            return web3.eth.accounts.privateKeyToAccount(private_key).address;
+        }
+
+        return Keypair.fromSecretKey(bs58.decode(private_key)).publicKey.toBase58();
+    }
+
+    private getNetworkTypeByChainId(chain_id: string) {
+        if (chain_id === "901" || chain_id === "902" || chain_id === "903") {
+            return "solana";
+        }
+        return "evm";
+    }
+
+    private getSubAccount(chain_type: string, pp: string, account_index: number): {
+        status: boolean,
+        output: any
+    } {
+        if (!checkMnemonic(pp)) {
+            return {
+                status: false,
+                output: "Please set correct mnemonic"
+            }
+        };
+
+        if (chain_type === "solana") {
+            const seed = bip39.mnemonicToSeedSync(pp);
+            let hdWallet = solanaHdKey.fromMasterSeed(seed);
+            let keypair = Keypair.fromSeed(hdWallet.derive(`m/44'/501'/${account_index}'/0'`).privateKey);
+            return {
+                status: true,
+                output: {
+                    address: keypair.publicKey.toBase58(),
+                    pk: bs58.encode(keypair.secretKey),
+                }
+            }
+        }
+
+        if (chain_type === "evm") {
+            const seed = bip39.mnemonicToSeedSync(pp);
+            const hdWallet = evmHdKey.fromMasterSeed(seed);
+            const hdRoot = hdWallet.derivePath("m/44'/60'/0'/0");
+            const child = hdRoot.deriveChild(account_index);
+            const wallet: any = child.getWallet();
+
+            return {
+                status: true,
+                output: {
+                    address: web3.utils.toChecksumAddress(wallet.getAddressString()),
+                    pk: wallet.getPrivateKeyString()
+                }
+            }
+        }
+
+        return {
+            status: false,
+            output: "Unknown chain type"
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+import { Account } from "./account";
+const packageJson = require('../package.json');
+
+export class WativeCore {
+    public static version = packageJson.version;
+    public account: Account;
+
+    public constructor(setting_path: string, account_labels: string[], account_passwords?: string[]) {
+        this.account = new Account(setting_path, account_labels, account_passwords);
+    }
+}