Upgrade @noble/ciphers, @noble/curves, @noble/hashes and @scure/bip39 to v2

CHANGELOG.md

@@ -9,6 +9,10 @@ and this project adheres to
 ### Changed
 
 - all: Drop support for Node.js < 22.
+- @cosmjs/crypto: Upgrade dependencies @noble/ciphers, @noble/curves,
+  @noble/hashes and @scure/bip39 to v2. ([#1935])
+
+[#1935]: https://github.com/cosmos/cosmjs/pull/1935
 
 ## [0.38.0] - 2025-12-30
 

packages/crypto/package.json

@@ -43,10 +43,10 @@
     "@cosmjs/encoding": "workspace:^",
     "@cosmjs/math": "workspace:^",
     "@cosmjs/utils": "workspace:^",
-    "@noble/ciphers": "^1.3.0",
-    "@noble/curves": "^1.9.2",
-    "@noble/hashes": "^1.8.0",
-    "@scure/bip39": "^1.6.0",
+    "@noble/ciphers": "^2.1.1",
+    "@noble/curves": "^2.0.1",
+    "@noble/hashes": "^2.0.1",
+    "@scure/bip39": "^2.0.1",
     "hash-wasm": "^4.12.0"
   },
   "devDependencies": {

packages/crypto/src/bip39.spec.ts

@@ -20,26 +20,26 @@ describe("Bip39", () => {
 
     it("throws for invalid input", () => {
       // invalid input length
-      expect(() => Bip39.encode(fromHex(""))).toThrowError(/got length/);
-      expect(() => Bip39.encode(fromHex("00"))).toThrowError(/got length/);
+      expect(() => Bip39.encode(fromHex(""))).toThrowError(/invalid entropy length/);
+      expect(() => Bip39.encode(fromHex("00"))).toThrowError(/invalid entropy length/);
       expect(() => Bip39.encode(fromHex("000000000000000000000000000000"))).toThrowError(
-        /expected of length .*, got length=15/,
+        /invalid entropy length/,
       );
       expect(() => Bip39.encode(fromHex("0000000000000000000000000000000000"))).toThrowError(
-        /expected of length .*, got length=17/,
+        /invalid entropy length/,
       );
       expect(() => Bip39.encode(fromHex("0000000000000000000000000000000000000000000000"))).toThrowError(
-        /got length/,
+        /invalid entropy length/,
       );
       expect(() => Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000"))).toThrowError(
-        /got length/,
+        /invalid entropy length/,
       );
       expect(() =>
         Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000000000")),
-      ).toThrowError(/got length/);
+      ).toThrowError(/invalid entropy length/);
       expect(() =>
         Bip39.encode(fromHex("000000000000000000000000000000000000000000000000000000000000000000")),
-      ).toThrowError(/got length/);
+      ).toThrowError(/invalid entropy length/);
     });
   });
 

packages/crypto/src/bip39.ts

@@ -1,6 +1,6 @@
 import { fixUint8Array } from "@cosmjs/encoding";
 import { entropyToMnemonic, mnemonicToEntropy, mnemonicToSeed } from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
 
 export class EnglishMnemonic {
   public static readonly wordlist: readonly string[] = wordlist;

packages/crypto/src/ed25519.spec.ts

@@ -72,13 +72,17 @@ describe("Libsodium", () => {
       {
         // seed too short
         const seed = fromHex("43a9c17ccbb0e767ea29ce1f10813afde5f1e0a7a504e89b4d2cc2b952b8e0");
-        await expectAsync(Ed25519.makeKeypair(seed)).toBeRejectedWithError(/key of length 32 expected/);
+        await expectAsync(Ed25519.makeKeypair(seed)).toBeRejectedWithError(
+          /"secretKey" expected Uint8Array of length 32, got length=31/,
+        );
       }
 
       {
         // seed too long
         const seed = fromHex("43a9c17ccbb0e767ea29ce1f10813afde5f1e0a7a504e89b4d2cc2b952b8e0b9aa");
-        await expectAsync(Ed25519.makeKeypair(seed)).toBeRejectedWithError(/key of length 32 expected/);
+        await expectAsync(Ed25519.makeKeypair(seed)).toBeRejectedWithError(
+          /"secretKey" expected Uint8Array of length 32, got length=33/,
+        );
       }
     });
 

packages/crypto/src/secp256k1.ts

@@ -1,6 +1,6 @@
 import { fixUint8Array, fromHex, toHex } from "@cosmjs/encoding";
 import { assert } from "@cosmjs/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 
 import { ExtendedSecp256k1Signature, Secp256k1Signature } from "./secp256k1signature";
 
@@ -41,7 +41,7 @@ export class Secp256k1 {
       throw new Error("input data is not a valid secp256k1 private key");
     }
 
-    if (!secp256k1.utils.isValidPrivateKey(privkey)) {
+    if (!secp256k1.utils.isValidSecretKey(privkey)) {
       // not strictly smaller than N
       throw new Error("input data is not a valid secp256k1 private key");
     }
@@ -71,9 +71,15 @@ export class Secp256k1 {
       throw new Error("Message hash length must not exceed 32 bytes");
     }
 
-    const { recovery, r, s } = secp256k1.sign(messageHash, privkey, {
-      lowS: true,
-    });
+    const signature = secp256k1.Signature.fromBytes(
+      secp256k1.sign(messageHash, privkey, {
+        prehash: false,
+        lowS: true,
+        format: "recovered",
+      }),
+      "recovered",
+    );
+    const { recovery, r, s } = signature;
     if (typeof recovery !== "number") throw new Error("Recovery param missing");
     return new ExtendedSecp256k1Signature(unsignedBigIntToBytes(r), unsignedBigIntToBytes(s), recovery);
   }
@@ -90,8 +96,11 @@ export class Secp256k1 {
       throw new Error("Message hash length must not exceed 32 bytes");
     }
 
-    const encodedSig = secp256k1.Signature.fromDER(signature.toDer());
-    return secp256k1.verify(encodedSig, messageHash, pubkey, { lowS: false });
+    return secp256k1.verify(signature.toDer(), messageHash, pubkey, {
+      prehash: false,
+      lowS: false,
+      format: "der",
+    });
   }
 
   public static recoverPubkey(

packages/crypto/src/slip10.ts

@@ -1,7 +1,7 @@
 import { fixUint8Array, fromHex, toAscii, toHex } from "@cosmjs/encoding";
 import { Uint32, Uint53 } from "@cosmjs/math";
 import { assert } from "@cosmjs/utils";
-import { secp256k1 } from "@noble/curves/secp256k1";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
 
 import { Hmac } from "./hmac";
 import { Sha512 } from "./sha";

packages/crypto/src/xchacha20poly1305.spec.ts

@@ -26,21 +26,21 @@ describe("Xchacha20poly1305Ietf", () => {
       // empty
       const key = fromHex("");
       await expectAsync(Xchacha20poly1305Ietf.encrypt(message, key, nonce)).toBeRejectedWithError(
-        /key, got length=0/,
+        /"arx key" expected Uint8Array of length 32, got length=0/,
       );
     }
     {
       // 31 bytes
       const key = fromHex("1324cdddc4b94e625bbabcac862c9429ba011e2184a1ccad60e7c3f6ff4916");
       await expectAsync(Xchacha20poly1305Ietf.encrypt(message, key, nonce)).toBeRejectedWithError(
-        /key, got length=31/,
+        /"arx key" expected Uint8Array of length 32, got length=31/,
       );
     }
     {
       // 33 bytes
       const key = fromHex("1324cdddc4b94e625bbabcac862c9429ba011e2184a1ccad60e7c3f6ff4916d8aa");
       await expectAsync(Xchacha20poly1305Ietf.encrypt(message, key, nonce)).toBeRejectedWithError(
-        /key, got length=33/,
+        /"arx key" expected Uint8Array of length 32, got length=33/,
       );
     }
     {
@@ -49,7 +49,7 @@ describe("Xchacha20poly1305Ietf", () => {
         "1324cdddc4b94e625bbabcac862c9429ba011e2184a1ccad60e7c3f6ff4916d81324cdddc4b94e625bbabcac862c9429ba011e2184a1ccad60e7c3f6ff4916d8",
       );
       await expectAsync(Xchacha20poly1305Ietf.encrypt(message, key, nonce)).toBeRejectedWithError(
-        /key, got length=64/,
+        /"arx key" expected Uint8Array of length 32, got length=64/,
       );
     }
   });