Move more utils into noble-hashes

Author: paulmillr

README.md

@@ -113,7 +113,7 @@ const { utf8ToBytes } = require("ethereum-cryptography/utils");
 sha256(utf8ToBytes("abc"))
 
 // If you need hex
-const { toHex } = require("ethereum-cryptography/utils");
+const { bytesToHex as toHex } = require("ethereum-cryptography/utils");
 toHex(sha256(utf8ToBytes("abc")))
 ```
 
@@ -208,7 +208,7 @@ Note: if you've been using ethereum-cryptography v0.1, it had different API. We'
 This module exports a single class `HDKey`, which should be used like this:
 
 ```ts
-const { HDKey } = require("ethereum-cryptography/secp256k1");
+const { HDKey } = require("ethereum-cryptography/hdkey");
 const hdkey1 = HDKey.fromMasterSeed(seed);
 const hdkey2 = HDKey.fromExtendedKey(base58key);
 const hdkey3 = HDKey.fromJSON({ xpriv: string });
@@ -269,17 +269,6 @@ but it's backed by this package's primitives, and has built-in TypeScript types.
 Its only difference is that it has to be be used with a named import.
 The implementation is [loosely based on hdkey, which has MIT License](#LICENSE).
 
-```js
-const { HDKey } = require("ethereum-cryptography/hdkey");
-const { hexToBytes } = require("ethereum-cryptography/utils");
-
-const seed = "fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542";
-const hdkey = HDKey.fromMasterSeed(hexToBytes(seed));
-const childkey = hdkey.derive("m/0/2147483647'/1");
-
-console.log(childkey.privateExtendedKey);
-```
-
 ## BIP39 Mnemonic Seed Phrase
 
 ```ts

package.json

@@ -24,8 +24,8 @@
     "*.d.ts.map"
   ],
   "dependencies": {
-    "micro-base": "^0.10.0",
-    "@noble/hashes": "^0.5.6",
+    "micro-base": "^0.10.1",
+    "@noble/hashes": "^0.5.7",
     "@noble/secp256k1": "^1.3.3"
   },
   "browser": {

src/hdkey.ts

@@ -2,16 +2,16 @@ import { hmac } from "@noble/hashes/hmac";
 import { ripemd160 } from "@noble/hashes/ripemd160";
 import { sha256 } from "@noble/hashes/sha256";
 import { sha512 } from "@noble/hashes/sha512";
-import { bytesToHex } from "@noble/hashes/utils";
-import { base58check } from "micro-base";
-import * as secp from "./secp256k1";
 import {
   assertBytes,
+  bytesToHex,
   concatBytes,
   createView,
   hexToBytes,
   utf8ToBytes
-} from "./utils";
+} from "@noble/hashes/utils";
+import { base58check } from "micro-base";
+import * as secp from "./secp256k1";
 const base58c = base58check(sha256);
 
 function bytesToNumber(bytes: Uint8Array): bigint {
@@ -41,7 +41,7 @@ const hash160 = (data: Uint8Array) => ripemd160(sha256(data));
 const fromU32 = (data: Uint8Array) => createView(data).getUint32(0, false);
 const toU32 = (n: number) => {
   if (!Number.isSafeInteger(n) || n < 0 || n > 2 ** 32 - 1) {
-    throw new Error(`Invalid number=${n}. Should be from 1 to 2 ** 32 - 1`);
+    throw new Error(`Invalid number=${n}. Should be from 0 to 2 ** 32 - 1`);
   }
   const buf = new Uint8Array(4);
   createView(buf).setUint32(0, n, false);

src/secp256k1.ts

@@ -10,7 +10,8 @@ export {
   utils,
   Point,
   Signature,
-  CURVE
+  CURVE,
+  schnorr
 } from "@noble/secp256k1";
 
 // Enable sync API for noble-secp256k1

src/utils.ts

@@ -1,39 +1,24 @@
 // buf.toString('hex') -> toHex(buf)
 import { assertBytes } from "@noble/hashes/utils";
 export {
+  assertBool,
   assertBytes,
+  bytesToHex,
   bytesToHex as toHex,
-  createView
+  concatBytes,
+  hexToBytes,
+  createView,
+  utf8ToBytes
 } from "@noble/hashes/utils";
-// Buffer.from(hex, 'hex') -> hexToBytes(hex)
-export function hexToBytes(hex: string): Uint8Array {
-  if (typeof hex !== "string") {
-    throw new TypeError(`hexToBytes: expected string, got ${typeof hex}`);
-  }
-  if (hex.length % 2) {
-    throw new Error("hexToBytes: received invalid unpadded hex");
-  }
-  const array = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < array.length; i++) {
-    const j = i * 2;
-    array[i] = Number.parseInt(hex.slice(j, j + 2), 16);
-  }
-  return array;
-}
-// Buffer.from(s, 'utf8') -> utf8ToBytes(s)
-export function utf8ToBytes(s: string) {
-  if (typeof s !== "string") {
-    throw new TypeError(`utf8ToBytes expected string, got ${typeof s}`);
-  }
-  return new TextEncoder().encode(s);
-}
+
 // buf.toString('utf8') -> bytesToUtf8(buf)
 export function bytesToUtf8(data: Uint8Array): string {
   if (!(data instanceof Uint8Array)) {
     throw new TypeError(`bytesToUtf8 expected Uint8Array, got ${typeof data}`);
   }
   return new TextDecoder().decode(data);
 }
+
 // buf.equals(buf2) -> equalsBytes(buf, buf2)
 export function equalsBytes(a: Uint8Array, b: Uint8Array): boolean {
   if (a.length !== b.length) {
@@ -46,27 +31,8 @@ export function equalsBytes(a: Uint8Array, b: Uint8Array): boolean {
   }
   return true;
 }
-// Buffer.concat([buf1, buf2]) -> concatBytes(buf1, buf2)
-export function concatBytes(...arrays: Uint8Array[]): Uint8Array {
-  if (arrays.length === 1) {
-    return arrays[0];
-  }
-  const length = arrays.reduce((a, arr) => a + arr.length, 0);
-  const result = new Uint8Array(length);
-  for (let i = 0, pad = 0; i < arrays.length; i++) {
-    const arr = arrays[i];
-    result.set(arr, pad);
-    pad += arr.length;
-  }
-  return result;
-}
-// Internal utils
-export function assertBool(b: boolean) {
-  if (typeof b !== "boolean") {
-    throw new Error(`Expected boolean, not ${b}`);
-  }
-}
 
+// Internal utils
 export function wrapHash(hash: (msg: Uint8Array) => Uint8Array) {
   return (msg: Uint8Array) => {
     assertBytes(msg);