jcc_wallet 4.0.1 → 4.0.3

package/lib/constant.js

@@ -15,4 +15,3 @@ const SECRET_IS_INVALID = `secret is invalid`;
 exports.SECRET_IS_INVALID = SECRET_IS_INVALID;
 const ADDRESS_IS_EXISTENT = `address is existent`;
 exports.ADDRESS_IS_EXISTENT = ADDRESS_IS_EXISTENT;
-//# sourceMappingURL=constant.js.map

package/lib/eccrypto.d.ts

@@ -0,0 +1,12 @@
+/**
+ * forked from https://github.com/bitchan/eccrypto/blob/master/index.js
+ *
+ * rewrite curves & hashes
+ */
+export declare const encrypt: (publicKeyTo: any, msg: any, opts?: any) => Promise<{
+    iv: any;
+    ephemPublicKey: any;
+    ciphertext: Uint8Array;
+    mac: Buffer;
+}>;
+export declare const decrypt: (privateKey: any, opts: any) => Promise<Uint8Array>;

package/lib/eccrypto.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * forked from https://github.com/bitchan/eccrypto/blob/master/index.js
+ *
+ * rewrite curves & hashes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = void 0;
+const EC_GROUP_ORDER = Buffer.from("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", "hex");
+const ZERO32 = Buffer.alloc(32, 0);
+const utils_1 = require("@noble/hashes/utils");
+const sha512_1 = require("@noble/hashes/sha512");
+const hmac_1 = require("@noble/hashes/hmac");
+const sha2_1 = require("@noble/hashes/sha2");
+const aes_1 = require("ethereum-cryptography/aes");
+const secp256k1_1 = require("@noble/curves/secp256k1");
+const Point = secp256k1_1.secp256k1.ProjectivePoint;
+function isScalar(x) {
+    return Buffer.isBuffer(x) && x.length === 32;
+}
+function isValidPrivateKey(privateKey) {
+    if (!isScalar(privateKey)) {
+        return false;
+    }
+    return (privateKey.compare(ZERO32) > 0 && privateKey.compare(EC_GROUP_ORDER) < 0 // > 0
+    ); // < G
+}
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}
+function sha512(msg) {
+    return sha512_1.sha512.create()
+        .update(msg)
+        .digest();
+}
+async function aes256CbcEncrypt(iv, key, plaintext) {
+    const buf = await (0, aes_1.encrypt)(plaintext, key, iv, "aes-256-cbc");
+    return buf;
+}
+async function aes256CbcDecrypt(iv, key, ciphertext) {
+    return await (0, aes_1.decrypt)(ciphertext, key, iv, "aes-256-cbc");
+}
+function hmacSha256(key, msg) {
+    return hmac_1.hmac
+        .create(sha2_1.sha256, key)
+        .update(msg)
+        .digest();
+}
+// Compare two buffers in constant time to prevent timing attacks.
+function equalConstTime(b1, b2) {
+    if (b1.length !== b2.length) {
+        return false;
+    }
+    let res = 0;
+    for (let i = 0; i < b1.length; i++) {
+        res |= b1[i] ^ b2[i]; // jshint ignore:line
+    }
+    return res === 0;
+}
+const getPublic = (privateKey) => {
+    assert(privateKey.length === 32, "Bad private key");
+    assert(isValidPrivateKey(privateKey), "Bad private key");
+    return Point.fromPrivateKey(privateKey).toRawBytes(false);
+};
+const derive = async (privateKeyA, publicKeyB) => {
+    return new Promise((resolve) => {
+        assert(privateKeyA.length === 32, "Bad private key");
+        assert(isValidPrivateKey(privateKeyA), "Bad private key");
+        resolve(secp256k1_1.secp256k1.getSharedSecret(privateKeyA, publicKeyB));
+    });
+};
+const encrypt = (publicKeyTo, msg, opts) => {
+    opts = opts || {};
+    // Tmp variable to save context from flat promises;
+    let ephemPublicKey;
+    return new Promise(function (resolve) {
+        let ephemPrivateKey = opts.ephemPrivateKey || Buffer.from((0, utils_1.randomBytes)(32));
+        // There is a very unlikely possibility that it is not a valid key
+        while (!isValidPrivateKey(ephemPrivateKey)) {
+            ephemPrivateKey = opts.ephemPrivateKey || Buffer.from((0, utils_1.randomBytes)(32));
+        }
+        ephemPublicKey = getPublic(ephemPrivateKey);
+        resolve(derive(ephemPrivateKey, publicKeyTo));
+    }).then(async function (Px) {
+        const hash = sha512(Px);
+        const iv = opts.iv || (0, utils_1.randomBytes)(16);
+        const encryptionKey = hash.slice(0, 32);
+        const macKey = hash.slice(32);
+        const ciphertext = await aes256CbcEncrypt(iv, encryptionKey, msg);
+        const dataToMac = Buffer.concat([iv, ephemPublicKey, ciphertext]);
+        const mac = Buffer.from(hmacSha256(macKey, dataToMac));
+        return {
+            iv: iv,
+            ephemPublicKey: ephemPublicKey,
+            ciphertext: ciphertext,
+            mac: mac
+        };
+    });
+};
+exports.encrypt = encrypt;
+const decrypt = (privateKey, opts) => {
+    return derive(privateKey, opts.ephemPublicKey).then(function (Px) {
+        assert(privateKey.length === 32, "Bad private key");
+        assert(isValidPrivateKey(privateKey), "Bad private key");
+        const hash = sha512(Px);
+        const encryptionKey = hash.slice(0, 32);
+        const macKey = hash.slice(32);
+        const dataToMac = Buffer.concat([opts.iv, opts.ephemPublicKey, opts.ciphertext]);
+        const realMac = hmacSha256(macKey, dataToMac);
+        assert(equalConstTime(opts.mac, realMac), "Bad MAC");
+        return aes256CbcDecrypt(opts.iv, encryptionKey, opts.ciphertext);
+    });
+};
+exports.decrypt = decrypt;

package/lib/hd/constant.js

@@ -53,4 +53,3 @@ const BIP44ChainMap = new Map([
     [BIP44Chain.BIZAIN, "bizain"]
 ]);
 exports.BIP44ChainMap = BIP44ChainMap;
-//# sourceMappingURL=constant.js.map

package/lib/hd/eos.plugin.d.ts

@@ -1,5 +1,6 @@
 import { IHDPlugin } from "../types";
 export interface IEosPlugin extends IHDPlugin {
     checkPrivateKey(privateKey: string): string;
+    privateKeyToLegacyString(privateKey: string): string;
 }
 export declare const plugin: IEosPlugin;

package/lib/hd/eos.plugin.js

@@ -1,42 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.plugin = void 0;
-const PublicKey = require("eosjs-ecc/lib/key_public");
-const PrivateKey = require("eosjs-ecc/lib/key_private");
-const Signature = require("eosjs-ecc/lib/signature");
-const wif = require("wif");
-const secp256k1_1 = require("@noble/curves/secp256k1");
-const jcc_common_1 = require("jcc_common");
 const sha256_1 = require("@noble/hashes/sha256");
+const PublicKey_1 = require("../minify-eosjs/PublicKey");
+const PrivateKey_1 = require("../minify-eosjs/PrivateKey");
+const Signature_1 = require("../minify-eosjs/Signature");
+const eosjs_numeric_1 = require("../minify-eosjs/eosjs-numeric");
+const internal_1 = require("../minify-ethereumjs-util/internal");
 exports.plugin = {
     checkPrivateKey(privateKey) {
         // check and cut swtc keypair lib add prefix 00
         return privateKey.length === 66 ? privateKey.substring(2) : privateKey;
     },
+    privateKeyToLegacyString(privateKey) {
+        const priv = exports.plugin.checkPrivateKey((0, internal_1.stripHexPrefix)(privateKey));
+        const buffer = Buffer.from(priv, "hex");
+        const eosPrivateKey = (0, eosjs_numeric_1.privateKeyToLegacyString)({
+            data: Uint8Array.from(buffer),
+            type: eosjs_numeric_1.KeyType.k1
+        });
+        return eosPrivateKey;
+    },
     address(key) {
         if (key.privateKey) {
-            const privateKey = exports.plugin.checkPrivateKey(key.privateKey);
-            // TODO: secp256k1 version confict fixed, but need refactor later
-            const rawPublicKey = Buffer.from(secp256k1_1.secp256k1.ProjectivePoint.fromPrivateKey(privateKey).toRawBytes(true));
-            const eosPublicKey = PublicKey(rawPublicKey).toString();
-            return eosPublicKey;
+            const eosPrivateKey = exports.plugin.privateKeyToLegacyString(key.privateKey);
+            return PrivateKey_1.PrivateKey.fromString(eosPrivateKey)
+                .getPublicKey()
+                .toLegacyString();
         }
         if (key.publicKey) {
-            const rawPublicKey = Buffer.from(key.publicKey, "hex");
-            const eosPublicKey = PublicKey(rawPublicKey).toString();
-            return eosPublicKey;
+            return (0, eosjs_numeric_1.publicKeyToLegacyString)({
+                data: Uint8Array.from(Buffer.from(key.publicKey, "hex")),
+                type: eosjs_numeric_1.KeyType.k1
+            });
         }
         return null;
     },
     isValidAddress(address) {
-        return PublicKey.isValid(address);
+        try {
+            const pk = PublicKey_1.PublicKey.fromString(address);
+            return pk.isValid();
+        }
+        catch (_) {
+            return false;
+        }
     },
     isValidSecret(secret) {
         try {
-            const privateKey = exports.plugin.checkPrivateKey((0, jcc_common_1.filterOx)(secret));
-            const buffer = Buffer.from(privateKey, "hex");
-            const eosPrivateKey = wif.encode(128, buffer, false);
-            return PrivateKey.isValid(eosPrivateKey);
+            const eosPrivateKey = exports.plugin.privateKeyToLegacyString(secret);
+            return PrivateKey_1.PrivateKey.fromString(eosPrivateKey).isValid();
         }
         catch (_) {
             return false;
@@ -55,16 +67,15 @@ exports.plugin = {
      * @returns signature string
      */
     sign(message, privateKey) {
-        const buffer = Buffer.from(exports.plugin.checkPrivateKey((0, jcc_common_1.filterOx)(privateKey)), "hex");
-        const eosPrivateKey = wif.encode(128, buffer, false);
-        return Signature.sign(message, eosPrivateKey, "utf8").toString();
+        const eosPrivateKey = exports.plugin.privateKeyToLegacyString(privateKey);
+        const pk = PrivateKey_1.PrivateKey.fromString(eosPrivateKey);
+        return pk.sign(message).toString();
     },
     verify(message, signature, address) {
         return exports.plugin.recover(message, signature) === address;
     },
     recover(message, signature) {
-        const s = Signature.from(signature);
-        return s.recover(message, "utf8").toString();
+        const s = Signature_1.Signature.fromString(signature);
+        return s.recover(message).toLegacyString();
     }
 };
-//# sourceMappingURL=eos.plugin.js.map

package/lib/hd/ethereum.plugin.d.ts

@@ -1,6 +1,6 @@
 import { IHDPlugin } from "../types";
 export interface IEthereumPlugin extends IHDPlugin {
     checkPrivateKey(privateKey: string): string;
-    decryptKeystore(password: string, encryptData: any): string;
+    decryptKeystore(password: string, encryptData: any): Promise<string>;
 }
 export declare const plugin: IEthereumPlugin;

package/lib/hd/ethereum.plugin.js

@@ -1,7 +1,4 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.plugin = void 0;
 const secp256k1_1 = require("@noble/curves/secp256k1");
@@ -10,10 +7,8 @@ const bytes_1 = require("../minify-ethereumjs-util/bytes");
 const internal_1 = require("../minify-ethereumjs-util/internal");
 const signature_1 = require("../minify-ethereumjs-util/signature");
 const account_1 = require("../minify-ethereumjs-util/account");
-const jcc_common_1 = require("jcc_common");
+const util_1 = require("../util");
 const constant_1 = require("../constant");
-const scrypt_1 = require("@noble/hashes/scrypt");
-const crypto_1 = __importDefault(require("crypto"));
 const utils_1 = require("@noble/hashes/utils");
 const isObject = (obj) => {
     return Object.prototype.toString.call(obj) === "[object Object]";
@@ -83,33 +78,34 @@ exports.plugin = {
         const address = (0, account_1.pubToAddress)(Buffer.from(pk));
         return (0, bytes_1.bytesToHex)(address);
     },
-    decryptKeystore(password, encryptData) {
+    async decryptKeystore(password, encryptData) {
         if (!isObject(encryptData)) {
             throw new Error(constant_1.KEYSTORE_IS_INVALID);
         }
         const cryptoData = encryptData.Crypto || encryptData.crypto;
-        if ((0, jcc_common_1.isEmptyObject)(cryptoData) || (0, jcc_common_1.isEmptyObject)(cryptoData.cipherparams) || (0, jcc_common_1.isEmptyObject)(cryptoData.kdfparams)) {
+        if ((0, util_1.isEmptyPlainObject)(cryptoData) ||
+            (0, util_1.isEmptyPlainObject)(cryptoData.cipherparams) ||
+            (0, util_1.isEmptyPlainObject)(cryptoData.kdfparams)) {
             throw new Error(constant_1.KEYSTORE_IS_INVALID);
         }
-        const iv = Buffer.from(cryptoData.cipherparams.iv, "hex");
         const kdfparams = cryptoData.kdfparams;
-        const derivedKey = (0, scrypt_1.scrypt)(Buffer.from(password), Buffer.from(kdfparams.salt, "hex"), {
-            N: kdfparams.n,
-            r: kdfparams.r,
-            p: kdfparams.p,
-            dkLen: kdfparams.dklen
+        const buf = await (0, util_1.decrypt)(password, {
+            crypto: {
+                iv: cryptoData.cipherparams.iv,
+                cipher: cryptoData.cipher,
+                kdf: cryptoData.kdf,
+                kdfparams: {
+                    dklen: kdfparams.dklen,
+                    n: kdfparams.n,
+                    p: kdfparams.p,
+                    r: kdfparams.r,
+                    salt: kdfparams.salt
+                }
+            },
+            mac: cryptoData.mac,
+            ciphertext: cryptoData.ciphertext
         });
-        const ciphertext = Buffer.from(cryptoData.ciphertext, "hex");
-        const mac = keccak_js_1.keccak256
-            .create()
-            .update(Buffer.concat([derivedKey.slice(16, 32), ciphertext]))
-            .digest();
-        if (Buffer.from(mac).toString("hex") !== cryptoData.mac) {
-            throw new Error(constant_1.ETH_PASSWORD_IS_WRONG);
-        }
-        const decipher = crypto_1.default.createDecipheriv("aes-128-ctr", derivedKey.slice(0, 16), iv);
-        const seed = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-        return seed.toString("hex");
+        return buf.toString("hex");
     },
     createWallet() {
         const priv = (0, utils_1.randomBytes)(32);
@@ -117,4 +113,3 @@ exports.plugin = {
         return { address, secret: (0, bytes_1.bytesToHex)(priv) };
     }
 };
-//# sourceMappingURL=ethereum.plugin.js.map

package/lib/hd/index.js

@@ -379,4 +379,3 @@ HDWallet.fromMnemonic = (mnemonic) => {
 HDWallet.fromKeypair = (keypair) => {
     return new HDWallet({ keypair });
 };
-//# sourceMappingURL=index.js.map

package/lib/hd/plugins.js

@@ -23,6 +23,7 @@ const pluginMap = {
     ethereum: ethereum_plugin_1.plugin,
     bsc: ethereum_plugin_2.plugin,
     heco: ethereum_plugin_3.plugin,
+    moac: ethereum_plugin_1.plugin,
     polygon: ethereum_plugin_4.plugin,
     tron: tron_plugin_1.plugin,
     eos: eos_plugin_1.plugin,
@@ -36,4 +37,3 @@ const pluginMap = {
 function getPluginByType(type) {
     return pluginMap[type];
 }
-//# sourceMappingURL=plugins.js.map

package/lib/hd/swtc.plugin.js

@@ -83,4 +83,3 @@ const SWTCPlugin = (alphabet) => {
     };
 };
 exports.SWTCPlugin = SWTCPlugin;
-//# sourceMappingURL=swtc.plugin.js.map

package/lib/hd/tron.plugin.js

@@ -59,4 +59,3 @@ exports.plugin = {
         return (0, message_1.verifyMessage)(message, signature);
     }
 };
-//# sourceMappingURL=tron.plugin.js.map

package/lib/index.js

@@ -56,4 +56,3 @@ const hdWallet = __importStar(require("./hd"));
 exports.hdWallet = hdWallet;
 __exportStar(require("./hd"), exports);
 __exportStar(require("./hd/plugins"), exports);
-//# sourceMappingURL=index.js.map

package/lib/jingchangWallet.d.ts

@@ -259,7 +259,7 @@ export default class JingchangWallet {
      * @returns {IKeystoreModel}
      * @memberof JingchangWallet
      */
-    protected getEncryptData(password: string, keypairs: IKeypairsModel): IKeystoreModel;
+    protected getEncryptData(password: string, keypairs: IKeypairsModel): Promise<IKeystoreModel>;
     /**
      * save wallet keystore to jingchang wallet
      *

package/lib/jingchangWallet.js

@@ -1,18 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const assert_1 = __importDefault(require("assert"));
 const clone_deep_1 = __importDefault(require("clone-deep"));
 const sha256_1 = require("@noble/hashes/sha256");
-const eccrypto_1 = __importDefault(require("eccrypto"));
-const jcc_common_1 = require("jcc_common");
+const eccrypto = __importStar(require("./eccrypto"));
+const util_1 = require("./util");
 const lockr_1 = __importDefault(require("lockr"));
 const minify_swtc_keypair_1 = require("./minify-swtc-keypair");
 const constant_1 = require("./constant");
 const plugins_1 = require("./hd/plugins");
-const util_1 = require("./util");
+const util_2 = require("./util");
 const types_1 = require("./types");
 lockr_1.default.prefix = "jingchang_";
 /**
@@ -48,7 +70,7 @@ class JingchangWallet {
             if (typeof wallet === "string") {
                 wallet = JSON.parse(wallet);
             }
-            const walletsNotEmpty = !(0, jcc_common_1.isEmptyObject)(wallet) && Array.isArray(wallet.wallets) && wallet.wallets.length > 0;
+            const walletsNotEmpty = !(0, util_1.isEmptyPlainObject)(wallet) && Array.isArray(wallet.wallets) && wallet.wallets.length > 0;
             return Boolean(walletsNotEmpty && wallet.contact && wallet.id && wallet.version);
         }
         catch (error) {
@@ -65,33 +87,31 @@ class JingchangWallet {
      * @returns {Promise<IJingchangWalletModel>} resolve jingchang wallet if success.
      * @memberof JingchangWallet
      */
-    static generate(password, secret, alias) {
-        return new Promise((resolve, reject) => {
-            const keypairs = {};
-            if (secret === undefined) {
-                const wallet = plugins_1.jtWallet.createWallet();
-                secret = wallet.secret;
-                keypairs.address = wallet.address;
-            }
-            else {
-                if (!plugins_1.jtWallet.isValidSecret(secret)) {
-                    return reject(new Error(constant_1.SECRET_IS_INVALID));
-                }
-                keypairs.address = plugins_1.jtWallet.getAddress(secret);
+    static async generate(password, secret, alias) {
+        const keypairs = {};
+        if (secret === undefined) {
+            const wallet = plugins_1.jtWallet.createWallet();
+            secret = wallet.secret;
+            keypairs.address = wallet.address;
+        }
+        else {
+            if (!plugins_1.jtWallet.isValidSecret(secret)) {
+                throw new Error(constant_1.SECRET_IS_INVALID);
             }
-            keypairs.secret = secret;
-            keypairs.type = "swt";
-            keypairs.default = true;
-            keypairs.alias = alias || "swt wallet";
-            const jcWallet = {};
-            const walletObj = (0, util_1.encryptWallet)(password, keypairs);
-            jcWallet.version = JingchangWallet.version;
-            jcWallet.id = JingchangWallet._walletID;
-            jcWallet.contact = {};
-            jcWallet.wallets = [];
-            jcWallet.wallets.push(walletObj);
-            return resolve(jcWallet);
-        });
+            keypairs.address = plugins_1.jtWallet.getAddress(secret);
+        }
+        keypairs.secret = secret;
+        keypairs.type = "swt";
+        keypairs.default = true;
+        keypairs.alias = alias || "swt wallet";
+        const jcWallet = {};
+        const walletObj = await (0, util_2.encryptWallet)(password, keypairs);
+        jcWallet.version = JingchangWallet.version;
+        jcWallet.id = JingchangWallet._walletID;
+        jcWallet.contact = {};
+        jcWallet.wallets = [];
+        jcWallet.wallets.push(walletObj);
+        return jcWallet;
     }
     /**
      * get jingchang wallet from local storage
@@ -155,12 +175,12 @@ class JingchangWallet {
      * @memberof JingchangWallet
      */
     static async encryptWithPublicKey(message, publicKey) {
-        const encode = await eccrypto_1.default.encrypt(Buffer.from(publicKey, "hex"), Buffer.from(message));
+        const encode = await eccrypto.encrypt(Buffer.from(publicKey, "hex"), Buffer.from(message));
         return {
-            ciphertext: encode.ciphertext.toString("hex"),
-            ephemPublicKey: encode.ephemPublicKey.toString("hex"),
-            iv: encode.iv.toString("hex"),
-            mac: encode.mac.toString("hex")
+            ciphertext: Buffer.from(encode.ciphertext).toString("hex"),
+            ephemPublicKey: Buffer.from(encode.ephemPublicKey).toString("hex"),
+            iv: Buffer.from(encode.iv).toString("hex"),
+            mac: Buffer.from(encode.mac).toString("hex")
         };
     }
     /**
@@ -179,8 +199,8 @@ class JingchangWallet {
             iv: Buffer.from(message.iv, "hex"),
             mac: Buffer.from(message.mac, "hex")
         };
-        const decode = await eccrypto_1.default.decrypt(Buffer.from(privateKey, "hex"), encode);
-        return decode.toString();
+        const decode = await eccrypto.decrypt(Buffer.from(privateKey, "hex"), encode);
+        return Buffer.from(decode).toString();
     }
     /**
      * get wallets from jingchang wallet
@@ -252,7 +272,7 @@ class JingchangWallet {
     hasDefault(type = "swt") {
         try {
             const wallet = this.findWallet((w) => w.type === type && w.default);
-            return !(0, jcc_common_1.isEmptyObject)(wallet);
+            return !(0, util_1.isEmptyPlainObject)(wallet);
         }
         catch (error) {
             return false;
@@ -268,8 +288,8 @@ class JingchangWallet {
      */
     async getSecretWithType(password, type = "swt") {
         const wallet = await this.findWallet((w) => w.type === type && w.default);
-        const secret = (0, util_1.decrypt)(password, wallet);
-        return secret;
+        const secret = await (0, util_2.decrypt)(password, wallet);
+        return secret.toString();
     }
     /**
      * get the wallet keystore's secret with address.
@@ -281,8 +301,8 @@ class JingchangWallet {
      */
     async getSecretWithAddress(password, address) {
         const wallet = await this.findWallet((w) => w.address === address);
-        const secret = (0, util_1.decrypt)(password, wallet);
-        return secret;
+        const secret = await (0, util_2.decrypt)(password, wallet);
+        return secret.toString();
     }
     /**
      * change the whole jingchang wallet password, if you set property of _samePassword is false, will throw an error
@@ -297,7 +317,6 @@ class JingchangWallet {
             throw new Error("the property of _samePassword is false, so please don't call this function!");
         }
         const jcWallet = (0, clone_deep_1.default)(this._jingchangWallet);
-        assert_1.default.notEqual(jcWallet, this._jingchangWallet);
         const wallets = JingchangWallet.getWallets(jcWallet);
         const arr = [];
         for (const wallet of wallets) {
@@ -310,7 +329,7 @@ class JingchangWallet {
                 secret,
                 type: wallet.type
             };
-            const newWallet = this.getEncryptData(newPassword, keypairs);
+            const newWallet = await this.getEncryptData(newPassword, keypairs);
             arr.push(newWallet);
         }
         jcWallet.wallets = arr;
@@ -339,7 +358,7 @@ class JingchangWallet {
             secret,
             type: wallet.type
         };
-        const newWallet = this.getEncryptData(newPassword, keypairs);
+        const newWallet = await this.getEncryptData(newPassword, keypairs);
         // shadow copy
         wallet.ciphertext = newWallet.ciphertext;
         wallet.crypto = newWallet.crypto;
@@ -365,7 +384,7 @@ class JingchangWallet {
             secret,
             type: wallet.type
         };
-        const newWallet = this.getEncryptData(password, keypairs);
+        const newWallet = await this.getEncryptData(password, keypairs);
         // shadow copy
         wallet.ciphertext = newWallet.ciphertext;
         wallet.crypto = newWallet.crypto;
@@ -393,7 +412,6 @@ class JingchangWallet {
      */
     async removeWalletWithAddress(address) {
         const jcWallet = (0, clone_deep_1.default)(this._jingchangWallet);
-        assert_1.default.notEqual(this._jingchangWallet, jcWallet);
         const wallets = JingchangWallet.getWallets(jcWallet);
         const wallet = this.findWallet((w) => w.address === address);
         const index = wallets.findIndex((w) => w.address === wallet.address);
@@ -472,7 +490,7 @@ class JingchangWallet {
         }
         const { wallets } = jingchangWallet;
         const wallet = wallets.find(filter);
-        if ((0, jcc_common_1.isEmptyObject)(wallet)) {
+        if ((0, util_1.isEmptyPlainObject)(wallet)) {
             throw new Error(constant_1.WALLET_IS_EMPTY);
         }
         return wallet;
@@ -486,8 +504,8 @@ class JingchangWallet {
      * @returns {IKeystoreModel}
      * @memberof JingchangWallet
      */
-    getEncryptData(password, keypairs) {
-        const encryptData = (0, util_1.encryptWallet)(password, keypairs, {});
+    async getEncryptData(password, keypairs) {
+        const encryptData = await (0, util_2.encryptWallet)(password, keypairs, {});
         return encryptData;
     }
     /**
@@ -502,9 +520,8 @@ class JingchangWallet {
     async saveWallet(password, keypairs) {
         // support type: ethereum, stream, jingtum, call and moac
         keypairs.default = this._multiple ? !this.hasDefault(keypairs.type) : true;
-        const encryptData = this.getEncryptData(password, keypairs);
+        const encryptData = await this.getEncryptData(password, keypairs);
         const jcWallet = (0, clone_deep_1.default)(this._jingchangWallet);
-        assert_1.default.notEqual(this._jingchangWallet, jcWallet);
         const wallets = jcWallet.wallets;
         const pre = wallets.findIndex((w) => w.type.toLowerCase() === keypairs.type.toLowerCase());
         if (this._multiple) {
@@ -528,4 +545,3 @@ JingchangWallet._walletID = Buffer.from(sha256_1.sha256
     .update(JingchangWallet._name.toLowerCase())
     .digest()).toString("hex");
 exports.default = JingchangWallet;
-//# sourceMappingURL=jingchangWallet.js.map

package/lib/minify-eosjs/PrivateKey.d.ts

@@ -0,0 +1,27 @@
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite curves
+ */
+import BN from "bn.js";
+import { Key, KeyType } from "./eosjs-numeric";
+import { ProjPointType, CurveFn } from "@noble/curves/abstract/weierstrass";
+import { PublicKey, Signature } from "./eosjs-key-conversions";
+/** Represents/stores a private key and provides easy conversion for use with `elliptic` lib */
+export declare class PrivateKey {
+    private key;
+    private ec;
+    constructor(key: Key, ec: CurveFn);
+    /** Instantiate private key from an EOSIO-format private key */
+    static fromString(keyString: string, ec?: CurveFn): PrivateKey;
+    /** Export private key as `elliptic`-format private key */
+    toPoint(): ProjPointType<bigint>;
+    /** Get key type from key */
+    getType(): KeyType;
+    /** Retrieve the public key from a private key */
+    getPublicKey(): PublicKey;
+    /** Sign a message or hashed message digest with private key */
+    sign(data: BN, shouldHash?: boolean, encoding?: BufferEncoding): Signature;
+    /** Validate a private key */
+    isValid(): boolean;
+}