wative-core 1.2.2 → 2.2.0

package/src/account.ts

@@ -1,749 +0,0 @@
-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, getAccountLabels } 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 = {};
-
-    private disable_address = false;
-    private account_signatures = "";
-
-    constructor(setting_path: string, account_labels: string[], account_passwords?: string[], disable_address?: boolean) {
-        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();
-            }
-        }
-
-        if (disable_address) {
-            this.disable_address = disable_address;
-        }
-
-        this.reload();
-    }
-
-    public isLogin(account_label: string) {
-        return account_label in this.account_passwords;
-    }
-
-    public reloadAccount() {
-        this.reload();
-    }
-
-    public getAccountLabel(account_address: string) {
-        let _account_address: any = null;
-        for (let _address in this.account_ciphertexts) {
-            if (_address.toLocaleLowerCase().includes(account_address.toLocaleLowerCase())) {
-                _account_address = _address;
-            }
-        }
-        if (_account_address === null) {
-            return null;
-        }
-
-        let result = {
-            account_address: _account_address,
-            account_label: this.account_ciphertexts[_account_address].account_label
-        }
-
-        return result;
-    }
-
-    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 getAccounts(account_chain_type: string) {
-        let new_account_signature = this.getAccountSignature();
-        if (new_account_signature !== this.account_signatures) {
-            this.account_signatures = new_account_signature;
-            this.reload();
-        }
-
-        let account_type_list = Object.keys(this.account_ciphertexts);
-        let account_address_list: string[] = [];
-        for (let i = 0; i < account_type_list.length; i++) {
-            if (this.getAccountChainType(account_type_list[i]) === account_chain_type) {
-                account_address_list.push(account_type_list[i]);
-            }
-        }
-        return account_address_list;
-    }
-
-    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.data[0].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_label];
-        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, generate_account_label: boolean) {
-        if (generate_account_label && this.checkAccountLabelIsExist(account_label)) {
-            throw new Error("Account labels already exist");
-        }
-
-        if (!generate_account_label && !this.account_passwords[account_label]) {
-            throw new Error("Password is not correct");
-        }
-
-        if (!generate_account_label) {
-            password = this.account_passwords[account_label];
-        }
-
-        let ciphertext_data = encryptMessage(pk, password);
-
-        let account_address: string;
-        try {
-            account_address = this.getAccountAddressByPrivateKey(pk, chain_id);
-        } catch (err: any) {
-            return {
-                status: false,
-                output: err.message
-            }
-        }
-
-        let ciphertexts = {
-            address: account_address,
-            data: ciphertext_data
-        };
-        let message = {
-            salt: password,
-            ...ciphertexts
-        };
-        let signature = CryptoJS.SHA256(JSON.stringify(message)).toString();
-
-        let account = {
-            signature,
-            account_type: "PK",
-            tag: "",
-            ciphertexts
-        }
-
-        if (!generate_account_label) {
-            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 account_data_list = account_label_data.data;
-
-            for (let i = 0; i < account_data_list.length; i++) {
-                let old_ciphertexts_data = account_data_list[i].ciphertexts.data;
-                let pk = decryptMessage(old_ciphertexts_data, this.account_passwords[account_label]);
-                account_data_list[i].ciphertexts.data = encryptMessage(pk, new_password);
-            }
-
-            let message = {
-                salt: new_password,
-                ...account_label_data.data[0].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);
-        let account_is_exist = this.checkAccountIsExist(account_address);
-        if (!account_is_exist) {
-            return {
-                status: false,
-                output: "Account is not exist"
-            }
-        }
-
-        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 signTransactionOffline(account_address: string, transaction: any, chainId: number) {
-        if (!("chainId" in transaction)) {
-            transaction.chainId = chainId;
-        }
-        const private_key = this.showPrivateKey(account_address);
-        const current_web3 = new Web3(Web3.givenProvider);
-        let excute_result = excutePromiseFunction(current_web3.eth.accounts.signTransaction.bind(current_web3.eth.accounts), [transaction, private_key]);
-        return excute_result;
-    }
-
-    public sendSignedTransaction(account_address: string, signed_transaction: any, rpc_url: string) {
-        account_address = this.getAccountChecksumAddress(account_address);
-        let account_is_exist = this.checkAccountIsExist(account_address);
-        if (!account_is_exist) {
-            return {
-                status: false,
-                output: "Account is not exist"
-            }
-        }
-
-        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);
-        let account_is_exist = this.checkAccountIsExist(account_address);
-        if (!account_is_exist) {
-            return {
-                status: false,
-                output: "Account is not exist"
-            }
-        }
-
-        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);
-    }
-
-    public checkIsDisableAddress(disabled_slots: any, account_index: number) {
-        if (!disabled_slots || !this.disable_address) {
-            return false;
-        }
-        let disabled_slots_len = disabled_slots.length;
-        for (let i = 0; i < disabled_slots_len; i++) {
-            let from = disabled_slots[i].from;
-            let to = disabled_slots[i].to;
-            if (account_index >= from && account_index <= to) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private reload() {
-        this.account_labels = getAccountLabels(this.setting_path, this.account_labels);
-        if (!checkAccountLabelsExistence(this.setting_path, this.account_labels)) {
-            throw new Error("Account labels not exist");
-        }
-
-        let new_account_ciphertexts: any = {};
-        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`);
-            if (!fs.existsSync(account_path)) {
-                continue;
-            }
-
-            let account_data: any = JSON.parse(fs.readFileSync(account_path, 'utf8'));
-            if (account_data.account_type === "PK") {
-                let data = account_data.data;
-                if (!data) {
-                    continue;
-                }
-
-                let data_len = data.length;
-                for (let j = 0; j < data_len; j++) {
-                    new_account_ciphertexts[data[j].ciphertexts.address] = {
-                        account_label: this.account_labels[i],
-                        data: data[j].ciphertexts.data
-                    };
-                }
-                continue;
-            }
-
-            let account_data_len = account_data.data.length;
-            let disabled_slots = account_data.disabled_slots;
-
-            for (let j = 0; j < account_data_len; j++) {
-                if (this.checkIsDisableAddress(disabled_slots, j)) {
-                    continue;
-                }
-
-                new_account_ciphertexts[account_data.data[j].ciphertexts.evm.address] = {
-                    account_label: this.account_labels[i],
-                    data: account_data.data[j].ciphertexts.evm.data
-                };
-                new_account_ciphertexts[account_data.data[j].ciphertexts.solana.address] = {
-                    account_label: this.account_labels[i],
-                    data: account_data.data[j].ciphertexts.solana.data
-                };
-            }
-        }
-
-        this.account_ciphertexts = new_account_ciphertexts;
-    }
-
-    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"
-        }
-    }
-
-    private getAccountSignature() {
-        let account_labels_size = this.account_labels.length;
-
-        // 使用增量哈希计算，避免大数据量问题
-        let hash = CryptoJS.algo.MD5.create();
-
-        for (let i = 0; i < account_labels_size; i++) {
-            let account_path = path.join(this.setting_path, `accounts/${this.account_labels[i]}.json`);
-
-            // 使用流式读取处理大文件
-            const chunkSize = 64 * 1024; // 64KB chunks
-            const fd = fs.openSync(account_path, 'r');
-            const buffer = Buffer.alloc(chunkSize);
-            let position = 0;
-
-            try {
-                while (true) {
-                    const bytesRead = fs.readSync(fd, buffer, 0, chunkSize, position);
-                    if (bytesRead === 0) break;
-
-                    // 更新哈希，只处理实际读取的字节
-                    const chunk = buffer.subarray(0, bytesRead).toString('utf8');
-                    hash.update(chunk);
-                    position += bytesRead;
-                }
-            } finally {
-                fs.closeSync(fd);
-            }
-
-            // 添加分隔符确保不同文件组合产生不同哈希
-            hash.update('|SEPARATOR|');
-        }
-
-        const account_signatures = hash.finalize().toString();
-        return account_signatures;
-    }
-}