jcc_wallet 4.0.1 → 4.0.2

package/lib/minify-eosjs/eosjs-numeric.js

@@ -0,0 +1,303 @@
+"use strict";
+/**
+ * forked from https://github.com/EOSIO/eosjs/blob/master/src/eosjs-key-conversions.ts
+ *
+ * rewrite ripemd160
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.privateKeyToString = exports.privateKeyToLegacyString = exports.signatureToString = exports.stringToSignature = exports.stringToPrivateKey = exports.publicKeyToLegacyString = exports.stringToPublicKey = exports.signatureDataSize = exports.privateKeyDataSize = exports.publicKeyDataSize = exports.KeyType = exports.binaryToBase58 = exports.base58ToBinary = void 0;
+const ripemd160_1 = require("@noble/hashes/ripemd160");
+const sha256_1 = require("@noble/hashes/sha256");
+const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const create_base58_map = () => {
+    const base58M = Array(256).fill(-1);
+    for (let i = 0; i < base58Chars.length; ++i) {
+        base58M[base58Chars.charCodeAt(i)] = i;
+    }
+    return base58M;
+};
+const base58Map = create_base58_map();
+const base58ToBinaryVarSize = (s) => {
+    const result = [];
+    for (let i = 0; i < s.length; ++i) {
+        let carry = base58Map[s.charCodeAt(i)];
+        if (carry < 0) {
+            throw new Error("invalid base-58 value");
+        }
+        for (let j = 0; j < result.length; ++j) {
+            const x = result[j] * 58 + carry;
+            result[j] = x & 0xff;
+            carry = x >> 8;
+        }
+        if (carry) {
+            result.push(carry);
+        }
+    }
+    for (const ch of s) {
+        if (ch === "1") {
+            result.push(0);
+        }
+        else {
+            break;
+        }
+    }
+    result.reverse();
+    return new Uint8Array(result);
+};
+/**
+ * Convert an unsigned base-58 number in `s` to a bignum
+ *
+ * @param size bignum size (bytes)
+ */
+const base58ToBinary = (size, s) => {
+    if (!size) {
+        return base58ToBinaryVarSize(s);
+    }
+    const result = new Uint8Array(size);
+    for (let i = 0; i < s.length; ++i) {
+        let carry = base58Map[s.charCodeAt(i)];
+        if (carry < 0) {
+            throw new Error("invalid base-58 value");
+        }
+        for (let j = 0; j < size; ++j) {
+            const x = result[j] * 58 + carry;
+            result[j] = x;
+            carry = x >> 8;
+        }
+        if (carry) {
+            throw new Error("base-58 value is out of range");
+        }
+    }
+    result.reverse();
+    return result;
+};
+exports.base58ToBinary = base58ToBinary;
+/**
+ * Convert `bignum` to a base-58 number
+ *
+ * @param minDigits 0-pad result to this many digits
+ */
+const binaryToBase58 = (bignum) => {
+    const result = [];
+    for (const byte of bignum) {
+        let carry = byte;
+        for (let j = 0; j < result.length; ++j) {
+            const x = (base58Map[result[j]] << 8) + carry;
+            result[j] = base58Chars.charCodeAt(x % 58);
+            carry = (x / 58) | 0;
+        }
+        while (carry) {
+            result.push(base58Chars.charCodeAt(carry % 58));
+            carry = (carry / 58) | 0;
+        }
+    }
+    for (const byte of bignum) {
+        if (byte) {
+            break;
+        }
+        else {
+            result.push("1".charCodeAt(0));
+        }
+    }
+    result.reverse();
+    return String.fromCharCode(...result);
+};
+exports.binaryToBase58 = binaryToBase58;
+/** Key types this library supports */
+var KeyType;
+(function (KeyType) {
+    KeyType[KeyType["k1"] = 0] = "k1";
+    KeyType[KeyType["r1"] = 1] = "r1";
+    KeyType[KeyType["wa"] = 2] = "wa";
+})(KeyType || (exports.KeyType = KeyType = {}));
+/** Public key data size, excluding type field */
+exports.publicKeyDataSize = 33;
+/** Private key data size, excluding type field */
+exports.privateKeyDataSize = 32;
+/** Signature data size, excluding type field */
+exports.signatureDataSize = 65;
+const digestSuffixRipemd160 = (data, suffix) => {
+    const d = new Uint8Array(data.length + suffix.length);
+    for (let i = 0; i < data.length; ++i) {
+        d[i] = data[i];
+    }
+    for (let i = 0; i < suffix.length; ++i) {
+        d[data.length + i] = suffix.charCodeAt(i);
+    }
+    return (0, ripemd160_1.ripemd160)(d);
+};
+const stringToKey = (s, type, size, suffix) => {
+    const whole = (0, exports.base58ToBinary)(size ? size + 4 : 0, s);
+    const result = { type, data: new Uint8Array(whole.buffer, 0, whole.length - 4) };
+    const digest = new Uint8Array(digestSuffixRipemd160(result.data, suffix));
+    if (digest[0] !== whole[whole.length - 4] ||
+        digest[1] !== whole[whole.length - 3] ||
+        digest[2] !== whole[whole.length - 2] ||
+        digest[3] !== whole[whole.length - 1]) {
+        throw new Error("checksum doesn't match");
+    }
+    return result;
+};
+const keyToString = (key, suffix, prefix) => {
+    const digest = new Uint8Array(digestSuffixRipemd160(key.data, suffix));
+    const whole = new Uint8Array(key.data.length + 4);
+    for (let i = 0; i < key.data.length; ++i) {
+        whole[i] = key.data[i];
+    }
+    for (let i = 0; i < 4; ++i) {
+        whole[i + key.data.length] = digest[i];
+    }
+    return prefix + (0, exports.binaryToBase58)(whole);
+};
+/** Convert key in `s` to binary form */
+const stringToPublicKey = (s) => {
+    if (typeof s !== "string") {
+        throw new Error("expected string containing public key");
+    }
+    if (s.substring(0, 3) === "EOS") {
+        const whole = (0, exports.base58ToBinary)(exports.publicKeyDataSize + 4, s.substring(3));
+        const key = { type: KeyType.k1, data: new Uint8Array(exports.publicKeyDataSize) };
+        for (let i = 0; i < exports.publicKeyDataSize; ++i) {
+            key.data[i] = whole[i];
+        }
+        const digest = new Uint8Array((0, ripemd160_1.ripemd160)(key.data));
+        if (digest[0] !== whole[exports.publicKeyDataSize] ||
+            digest[1] !== whole[34] ||
+            digest[2] !== whole[35] ||
+            digest[3] !== whole[36]) {
+            throw new Error("checksum doesn't match");
+        }
+        return key;
+    }
+    else if (s.substring(0, 7) === "PUB_K1_") {
+        return stringToKey(s.substring(7), KeyType.k1, exports.publicKeyDataSize, "K1");
+    }
+    else if (s.substring(0, 7) === "PUB_R1_") {
+        return stringToKey(s.substring(7), KeyType.r1, exports.publicKeyDataSize, "R1");
+    }
+    else if (s.substring(0, 7) === "PUB_WA_") {
+        return stringToKey(s.substring(7), KeyType.wa, 0, "WA");
+    }
+    else {
+        throw new Error("unrecognized public key format");
+    }
+};
+exports.stringToPublicKey = stringToPublicKey;
+/** Convert public `key` to legacy string (base-58) form */
+const publicKeyToLegacyString = (key) => {
+    if (key.type === KeyType.k1 && key.data.length === exports.publicKeyDataSize) {
+        return keyToString(key, "", "EOS");
+    }
+    else if (key.type === KeyType.r1 || key.type === KeyType.wa) {
+        throw new Error("Key format not supported in legacy conversion");
+    }
+    else {
+        throw new Error("unrecognized public key format");
+    }
+};
+exports.publicKeyToLegacyString = publicKeyToLegacyString;
+/** Convert key in `s` to binary form */
+const stringToPrivateKey = (s) => {
+    if (typeof s !== "string") {
+        throw new Error("expected string containing private key");
+    }
+    if (s.substring(0, 7) === "PVT_R1_") {
+        return stringToKey(s.substring(7), KeyType.r1, exports.privateKeyDataSize, "R1");
+    }
+    else if (s.substring(0, 7) === "PVT_K1_") {
+        return stringToKey(s.substring(7), KeyType.k1, exports.privateKeyDataSize, "K1");
+    }
+    else {
+        // todo: Verify checksum: sha256(sha256(key.data)).
+        //       Not critical since a bad key will fail to produce a
+        //       valid signature anyway.
+        const whole = (0, exports.base58ToBinary)(exports.privateKeyDataSize + 5, s);
+        const key = { type: KeyType.k1, data: new Uint8Array(exports.privateKeyDataSize) };
+        if (whole[0] !== 0x80) {
+            throw new Error("unrecognized private key type");
+        }
+        for (let i = 0; i < exports.privateKeyDataSize; ++i) {
+            key.data[i] = whole[i + 1];
+        }
+        return key;
+    }
+};
+exports.stringToPrivateKey = stringToPrivateKey;
+/** Convert key in `s` to binary form */
+const stringToSignature = (s) => {
+    if (typeof s !== "string") {
+        throw new Error("expected string containing signature");
+    }
+    if (s.substring(0, 7) === "SIG_K1_") {
+        return stringToKey(s.substring(7), KeyType.k1, exports.signatureDataSize, "K1");
+    }
+    else if (s.substring(0, 7) === "SIG_R1_") {
+        return stringToKey(s.substring(7), KeyType.r1, exports.signatureDataSize, "R1");
+    }
+    else if (s.substring(0, 7) === "SIG_WA_") {
+        return stringToKey(s.substring(7), KeyType.wa, 0, "WA");
+    }
+    else {
+        throw new Error("unrecognized signature format");
+    }
+};
+exports.stringToSignature = stringToSignature;
+/** Convert `signature` to string (base-58) form */
+const signatureToString = (signature) => {
+    if (signature.type === KeyType.k1) {
+        return keyToString(signature, "K1", "SIG_K1_");
+    }
+    else if (signature.type === KeyType.r1) {
+        return keyToString(signature, "R1", "SIG_R1_");
+    }
+    else if (signature.type === KeyType.wa) {
+        return keyToString(signature, "WA", "SIG_WA_");
+    }
+    else {
+        throw new Error("unrecognized signature format");
+    }
+};
+exports.signatureToString = signatureToString;
+const privateKeyToLegacyString = (key) => {
+    if (key.type === KeyType.k1 && key.data.length === exports.privateKeyDataSize) {
+        const whole = [];
+        whole.push(128);
+        key.data.forEach((byte) => whole.push(byte));
+        const digest = new Uint8Array(sha256_1.sha256
+            .create()
+            .update(sha256_1.sha256
+            .create()
+            .update(Buffer.from(whole))
+            .digest())
+            .digest());
+        const result = new Uint8Array(exports.privateKeyDataSize + 5);
+        for (let i = 0; i < whole.length; i++) {
+            result[i] = whole[i];
+        }
+        for (let i = 0; i < 4; i++) {
+            result[i + whole.length] = digest[i];
+        }
+        return (0, exports.binaryToBase58)(result);
+    }
+    else if (key.type === KeyType.r1 || key.type === KeyType.wa) {
+        throw new Error("Key format not supported in legacy conversion");
+    }
+    else {
+        throw new Error("unrecognized public key format");
+    }
+};
+exports.privateKeyToLegacyString = privateKeyToLegacyString;
+/** Convert `key` to string (base-58) form */
+const privateKeyToString = (key) => {
+    if (key.type === KeyType.r1) {
+        return keyToString(key, "R1", "PVT_R1_");
+    }
+    else if (key.type === KeyType.k1) {
+        return keyToString(key, "K1", "PVT_K1_");
+    }
+    else {
+        throw new Error("unrecognized private key format");
+    }
+};
+exports.privateKeyToString = privateKeyToString;

package/lib/minify-ethereumjs-util/account.js

@@ -19,4 +19,3 @@ const pubToAddress = function (pubKey, sanitize = false) {
     return (0, keccak_js_1.keccak256)(pubKey).subarray(-20);
 };
 exports.pubToAddress = pubToAddress;
-//# sourceMappingURL=account.js.map

package/lib/minify-ethereumjs-util/bytes.js

@@ -97,4 +97,3 @@ const bytesToBigInt = (bytes) => {
     return BigInt(hex);
 };
 exports.bytesToBigInt = bytesToBigInt;
-//# sourceMappingURL=bytes.js.map

package/lib/minify-ethereumjs-util/constants.js

@@ -6,4 +6,3 @@ exports.BIGINT_0 = BigInt(0);
 exports.BIGINT_1 = BigInt(1);
 exports.BIGINT_2 = BigInt(2);
 exports.BIGINT_27 = BigInt(27);
-//# sourceMappingURL=constants.js.map

package/lib/minify-ethereumjs-util/helper.js

@@ -13,4 +13,3 @@ const assertIsBytes = function (input) {
     }
 };
 exports.assertIsBytes = assertIsBytes;
-//# sourceMappingURL=helper.js.map

package/lib/minify-ethereumjs-util/internal.js

@@ -30,4 +30,3 @@ const stripHexPrefix = (str) => {
     return isHexPrefixed(str) ? str.slice(2) : str;
 };
 exports.stripHexPrefix = stripHexPrefix;
-//# sourceMappingURL=internal.js.map

package/lib/minify-ethereumjs-util/signature.js

@@ -42,4 +42,3 @@ const ecrecover = function (msgHash, v, r, s, chainId) {
     return senderPubKey.toRawBytes(false).slice(1);
 };
 exports.ecrecover = ecrecover;
-//# sourceMappingURL=signature.js.map

package/lib/minify-swtc-keypair/address-codec.js

@@ -163,4 +163,3 @@ const Factory = (alphabet) => {
     };
 };
 exports.Factory = Factory;
-//# sourceMappingURL=address-codec.js.map

package/lib/minify-swtc-keypair/index.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.Factory = void 0;
 const address_codec_1 = require("./address-codec");
@@ -12,8 +9,7 @@ const sha256_1 = require("@noble/hashes/sha256");
 const ripemd160_1 = require("@noble/hashes/ripemd160");
 const ed25519_1 = require("@noble/curves/ed25519");
 const secp256k1_1 = require("@noble/curves/secp256k1");
-const brorand_1 = __importDefault(require("brorand"));
-const assert = require("assert");
+const utils_3 = require("@noble/hashes/utils");
 const hash = (message) => {
     return sha512_1.sha512
         .create()
@@ -28,6 +24,11 @@ const funcHexToBytes = (hex) => {
     }
     return bytes;
 };
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(message || "Assertion failed");
+    }
+}
 const SECP256K1_PREFIX = "00";
 const ED25519_PREFIX = "ED";
 const computePublicKeyHash = (publicKeyBytes) => {
@@ -140,7 +141,7 @@ const Factory = (alphabet) => {
     };
     const generate = (options) => {
         assert(!options.entropy || options.entropy.length >= 16, "entropy too short");
-        const entropy = options.entropy ? options.entropy.slice(0, 16) : (0, brorand_1.default)(16);
+        const entropy = options.entropy ? options.entropy.slice(0, 16) : (0, utils_3.randomBytes)(16);
         const type = options.algorithm === "ed25519" ? "ed25519" : "secp256k1";
         const secret = addressCodec.encodeSeed(entropy, type);
         const keypair = deriveKeyPair(secret);
@@ -175,4 +176,3 @@ const Factory = (alphabet) => {
     };
 };
 exports.Factory = Factory;
-//# sourceMappingURL=index.js.map

package/lib/minify-swtc-keypair/sha512.js

@@ -30,4 +30,3 @@ class Sha512 {
     }
 }
 exports.default = Sha512;
-//# sourceMappingURL=sha512.js.map

package/lib/minify-swtc-keypair/utils.js

@@ -60,4 +60,3 @@ function derivePrivateKey(seed, opts = {}) {
     const accountIndex = opts.accountIndex || 0;
     return (deriveScalar(publicGen, accountIndex) + privateGen) % order;
 }
-//# sourceMappingURL=utils.js.map

package/lib/minify-tron/address.js

@@ -8,4 +8,3 @@ exports.ADDRESS_PREFIX_BYTE = 0x41;
 exports.ADDRESS_PREFIX_REGEX = /^(41)/;
 exports.TRON_BIP39_PATH_PREFIX = "m/44'/195'";
 exports.TRON_BIP39_PATH_INDEX_0 = exports.TRON_BIP39_PATH_PREFIX + "/0'/0/0";
-//# sourceMappingURL=address.js.map

package/lib/minify-tron/base58.js

@@ -64,4 +64,3 @@ function decode58(string) {
         bytes.push(0);
     return bytes.reverse();
 }
-//# sourceMappingURL=base58.js.map

package/lib/minify-tron/bytes.js

@@ -20,4 +20,3 @@ function byte2hexStr(byte) {
     str += hexByteMap.charAt(byte & 0x0f);
     return str;
 }
-//# sourceMappingURL=bytes.js.map

package/lib/minify-tron/code.d.ts

@@ -1,3 +1,3 @@
-export declare function isHexChar(c: any): 1 | 0;
+export declare function isHexChar(c: any): 0 | 1;
 export declare function hexChar2byte(c: any): number;
 export declare function hexStr2byteArray(str: any, strict?: boolean): any[];

package/lib/minify-tron/code.js

@@ -53,4 +53,3 @@ function hexStr2byteArray(str, strict = false) {
     }
     return byteArray;
 }
-//# sourceMappingURL=code.js.map

package/lib/minify-tron/crypto.js

@@ -13,7 +13,7 @@ const code_1 = require("./code");
 const base58_1 = require("./base58");
 const bytes_1 = require("./bytes");
 const secp256k1_1 = require("@noble/curves/secp256k1");
-const { keccak256, sha256 } = require("ethers/crypto");
+const crypto_1 = require("ethers/crypto");
 function normalizePrivateKeyBytes(priKeyBytes) {
     return (0, code_1.hexStr2byteArray)((0, bytes_1.byteArray2hexStr)(priKeyBytes).padStart(64, "0"));
 }
@@ -50,7 +50,7 @@ function isAddressValid(base58Str) {
 function computeAddress(pubBytes) {
     if (pubBytes.length === 65)
         pubBytes = pubBytes.slice(1);
-    const hash = keccak256(new Uint8Array(pubBytes))
+    const hash = (0, crypto_1.keccak256)(new Uint8Array(pubBytes))
         .toString()
         .substring(2);
     const addressHex = address_1.ADDRESS_PREFIX + hash.substring(24);
@@ -72,7 +72,7 @@ function getPubKeyFromPriKey(priKeyBytes) {
 }
 function SHA256(msgBytes) {
     const msgHex = (0, bytes_1.byteArray2hexStr)(msgBytes);
-    const hashHex = sha256("0x" + msgHex).replace(/^0x/, "");
+    const hashHex = (0, crypto_1.sha256)("0x" + msgHex).replace(/^0x/, "");
     return (0, code_1.hexStr2byteArray)(hashHex);
 }
 function pkToAddress(privateKey, strict = false) {
@@ -80,4 +80,3 @@ function pkToAddress(privateKey, strict = false) {
     const com_addressBytes = getAddressFromPriKey(com_priKeyBytes);
     return getBase58CheckAddress(com_addressBytes);
 }
-//# sourceMappingURL=crypto.js.map

package/lib/minify-tron/message.d.ts

@@ -1,4 +1,4 @@
 export declare const TRON_MESSAGE_PREFIX = "\u0019TRON Signed Message:\n";
-export declare function hashMessage(message: any): any;
-export declare function signMessage(message: any, privateKey: any): any;
+export declare function hashMessage(message: any): string;
+export declare function signMessage(message: any, privateKey: any): string;
 export declare function verifyMessage(message: any, signature: any): string;

package/lib/minify-tron/message.js

@@ -8,25 +8,25 @@ exports.verifyMessage = verifyMessage;
 const address_1 = require("./address");
 const crypto_1 = require("./crypto");
 const code_1 = require("./code");
-const { keccak256, SigningKey, Signature } = require("ethers/crypto");
-const { recoverAddress } = require("ethers/transaction");
-const { toUtf8Bytes, concat } = require("ethers/utils");
-const joinSignature = (splitSig) => Signature.from(splitSig).serialized;
+const crypto_2 = require("ethers/crypto");
+const transaction_1 = require("ethers/transaction");
+const utils_1 = require("ethers/utils");
+const joinSignature = (splitSig) => crypto_2.Signature.from(splitSig).serialized;
 exports.TRON_MESSAGE_PREFIX = "\x19TRON Signed Message:\n";
 function hashMessage(message) {
     if (typeof message === "string") {
-        message = toUtf8Bytes(message);
+        message = (0, utils_1.toUtf8Bytes)(message);
     }
     if (Array.isArray(message)) {
         message = new Uint8Array(message);
     }
-    return keccak256(concat([toUtf8Bytes(exports.TRON_MESSAGE_PREFIX), toUtf8Bytes(String(message.length)), message]));
+    return (0, crypto_2.keccak256)((0, utils_1.concat)([(0, utils_1.toUtf8Bytes)(exports.TRON_MESSAGE_PREFIX), (0, utils_1.toUtf8Bytes)(String(message.length)), message]));
 }
 function signMessage(message, privateKey) {
     if (!privateKey.match(/^0x/)) {
         privateKey = "0x" + privateKey;
     }
-    const signingKey = new SigningKey(privateKey);
+    const signingKey = new crypto_2.SigningKey(privateKey);
     const messageDigest = hashMessage(message);
     const signature = signingKey.sign(messageDigest);
     return joinSignature(signature);
@@ -35,8 +35,7 @@ function verifyMessage(message, signature) {
     if (!signature.match(/^0x/)) {
         signature = "0x" + signature;
     }
-    const recovered = recoverAddress(hashMessage(message), signature);
+    const recovered = (0, transaction_1.recoverAddress)(hashMessage(message), signature);
     const base58Address = (0, crypto_1.getBase58CheckAddress)((0, code_1.hexStr2byteArray)(recovered.replace(/^0x/, address_1.ADDRESS_PREFIX)));
     return base58Address;
 }
-//# sourceMappingURL=message.js.map

package/lib/types.js

@@ -13,4 +13,3 @@ var Alphabet;
     Alphabet["XRP"] = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz";
     Alphabet["SWTC"] = "jpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65rkm8oFqi1tuvAxyz";
 })(Alphabet || (exports.Alphabet = Alphabet = {}));
-//# sourceMappingURL=types.js.map

package/lib/util/index.d.ts

@@ -1,4 +1,5 @@
 import { IEncryptModel, IKeystoreModel, IKeypairsModel } from "../types";
+export declare const isEmptyPlainObject: (obj: any) => boolean;
 /**
  * decrypt wallet with password
  *
@@ -7,7 +8,7 @@ import { IEncryptModel, IKeystoreModel, IKeypairsModel } from "../types";
  * @returns {(string)} return secret if success, otherwise throws `keystore is invalid` if the keystore is invalid or
  * throws `password is wrong` if the password is wrong
  */
-declare const decrypt: (password: string, encryptData: IKeystoreModel) => string;
+declare const decrypt: (password: string, encryptData: IKeystoreModel) => Promise<Buffer>;
 /**
  * encrypt data with password
  *
@@ -16,7 +17,7 @@ declare const decrypt: (password: string, encryptData: IKeystoreModel) => string
  * @param {IEncryptModel} [opts={}]
  * @returns {IKeystoreModel}
  */
-declare const encrypt: (password: string, data: string, opts: IEncryptModel) => IKeystoreModel;
-declare const encryptContact: (password: string, contacts: any, opts?: IEncryptModel) => IKeystoreModel;
-declare const encryptWallet: (password: string, keypairs: IKeypairsModel, opts?: IEncryptModel) => IKeystoreModel;
+declare const encrypt: (password: string, data: string, opts: IEncryptModel) => Promise<IKeystoreModel>;
+declare const encryptContact: (password: string, contacts: any, opts?: IEncryptModel) => Promise<IKeystoreModel>;
+declare const encryptWallet: (password: string, keypairs: IKeypairsModel, opts?: IEncryptModel) => Promise<IKeystoreModel>;
 export { decrypt, encrypt, encryptContact, encryptWallet };

package/lib/util/index.js

@@ -3,13 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encryptWallet = exports.encryptContact = exports.encrypt = exports.decrypt = void 0;
-const crypto_1 = __importDefault(require("crypto"));
-const jcc_common_1 = require("jcc_common");
+exports.encryptWallet = exports.encryptContact = exports.encrypt = exports.decrypt = exports.isEmptyPlainObject = void 0;
 const keccak_js_1 = require("ethereum-cryptography/keccak.js");
-const randombytes_1 = __importDefault(require("randombytes"));
+const aes_1 = require("ethereum-cryptography/aes");
+const utils_1 = require("@noble/hashes/utils");
 const scrypt_1 = require("@noble/hashes/scrypt");
 const constant_1 = require("../constant");
+const is_plain_object_1 = __importDefault(require("is-plain-object"));
+const isEmptyPlainObject = (obj) => {
+    const isPlain = (0, is_plain_object_1.default)(obj);
+    if (!isPlain) {
+        return true;
+    }
+    return Object.keys(obj).length === 0;
+};
+exports.isEmptyPlainObject = isEmptyPlainObject;
 /**
  * decrypt wallet with password
  *
@@ -18,8 +26,10 @@ const constant_1 = require("../constant");
  * @returns {(string)} return secret if success, otherwise throws `keystore is invalid` if the keystore is invalid or
  * throws `password is wrong` if the password is wrong
  */
-const decrypt = (password, encryptData) => {
-    if ((0, jcc_common_1.isEmptyObject)(encryptData) || (0, jcc_common_1.isEmptyObject)(encryptData.crypto) || (0, jcc_common_1.isEmptyObject)(encryptData.crypto.kdfparams)) {
+const decrypt = async (password, encryptData) => {
+    if ((0, exports.isEmptyPlainObject)(encryptData) ||
+        (0, exports.isEmptyPlainObject)(encryptData.crypto) ||
+        (0, exports.isEmptyPlainObject)(encryptData.crypto.kdfparams)) {
         throw new Error(constant_1.KEYSTORE_IS_INVALID);
     }
     const iv = Buffer.from(encryptData.crypto.iv, "hex");
@@ -38,9 +48,8 @@ const decrypt = (password, encryptData) => {
     if (Buffer.from(mac).toString("hex") !== encryptData.mac) {
         throw new Error(constant_1.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();
+    const buf = await (0, aes_1.decrypt)(ciphertext, derivedKey.slice(0, 16), iv, "aes-128-ctr");
+    return Buffer.from(buf);
 };
 exports.decrypt = decrypt;
 /**
@@ -51,14 +60,14 @@ exports.decrypt = decrypt;
  * @param {IEncryptModel} [opts={}]
  * @returns {IKeystoreModel}
  */
-const encrypt = (password, data, opts) => {
-    const iv = opts.iv || (0, randombytes_1.default)(16).toString("hex");
+const encrypt = async (password, data, opts) => {
+    const iv = opts.iv || Buffer.from((0, utils_1.randomBytes)(16)).toString("hex");
     const kdfparams = {
         dklen: opts.dklen || 32,
         n: opts.n || 4096,
         p: opts.p || 1,
         r: opts.r || 8,
-        salt: opts.salt || (0, randombytes_1.default)(32).toString("hex")
+        salt: opts.salt || Buffer.from((0, utils_1.randomBytes)(32)).toString("hex")
     };
     const derivedKey = (0, scrypt_1.scrypt)(Buffer.from(password), Buffer.from(kdfparams.salt, "hex"), {
         N: kdfparams.n,
@@ -66,14 +75,13 @@ const encrypt = (password, data, opts) => {
         p: kdfparams.p,
         dkLen: kdfparams.dklen
     });
-    const cipher = crypto_1.default.createCipheriv(opts.cipher || "aes-128-ctr", derivedKey.slice(0, 16), Buffer.from(iv, "hex"));
-    const ciphertext = Buffer.concat([cipher.update(Buffer.from(data)), cipher.final()]);
+    const buf = await (0, aes_1.encrypt)(Buffer.from(data), derivedKey.slice(0, 16), Buffer.from(iv, "hex"), "aes-128-ctr");
     const mac = keccak_js_1.keccak256
         .create()
-        .update(Buffer.concat([derivedKey.slice(16, 32), ciphertext]))
+        .update(Buffer.concat([derivedKey.slice(16, 32), buf]))
         .digest();
     return {
-        ciphertext: ciphertext.toString("hex"),
+        ciphertext: Buffer.from(buf).toString("hex"),
         crypto: {
             cipher: opts.cipher || "aes-128-ctr",
             iv,
@@ -84,12 +92,12 @@ const encrypt = (password, data, opts) => {
     };
 };
 exports.encrypt = encrypt;
-const encryptContact = (password, contacts, opts = {}) => {
-    return encrypt(password, JSON.stringify(contacts), opts);
+const encryptContact = async (password, contacts, opts = {}) => {
+    return await encrypt(password, JSON.stringify(contacts), opts);
 };
 exports.encryptContact = encryptContact;
-const encryptWallet = (password, keypairs, opts = {}) => {
-    const data = encrypt(password, keypairs.secret, opts);
+const encryptWallet = async (password, keypairs, opts = {}) => {
+    const data = await encrypt(password, keypairs.secret, opts);
     data.type = keypairs.type || "swt";
     data.address = keypairs.address;
     data.default = typeof keypairs.default === "boolean" ? keypairs.default : true;
@@ -97,4 +105,3 @@ const encryptWallet = (password, keypairs, opts = {}) => {
     return data;
 };
 exports.encryptWallet = encryptWallet;
-//# sourceMappingURL=index.js.map