jcc_wallet 4.0.3 → 4.0.4

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

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Factory = void 0;
 const address_codec_1 = require("./address-codec");
 const utils_1 = require("./utils");
-const utils_2 = require("@noble/curves/abstract/utils");
+const utils_js_1 = require("@noble/curves/abstract/utils.js");
 const sha512_1 = __importDefault(require("./sha512"));
-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 utils_3 = require("@noble/hashes/utils");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const legacy_js_1 = require("@noble/hashes/legacy.js");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
+const utils_js_2 = require("@noble/hashes/utils.js");
 function assert(condition, message) {
     if (!condition) {
         throw new Error(message || "Assertion failed");
@@ -21,11 +21,11 @@ function assert(condition, message) {
 const SECP256K1_PREFIX = "00";
 const ED25519_PREFIX = "ED";
 const computePublicKeyHash = (publicKeyBytes) => {
-    const hash256 = sha256_1.sha256
+    const hash256 = sha2_js_1.sha256
         .create()
         .update(publicKeyBytes)
         .digest();
-    const hash160 = ripemd160_1.ripemd160
+    const hash160 = legacy_js_1.ripemd160
         .create()
         .update(hash256)
         .digest();
@@ -36,20 +36,20 @@ const Factory = (alphabet) => {
     const secp256k1 = {
         deriveKeypair: (entropy, options) => {
             const derived = (0, utils_1.derivePrivateKey)(entropy, options);
-            const privateKey = (0, utils_2.bytesToHex)((0, utils_2.numberToBytesBE)(derived, 32));
+            const privateKey = (0, utils_js_1.bytesToHex)((0, utils_js_1.numberToBytesBE)(derived, 32));
             return {
                 privateKey: SECP256K1_PREFIX + privateKey,
-                publicKey: secp256k1_1.secp256k1.ProjectivePoint.fromPrivateKey(privateKey).toHex(true)
+                publicKey: secp256k1_js_1.secp256k1.ProjectivePoint.fromPrivateKey(privateKey).toHex(true)
             };
         },
         deriveKeypairWithPrivateKey: (rawPrivateKey) => {
             const privateKey = rawPrivateKey.toUpperCase();
-            const publicKey = secp256k1_1.secp256k1.ProjectivePoint.fromPrivateKey(privateKey).toHex(true);
+            const publicKey = secp256k1_js_1.secp256k1.ProjectivePoint.fromPrivateKey(privateKey).toHex(true);
             return { privateKey: SECP256K1_PREFIX + privateKey, publicKey };
         },
         sign(message, privateKey) {
             const signHash = sha512_1.default.half(message);
-            return secp256k1_1.secp256k1.sign(signHash, privateKey, {
+            return secp256k1_js_1.secp256k1.sign(signHash, privateKey, {
                 // "Canonical" signatures
                 lowS: true,
                 // Would fail tests if signatures aren't deterministic
@@ -60,30 +60,30 @@ const Factory = (alphabet) => {
         },
         verify(message, signature, publicKey) {
             const signHash = sha512_1.default.half(message);
-            return secp256k1_1.secp256k1.verify(signature, signHash, publicKey);
+            return secp256k1_js_1.secp256k1.verify(signature, signHash, publicKey);
         }
     };
     const ed25519 = {
         deriveKeypair: (entropy) => {
             const rawPrivateKey = sha512_1.default.half(entropy);
-            const privateKey = (0, utils_2.bytesToHex)(rawPrivateKey);
-            const pub = ed25519_1.ed25519.getPublicKey(privateKey);
+            const privateKey = (0, utils_js_1.bytesToHex)(rawPrivateKey);
+            const pub = ed25519_js_1.ed25519.getPublicKey(privateKey);
             return {
                 privateKey: ED25519_PREFIX + privateKey,
-                publicKey: ED25519_PREFIX + (0, utils_2.bytesToHex)(pub)
+                publicKey: ED25519_PREFIX + (0, utils_js_1.bytesToHex)(pub)
             };
         },
         deriveKeypairWithPrivateKey: (rawPrivateKey) => {
             const privateKey = rawPrivateKey.toUpperCase();
-            const pub = ed25519_1.ed25519.getPublicKey(privateKey);
-            return { privateKey: ED25519_PREFIX + privateKey, publicKey: ED25519_PREFIX + (0, utils_2.bytesToHex)(pub) };
+            const pub = ed25519_js_1.ed25519.getPublicKey(privateKey);
+            return { privateKey: ED25519_PREFIX + privateKey, publicKey: ED25519_PREFIX + (0, utils_js_1.bytesToHex)(pub) };
         },
         sign(message, privateKey) {
-            const buf = ed25519_1.ed25519.sign(message, privateKey);
-            return (0, utils_2.bytesToHex)(buf).toUpperCase();
+            const buf = ed25519_js_1.ed25519.sign(message, privateKey);
+            return (0, utils_js_1.bytesToHex)(buf).toUpperCase();
         },
         verify(message, signature, publicKey) {
-            return ed25519_1.ed25519.verify(message, Buffer.from(signature, "hex"), publicKey);
+            return ed25519_js_1.ed25519.verify(message, Buffer.from(signature, "hex"), publicKey);
         }
     };
     const deriveKeyPair = (seed, algorithm) => {
@@ -112,13 +112,13 @@ const Factory = (alphabet) => {
         try {
             deriveKeyPair(secret);
         }
-        catch (_) {
+        catch (_a) {
             return false;
         }
         return true;
     };
     const deriveAddress = (pk) => {
-        return addressCodec.encodeAccountID(Buffer.from(computePublicKeyHash(Buffer.from((0, utils_2.hexToBytes)(pk)))));
+        return addressCodec.encodeAccountID(Buffer.from(computePublicKeyHash(Buffer.from((0, utils_js_1.hexToBytes)(pk)))));
     };
     const fromSecret = (secret, algorithm) => {
         const keypair = deriveKeyPair(secret, algorithm);
@@ -130,7 +130,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, utils_3.randomBytes)(16);
+        const entropy = options.entropy ? options.entropy.slice(0, 16) : (0, utils_js_2.randomBytes)(16);
         const type = options.algorithm === "ed25519" ? "ed25519" : "secp256k1";
         const secret = addressCodec.encodeSeed(entropy, type);
         const keypair = deriveKeyPair(secret);

package/lib/minify-swtc-keypair/sha512.d.ts

@@ -1,5 +1,5 @@
 export default class Sha512 {
-    hash: import("@noble/hashes/utils").Hash<import("@noble/hashes/sha512").SHA512>;
+    hash: import("@noble/hashes/utils").Hash<import("@noble/hashes/utils").Hash<any>>;
     static half(input: any): Uint8Array;
     add(bytes: any): this;
     addU32(i: number): this;

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@noble/curves/abstract/utils");
-const sha512_1 = require("@noble/hashes/sha512");
+const utils_js_1 = require("@noble/curves/abstract/utils.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
 class Sha512 {
     constructor() {
         // instantiate empty sha512 hash
-        this.hash = sha512_1.sha512.create();
+        this.hash = sha2_js_1.sha512.create();
     }
     static half(input) {
         return new Sha512().add(input).first256();
@@ -26,7 +26,7 @@ class Sha512 {
         return this.finish().slice(0, 32);
     }
     first256BigInt() {
-        return (0, utils_1.bytesToNumberBE)(this.first256());
+        return (0, utils_js_1.bytesToNumberBE)(this.first256());
     }
 }
 exports.default = Sha512;

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

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.derivePrivateKey = derivePrivateKey;
-const secp256k1_1 = require("@noble/curves/secp256k1");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
 const sha512_1 = __importDefault(require("./sha512"));
 const ZERO = BigInt(0);
 function deriveScalar(bytes, discrim) {
-    const order = secp256k1_1.secp256k1.CURVE.n;
+    const order = secp256k1_js_1.secp256k1.CURVE.n;
     for (let i = 0; i <= 4294967295; i++) {
         // We hash the bytes to find a 256-bit number, looping until we are sure it
         // is less than the order of the curve.
@@ -46,7 +46,7 @@ function deriveScalar(bytes, discrim) {
  */
 function derivePrivateKey(seed, opts = {}) {
     const root = opts.validator;
-    const order = secp256k1_1.secp256k1.CURVE.n;
+    const order = secp256k1_js_1.secp256k1.CURVE.n;
     // This private generator represents the `root` private key, and is what's
     // used by validators for signing when a keypair is generated from a seed.
     const privateGen = deriveScalar(seed);
@@ -54,7 +54,7 @@ function derivePrivateKey(seed, opts = {}) {
         // As returned by validation_create for a given seed
         return privateGen;
     }
-    const publicGen = secp256k1_1.secp256k1.ProjectivePoint.BASE.multiply(privateGen).toRawBytes(true);
+    const publicGen = secp256k1_js_1.secp256k1.ProjectivePoint.BASE.multiply(privateGen).toRawBytes(true);
     // A seed can generate many keypairs as a function of the seed and a uint32.
     // Almost everyone just uses the first account, `0`.
     const accountIndex = opts.accountIndex || 0;

package/lib/minify-tron/crypto.js

@@ -12,7 +12,7 @@ const address_1 = require("./address");
 const code_1 = require("./code");
 const base58_1 = require("./base58");
 const bytes_1 = require("./bytes");
-const secp256k1_1 = require("@noble/curves/secp256k1");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
 const crypto_1 = require("ethers/crypto");
 function normalizePrivateKeyBytes(priKeyBytes) {
     return (0, code_1.hexStr2byteArray)((0, bytes_1.byteArray2hexStr)(priKeyBytes).padStart(64, "0"));
@@ -61,7 +61,7 @@ function getAddressFromPriKey(priKeyBytes) {
     return computeAddress(pubBytes);
 }
 function getPubKeyFromPriKey(priKeyBytes) {
-    const pubkey = secp256k1_1.secp256k1.ProjectivePoint.fromPrivateKey(new Uint8Array(normalizePrivateKeyBytes(priKeyBytes)));
+    const pubkey = secp256k1_js_1.secp256k1.ProjectivePoint.fromPrivateKey(new Uint8Array(normalizePrivateKeyBytes(priKeyBytes)));
     const x = pubkey.x;
     const y = pubkey.y;
     const xHex = x.toString(16).padStart(64, "0");

package/lib/util/index.js

@@ -6,8 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.encryptWallet = exports.encryptContact = exports.encrypt = exports.decrypt = exports.isEmptyPlainObject = void 0;
 const keccak_js_1 = require("ethereum-cryptography/keccak.js");
 const aes_1 = require("ethereum-cryptography/aes");
-const utils_1 = require("@noble/hashes/utils");
-const scrypt_1 = require("@noble/hashes/scrypt");
+const utils_js_1 = require("@noble/hashes/utils.js");
+const scrypt_js_1 = require("@noble/hashes/scrypt.js");
 const constant_1 = require("../constant");
 const is_plain_object_1 = __importDefault(require("is-plain-object"));
 const isEmptyPlainObject = (obj) => {
@@ -34,7 +34,7 @@ const decrypt = async (password, encryptData) => {
     }
     const iv = Buffer.from(encryptData.crypto.iv, "hex");
     const kdfparams = encryptData.crypto.kdfparams;
-    const derivedKey = (0, scrypt_1.scrypt)(Buffer.from(password), Buffer.from(kdfparams.salt, "hex"), {
+    const derivedKey = (0, scrypt_js_1.scrypt)(Buffer.from(password), Buffer.from(kdfparams.salt, "hex"), {
         N: kdfparams.n,
         r: kdfparams.r,
         p: kdfparams.p,
@@ -61,15 +61,15 @@ exports.decrypt = decrypt;
  * @returns {IKeystoreModel}
  */
 const encrypt = async (password, data, opts) => {
-    const iv = opts.iv || Buffer.from((0, utils_1.randomBytes)(16)).toString("hex");
+    const iv = opts.iv || Buffer.from((0, utils_js_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 || Buffer.from((0, utils_1.randomBytes)(32)).toString("hex")
+        salt: opts.salt || Buffer.from((0, utils_js_1.randomBytes)(32)).toString("hex")
     };
-    const derivedKey = (0, scrypt_1.scrypt)(Buffer.from(password), Buffer.from(kdfparams.salt, "hex"), {
+    const derivedKey = (0, scrypt_js_1.scrypt)(Buffer.from(password), Buffer.from(kdfparams.salt, "hex"), {
         N: kdfparams.n,
         r: kdfparams.r,
         p: kdfparams.p,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jcc_wallet",
-  "version": "4.0.3",
+  "version": "4.0.4",
   "description": "Toolkit of wallet to manage multiple chains & support multiple keystores for each chain",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -53,8 +53,8 @@
     "@types/chai": "^4.3.16",
     "@types/jest": "^29.5.12",
     "@types/node": "^20.14.10",
-    "@typescript-eslint/eslint-plugin": "^7.12.0",
-    "@typescript-eslint/parser": "^7.12.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
     "babel-jest": "^29.7.0",
     "babel-loader": "^9.1.3",
     "chai": "^4.2.0",
@@ -80,25 +80,19 @@
     "pretty-quick": "^2.0.1",
     "sinon": "^17.0.1",
     "ts-loader": "^9.5.1",
-    "typescript": "^5.4.5",
-    "typescript-eslint": "^7.12.0",
+    "typescript": "5.7.2",
+    "typescript-eslint": "^8.48.1",
     "webpack": "^5.89.0",
     "webpack-bundle-analyzer": "^4.10.1",
     "webpack-cli": "^5.1.4"
   },
-  "resolutions": {
-    "@noble/curves": "^1.4.2",
-    "@noble/hashes": "^1.4.0",
-    "buffer": "^6.0.3"
-  },
   "dependencies": {
-    "@scure/bip32": "^1.4.0",
-    "base-x": "^4.0.0",
-    "bip39": "^3.0.4",
-    "bip44-constants": "^123.0.0",
+    "base-x": "^4.0.1",
+    "bip39": "^3.1.0",
+    "bip44-constants": "^396.0.0",
     "clone-deep": "^4.0.1",
-    "ethereum-cryptography": "^2.2.1",
-    "ethers": "^6.13.1",
+    "ethereum-cryptography": "^3.2.0",
+    "ethers": "^6.16.0",
     "lockr": "^0.8.5"
   },
   "sideEffects": false,