@exodus/bytes 1.0.0-rc.6 → 1.0.0-rc.8

package/README.md

@@ -1,11 +1,27 @@
 # `@exodus/bytes`
 
-`Uint8Array` conversion to and from `base64`, `base32`, `hex` and `utf8`
+`Uint8Array` conversion to and from `base64`, `base32`, `base58`, `hex`, and `utf8`
 
 [Fast](./Performance.md)
 
 Performs proper input validation
 
+## API
+
+### `@exodus/bytes/hex.js`
+
+### `@exodus/bytes/base64.js`
+
+### `@exodus/bytes/base32.js`
+
+### `@exodus/bytes/hex.js`
+
+### `@exodus/bytes/base58.js`
+
+### `@exodus/bytes/base58check.js`
+
+### `@exodus/bytes/wif.js`
+
 ## License
 
 [MIT](./LICENSE)

package/base58.js

@@ -1,7 +1,7 @@
 import { typedView } from './array.js'
 import { assertUint8 } from './assert.js'
-import { nativeDecoder, nativeEncoder } from './fallback/_utils.js'
-import { encodeAscii } from './fallback/latin1.js'
+import { nativeDecoder, nativeEncoder, isHermes } from './fallback/_utils.js'
+import { encodeAscii, decodeAscii } from './fallback/latin1.js'
 
 const alphabet = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
 const codes = new Uint8Array(alphabet.map((x) => x.charCodeAt(0)))
@@ -20,7 +20,7 @@ let fromMap
 
 const E_CHAR = 'Invalid character in base58 input'
 
-const shouldUseBigIntFrom = Boolean(globalThis.HermesInternal) // faster only on Hermes, numbers path beats it on normal engines
+const shouldUseBigIntFrom = isHermes // faster only on Hermes, numbers path beats it on normal engines
 
 export function toBase58(arr) {
   assertUint8(arr)
@@ -104,7 +104,7 @@ export function toBase58(arr) {
     while (carry) {
       const c = carry
       carry = Math.floor(c / 58)
-      res[i++] = c - carry * 58
+      res.push(c - carry * 58)
     }
   }
 
@@ -112,7 +112,7 @@ export function toBase58(arr) {
     const oa = new Uint8Array(res.length)
     let j = 0
     for (let i = res.length - 1; i >= 0; i--) oa[j++] = codes[res[i]]
-    return ZERO.repeat(zeros) + nativeDecoder.decode(oa)
+    return ZERO.repeat(zeros) + decodeAscii(oa)
   }
 
   let out = ''
@@ -134,7 +134,7 @@ export function fromBase58(str, format = 'uint8') {
     for (let i = 0; i < 58; i++) fromMap[alphabet[i].charCodeAt(0)] = i
   }
 
-  const size = zeros + (((length - zeros) * 3 + 1) >> 2) // 3/4 rounded up, larger than ~0.73 coef to fit everything
+  const size = zeros + (((length - zeros + 1) * 3) >> 2) // 3/4 rounded up, larger than ~0.73 coef to fit everything
   const res = new Uint8Array(size)
   let at = size // where is the first significant byte written
 

package/base58check.js

@@ -1,7 +1,7 @@
 import { typedView } from './array.js'
 import { assertUint8 } from './assert.js'
 import { toBase58, fromBase58 } from './base58.js'
-import { hashSync } from '@exodus/crypto/hash'
+import { hashSync } from '@exodus/crypto/hash' // eslint-disable-line @exodus/import/no-deprecated
 
 // Note: while API is async, we use hashSync for now until we improve webcrypto perf for hash256
 // Inputs to base58 are typically very small, and that makes a difference
@@ -56,6 +56,7 @@ export const makeBase58check = (hashAlgo, hashAlgoSync) => {
   }
 }
 
+// eslint-disable-next-line @exodus/import/no-deprecated
 const hash256sync = (x) => hashSync('sha256', hashSync('sha256', x, 'uint8'), 'uint8')
 const hash256 = hash256sync // See note at the top
 const {

package/base64.js

@@ -1,5 +1,6 @@
 import { assertUint8, assertEmptyRest } from './assert.js'
 import { typedView } from './array.js'
+import { isHermes, skipWeb } from './fallback/_utils.js'
 import { decodeLatin1, encodeLatin1 } from './fallback/latin1.js'
 import * as js from './fallback/base64.js'
 
@@ -15,8 +16,8 @@ const { toBase64: web64 } = Uint8Array.prototype // Modern engines have this
 const { E_CHAR, E_PADDING, E_LENGTH, E_LAST } = js
 
 // faster only on Hermes (and a little in old Chrome), js path beats it on normal engines
-const shouldUseBtoa = btoa && Boolean(globalThis.HermesInternal)
-const shouldUseAtob = atob && Boolean(globalThis.HermesInternal)
+const shouldUseBtoa = btoa && isHermes
+const shouldUseAtob = atob && isHermes
 
 // For native Buffer codepaths only
 const isBuffer = (x) => x.constructor === Buffer && Buffer.isBuffer(x)
@@ -33,13 +34,12 @@ function maybePad(res, padding) {
 }
 
 const toUrl = (x) => x.replaceAll('+', '-').replaceAll('/', '_')
-const fromUrl = (x) => x.replaceAll('-', '+').replaceAll('_', '/')
-const haveWeb = (x) => web64 && x.toBase64 === web64
+const haveWeb = (x) => !skipWeb && web64 && x.toBase64 === web64
 
 export function toBase64(x, { padding = true } = {}) {
   assertUint8(x)
   if (haveWeb(x)) return padding ? x.toBase64() : x.toBase64({ omitPadding: !padding }) // Modern, optionless is slightly faster
-  if (haveNativeBuffer) return maybeUnpad(toBuffer(x).toString('base64'), padding) // Older Node.js
+  if (haveNativeBuffer) return maybeUnpad(toBuffer(x).base64Slice(0, x.byteLength), padding) // Older Node.js
   if (shouldUseBtoa) return maybeUnpad(btoa(decodeLatin1(x)), padding)
   return js.toBase64(x, false, padding) // Fallback
 }
@@ -48,7 +48,7 @@ export function toBase64(x, { padding = true } = {}) {
 export function toBase64url(x, { padding = false } = {}) {
   assertUint8(x)
   if (haveWeb(x)) return x.toBase64({ alphabet: 'base64url', omitPadding: !padding }) // Modern
-  if (haveNativeBuffer) return maybePad(toBuffer(x).toString('base64url'), padding) // Older Node.js
+  if (haveNativeBuffer) return maybePad(toBuffer(x).base64urlSlice(0, x.byteLength), padding) // Older Node.js
   if (shouldUseBtoa) return maybeUnpad(toUrl(btoa(decodeLatin1(x))), padding)
   return js.toBase64(x, true, padding) // Fallback
 }
@@ -111,7 +111,7 @@ function noWhitespaceSeen(str, arr) {
 }
 
 let fromBase64impl
-if (Uint8Array.fromBase64) {
+if (!skipWeb && Uint8Array.fromBase64) {
   // NOTICE: this is actually slower than our JS impl in older JavaScriptCore and (slightly) in SpiderMonkey, but faster on V8 and new JavaScriptCore
   fromBase64impl = (str, isBase64url, padding) => {
     const alphabet = isBase64url ? 'base64url' : 'base64'
@@ -137,40 +137,41 @@ if (Uint8Array.fromBase64) {
     if (!noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR)
     return arr
   }
-} else {
+} else if (haveNativeBuffer) {
+  fromBase64impl = (str, isBase64url, padding) => {
+    const arr = Buffer.from(str, 'base64')
+    // Rechecking by re-encoding is cheaper than regexes on Node.js
+    const got = isBase64url ? maybeUnpad(str, padding === false) : maybePad(str, padding !== true)
+    const valid = isBase64url ? arr.base64urlSlice(0, arr.length) : arr.base64Slice(0, arr.length)
+    if (got !== valid) throw new SyntaxError(E_PADDING)
+    return arr // fully checked
+  }
+} else if (shouldUseAtob) {
+  // atob is faster than manual parsing on Hermes
   fromBase64impl = (str, isBase64url, padding) => {
     let arr
-    if (haveNativeBuffer) {
-      arr = Buffer.from(str, 'base64')
-      // Rechecking is cheaper than regexes on Node.js
-      const r = isBase64url ? maybeUnpad(str, padding === false) : maybePad(str, padding !== true)
-      if (r !== arr.toString(isBase64url ? 'base64url' : 'base64')) throw new SyntaxError(E_PADDING)
-    } else if (shouldUseAtob) {
-      // atob is faster than manual parsing on Hermes
-      if (isBase64url) {
-        if (/[\t\n\f\r +/]/.test(str)) throw new SyntaxError(E_CHAR) // atob verifies other invalid input
-        str = fromUrl(str)
-      }
-
-      try {
-        arr = encodeLatin1(atob(str))
-      } catch {
-        throw new SyntaxError(E_CHAR) // convert atob errors
-      }
+    if (isBase64url) {
+      if (/[\t\n\f\r +/]/.test(str)) throw new SyntaxError(E_CHAR) // atob verifies other invalid input
+      str = str.replaceAll('-', '+').replaceAll('_', '/') // from url to normal
+    }
 
-      if (!isBase64url && !noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR) // base64url checks input above
-    } else {
-      return js.fromBase64(str, isBase64url) // early return to skip last chunk verification, it's already validated in js
+    try {
+      arr = encodeLatin1(atob(str))
+    } catch {
+      throw new SyntaxError(E_CHAR) // convert atob errors
     }
 
+    if (!isBase64url && !noWhitespaceSeen(str, arr)) throw new SyntaxError(E_CHAR) // base64url checks input above
+
     if (arr.length % 3 !== 0) {
       // Check last chunk to be strict if it was incomplete
-      const expected = toBase64(arr.subarray(-(arr.length % 3)))
+      const expected = toBase64(arr.subarray(-(arr.length % 3))) // str is normalized to non-url already
       const end = str.length % 4 === 0 ? str.slice(-4) : str.slice(-(str.length % 4)).padEnd(4, '=')
-      const actual = isBase64url ? fromUrl(end) : end
-      if (expected !== actual) throw new SyntaxError(E_LAST)
+      if (expected !== end) throw new SyntaxError(E_LAST)
     }
 
     return arr
   }
+} else {
+  fromBase64impl = (str, isBase64url, padding) => js.fromBase64(str, isBase64url) // validated in js
 }

package/bech32.js

@@ -0,0 +1,254 @@
+import { assertUint8 } from './assert.js'
+import { nativeEncoder } from './fallback/_utils.js'
+import { decodeAscii, encodeAscii, encodeLatin1 } from './fallback/latin1.js'
+
+const alphabet = [...'qpzry9x8gf2tvdw0s3jn54khce6mua7l']
+const BECH32 = 1
+const BECH32M = 0x2b_c8_30_a3
+
+const E_SIZE = 'Input length is out of range'
+const E_PREFIX = 'Missing or invalid prefix'
+const E_MIXED = 'Mixed-case string'
+const E_PADDING = 'Padding is invalid'
+const E_CHECKSUM = 'Invalid checksum'
+const E_CHARACTER = 'Non-bech32 character'
+const E_STRING = 'Input is not a string'
+
+// nativeEncoder path uses encodeAscii which asserts ascii, otherwise we have 0-255 bytes from encodeLatin1
+const c2x = new Int8Array(nativeEncoder ? 128 : 256).fill(-1)
+const x2c = new Uint8Array(32)
+for (let i = 0; i < alphabet.length; i++) {
+  const c = alphabet[i].charCodeAt(0)
+  c2x[c] = i
+  x2c[i] = c
+}
+
+// checksum size is 30 bits, 0x3f_ff_ff_ff
+// The good thing about the checksum is that it's linear over every bit
+const poly0 = new Uint32Array(32) // just precache all possible ones, it's only 1 KiB
+const p = (x) => ((x & 0x1_ff_ff_ff) << 5) ^ poly0[x >> 25]
+for (let i = 0; i < 32; i++) {
+  poly0[i] =
+    (i & 0b0_0001 ? 0x3b_6a_57_b2 : 0) ^
+    (i & 0b0_0010 ? 0x26_50_8e_6d : 0) ^
+    (i & 0b0_0100 ? 0x1e_a1_19_fa : 0) ^
+    (i & 0b0_1000 ? 0x3d_42_33_dd : 0) ^
+    (i & 0b1_0000 ? 0x2a_14_62_b3 : 0)
+}
+
+// 7 KiB more for faster p6/p8
+const poly1 = new Uint32Array(32)
+const poly2 = new Uint32Array(32)
+const poly3 = new Uint32Array(32)
+const poly4 = new Uint32Array(32)
+const poly5 = new Uint32Array(32)
+const poly6 = new Uint32Array(32)
+const poly7 = new Uint32Array(32)
+for (let i = 0; i < 32; i++) {
+  // poly0[i] === p(p(p(p(p(p(i))))))
+  poly1[i] = p(poly0[i]) // aka p(p(p(p(p(p(i << 5))))))
+  poly2[i] = p(poly1[i]) // aka p(p(p(p(p(p(i << 10))))))
+  poly3[i] = p(poly2[i]) // aka p(p(p(p(p(p(i << 15))))))
+  poly4[i] = p(poly3[i]) // aka p(p(p(p(p(p(i << 20))))))
+  poly5[i] = p(poly4[i]) // aka p(p(p(p(p(p(i << 25))))))
+  poly6[i] = p(poly5[i])
+  poly7[i] = p(poly6[i])
+}
+
+function p6(x) {
+  // Same as: return p(p(p(p(p(p(x))))))
+  const x0 = x & 0x1f
+  const x1 = (x >> 5) & 0x1f
+  const x2 = (x >> 10) & 0x1f
+  const x3 = (x >> 15) & 0x1f
+  const x4 = (x >> 20) & 0x1f
+  const x5 = (x >> 25) & 0x1f
+  return poly0[x0] ^ poly1[x1] ^ poly2[x2] ^ poly3[x3] ^ poly4[x4] ^ poly5[x5]
+}
+
+function p8(x) {
+  // Same as: return p(p(p(p(p(p(p(p(x))))))))
+  const x0 = x & 0x1f
+  const x1 = (x >> 5) & 0x1f
+  const x2 = (x >> 10) & 0x1f
+  const x3 = (x >> 15) & 0x1f
+  const x4 = (x >> 20) & 0x1f
+  const x5 = (x >> 25) & 0x1f
+  return poly2[x0] ^ poly3[x1] ^ poly4[x2] ^ poly5[x3] ^ poly6[x4] ^ poly7[x5]
+}
+
+// p(p(p(p(p(p(chk) ^ x0) ^ x1) ^ x2) ^ x3) ^ x4) ^ x5 === p6(chk) ^ merge(x0, x1, x2, x3, x4, x5)
+const merge = (a, b, c, d, e, f) => f ^ (e << 5) ^ (d << 10) ^ (c << 15) ^ (b << 20) ^ (a << 25)
+
+const prefixCache = new Map() // Cache 10 of them
+
+function pPrefix(prefix) {
+  if (prefix === 'bc') return 0x2_31_80_43 // perf
+  const cached = prefixCache.get(prefix)
+  if (cached !== undefined) return cached
+
+  // bech32_hrp_expand(s): [ord(x) >> 5 for x in s] + [0] + [ord(x) & 31 for x in s]
+  // We can do this in a single scan due to linearity, but it's not very beneficial
+  let chk = 1 // it starts with one (see def bech32_polymod in BIP_0173)
+  const length = prefix.length
+  for (let i = 0; i < length; i++) {
+    const c = prefix.charCodeAt(i)
+    if (c < 33 || c > 126) throw new Error(E_PREFIX) // each character having a value in the range [33-126]
+    chk = p(chk) ^ (c >> 5)
+  }
+
+  chk = p(chk) // <= for + [0]
+  for (let i = 0; i < length; i++) {
+    const c = prefix.charCodeAt(i)
+    chk = p(chk) ^ (c & 0x1f)
+  }
+
+  if (prefixCache.size < 10) prefixCache.set(prefix, chk)
+  return chk
+}
+
+function toBech32enc(prefix, bytes, limit, encoding) {
+  if (typeof prefix !== 'string' || !prefix) throw new TypeError(E_PREFIX)
+  if (typeof limit !== 'number') throw new TypeError(E_SIZE)
+  assertUint8(bytes)
+  const bytesLength = bytes.length
+  const wordsLength = Math.ceil((bytesLength * 8) / 5)
+  if (!(prefix.length + 7 + wordsLength <= limit)) throw new TypeError(E_SIZE)
+  prefix = prefix.toLowerCase()
+  const out = new Uint8Array(wordsLength + 6)
+
+  let chk = pPrefix(prefix)
+  let i = 0, j = 0 // prettier-ignore
+
+  // This loop is just an optimization of the next one
+  for (const length4 = bytesLength - 4; i < length4; i += 5, j += 8) {
+    const b0 = bytes[i], b1 = bytes[i + 1], b2 = bytes[i + 2], b3 = bytes[i + 3], b4 = bytes[i + 4] // prettier-ignore
+    const x0 = b0 >> 3
+    const x1 = ((b0 << 2) & 0x1f) | (b1 >> 6)
+    const x2 = (b1 >> 1) & 0x1f
+    const x3 = ((b1 << 4) & 0x1f) | (b2 >> 4)
+    const x4 = ((b2 << 1) & 0x1f) | (b3 >> 7)
+    const x5 = (b3 >> 2) & 0x1f
+    const x6 = ((b3 << 3) & 0x1f) | (b4 >> 5)
+    const x7 = b4 & 0x1f
+    chk = merge(x2, x3, x4, x5, x6, x7) ^ poly0[x1] ^ poly1[x0] ^ p8(chk)
+    out[j] = x2c[x0]
+    out[j + 1] = x2c[x1]
+    out[j + 2] = x2c[x2]
+    out[j + 3] = x2c[x3]
+    out[j + 4] = x2c[x4]
+    out[j + 5] = x2c[x5]
+    out[j + 6] = x2c[x6]
+    out[j + 7] = x2c[x7]
+  }
+
+  let value = 0, bits = 0 // prettier-ignore
+  for (; i < bytesLength; i++) {
+    value = ((value & 0xf) << 8) | bytes[i]
+    bits += 3
+    const x = (value >> bits) & 0x1f
+    chk = p(chk) ^ x
+    out[j++] = x2c[x]
+    if (bits >= 5) {
+      bits -= 5
+      const x = (value >> bits) & 0x1f
+      chk = p(chk) ^ x
+      out[j++] = x2c[x]
+    }
+  }
+
+  if (bits > 0) {
+    const x = (value << (5 - bits)) & 0x1f
+    chk = p(chk) ^ x
+    out[j++] = x2c[x]
+  }
+
+  chk = encoding ^ p6(chk)
+  out[j++] = x2c[(chk >> 25) & 0x1f]
+  out[j++] = x2c[(chk >> 20) & 0x1f]
+  out[j++] = x2c[(chk >> 15) & 0x1f]
+  out[j++] = x2c[(chk >> 10) & 0x1f]
+  out[j++] = x2c[(chk >> 5) & 0x1f]
+  out[j++] = x2c[(chk >> 0) & 0x1f]
+
+  return prefix + '1' + decodeAscii(out) // suboptimal in barebones, but actually ok in Hermes for not to care atm
+}
+
+function assertDecodeArgs(str, limit) {
+  if (typeof str !== 'string') throw new TypeError(E_STRING)
+  if (typeof limit !== 'number' || str.length < 8 || !(str.length <= limit)) throw new Error(E_SIZE)
+}
+
+function fromBech32enc(str, limit, encoding) {
+  assertDecodeArgs(str, limit)
+  const lower = str.toLowerCase()
+  if (str !== lower) {
+    if (str !== str.toUpperCase()) throw new Error(E_MIXED)
+    str = lower
+  }
+
+  const split = str.lastIndexOf('1')
+  if (split <= 0) throw new Error(E_PREFIX)
+  const prefix = str.slice(0, split)
+  const charsLength = str.length - split - 1
+  const wordsLength = charsLength - 6
+  if (wordsLength < 0) throw new Error(E_SIZE)
+  const bytesLength = (wordsLength * 5) >> 3
+  const slice = str.slice(split + 1)
+  const c = nativeEncoder ? encodeAscii(slice, E_CHARACTER) : encodeLatin1(slice) // suboptimal, but only affects non-Hermes barebones
+  const bytes = new Uint8Array(bytesLength)
+
+  let chk = pPrefix(prefix)
+  let i = 0, j = 0 // prettier-ignore
+
+  // This loop is just an optimization of the next one
+  for (const length7 = wordsLength - 7; i < length7; i += 8, j += 5) {
+    const c0 = c[i], c1 = c[i + 1], c2 = c[i + 2], c3 = c[i + 3], c4 = c[i + 4], c5 = c[i + 5], c6 = c[i + 6], c7 = c[i + 7] // prettier-ignore
+    const x0 = c2x[c0], x1 = c2x[c1], x2 = c2x[c2], x3 = c2x[c3], x4 = c2x[c4], x5 = c2x[c5], x6 = c2x[c6], x7 = c2x[c7] // prettier-ignore
+    if (x0 < 0 || x1 < 0 || x2 < 0 || x3 < 0 || x4 < 0 || x5 < 0 || x6 < 0 || x7 < 0) throw new SyntaxError(E_CHARACTER) // prettier-ignore
+    chk = merge(x2, x3, x4, x5, x6, x7) ^ poly0[x1] ^ poly1[x0] ^ p8(chk)
+    bytes[j] = (x0 << 3) | (x1 >> 2)
+    bytes[j + 1] = (((x1 << 6) | (x2 << 1)) & 0xff) | (x3 >> 4)
+    bytes[j + 2] = ((x3 << 4) & 0xff) | (x4 >> 1)
+    bytes[j + 3] = ((((x4 << 5) | x5) << 2) & 0xff) | (x6 >> 3)
+    bytes[j + 4] = ((x6 << 5) & 0xff) | x7
+  }
+
+  let value = 0, bits = 0 // prettier-ignore
+  for (; i < wordsLength; i++) {
+    const x = c2x[c[i]]
+    if (x < 0) throw new SyntaxError(E_CHARACTER)
+    chk = p(chk) ^ x
+    value = (value << 5) | x
+    bits += 5
+    if (bits >= 8) {
+      bits -= 8
+      bytes[j++] = (value >> bits) & 0xff
+    }
+  }
+
+  if (bits >= 5 || (value << (8 - bits)) & 0xff) throw new Error(E_PADDING)
+
+  // Checksum
+  {
+    const c0 = c[i], c1 = c[i + 1], c2 = c[i + 2], c3 = c[i + 3], c4 = c[i + 4], c5 = c[i + 5] // prettier-ignore
+    const x0 = c2x[c0], x1 = c2x[c1], x2 = c2x[c2], x3 = c2x[c3], x4 = c2x[c4], x5 = c2x[c5] // prettier-ignore
+    if (x0 < 0 || x1 < 0 || x2 < 0 || x3 < 0 || x4 < 0 || x5 < 0) throw new SyntaxError(E_CHARACTER)
+    if ((merge(x0, x1, x2, x3, x4, x5) ^ p6(chk)) !== encoding) throw new Error(E_CHECKSUM)
+  }
+
+  return { prefix, bytes }
+}
+
+// This is designed to be a very quick check, skipping all other validation
+export function getPrefix(str, limit = 90) {
+  assertDecodeArgs(str, limit)
+  const split = str.lastIndexOf('1')
+  if (split <= 0) throw new Error(E_PREFIX)
+  return str.slice(0, split).toLowerCase()
+}
+
+export const toBech32 = (prefix, bytes, limit = 90) => toBech32enc(prefix, bytes, limit, BECH32)
+export const fromBech32 = (str, limit = 90) => fromBech32enc(str, limit, BECH32)
+export const toBech32m = (prefix, bytes, limit = 90) => toBech32enc(prefix, bytes, limit, BECH32M)
+export const fromBech32m = (str, limit = 90) => fromBech32enc(str, limit, BECH32M)

package/fallback/_utils.js

@@ -3,4 +3,38 @@ const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]')) // we consider Node.js TextDecoder/TextEncoder native
 const nativeEncoder = isNative(TextEncoder) ? new TextEncoder() : null
 const nativeDecoder = isNative(TextDecoder) ? new TextDecoder('utf8', { ignoreBOM: true }) : null
-export { nativeEncoder, nativeDecoder }
+const nativeBuffer = haveNativeBuffer ? Buffer : null
+const isHermes = Boolean(globalThis.HermesInternal)
+
+// Actually windows-1252, compatible with ascii and latin1 decoding
+// Beware that on non-latin1, i.e. on windows-1252, this is broken in ~all Node.js versions released
+// in 2025 due to a regression, so we call it Latin1 as it's usable only for that
+const nativeDecoderLatin1 = isNative(TextDecoder)
+  ? new TextDecoder('latin1', { ignoreBOM: true })
+  : null
+
+// Block Firefox < 146 specifically from using native hex/base64, as it's very slow there
+// Refs: https://bugzilla.mozilla.org/show_bug.cgi?id=1994067 (and linked issues), fixed in 146
+// Before that, all versions of Firefox >= 133 are slow
+// TODO: this could be removed when < 146 usage diminishes (note ESR)
+// We do not worry about false-negatives here but worry about false-positives!
+function shouldSkipBuiltins() {
+  const g = globalThis
+  // First, attempt to exclude as many things as we can using trivial checks, just in case, and to not hit ua
+  if (haveNativeBuffer || isHermes || !g.window || g.chrome || !g.navigator) return false
+  try {
+    // This was fixed specifically in Firefox 146. Other engines except Hermes (already returned) get this right
+    new WeakSet().add(Symbol()) // eslint-disable-line symbol-description
+    return false
+  } catch {
+    // In catch and not after in case if something too smart optimizes out code in try. False-negative is acceptable in that case
+    if (!('onmozfullscreenerror' in g)) return false // Firefox has it (might remove in the future, but we don't care)
+    return /firefox/i.test(g.navigator.userAgent || '') // as simple as we can
+  }
+
+  return false // eslint-disable-line no-unreachable
+}
+
+const skipWeb = shouldSkipBuiltins()
+
+export { nativeEncoder, nativeDecoder, nativeDecoderLatin1, nativeBuffer, isHermes, skipWeb }

package/fallback/base32.js

@@ -1,6 +1,6 @@
 import { assertUint8 } from '../assert.js'
-import { nativeEncoder, nativeDecoder } from './_utils.js'
-import { encodeAscii } from './latin1.js'
+import { nativeEncoder, nativeDecoder, isHermes } from './_utils.js'
+import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
@@ -14,7 +14,7 @@ export const E_PADDING = 'Invalid base32 padding'
 export const E_LENGTH = 'Invalid base32 length'
 export const E_LAST = 'Invalid last chunk'
 
-const useTemplates = Boolean(globalThis.HermesInternal) // Faster on Hermes and JSC, but we use it only on Hermes
+const useTemplates = isHermes // Faster on Hermes and JSC, but we use it only on Hermes
 
 // We construct output by concatenating chars, this seems to be fine enough on modern JS engines
 export function toBase32(arr, isBase32Hex, padding) {
@@ -68,7 +68,7 @@ export function toBase32(arr, isBase32Hex, padding) {
       j += 4
     }
 
-    o = nativeDecoder.decode(oa)
+    o = decodeAscii(oa)
   } else if (useTemplates) {
     // Templates are faster only on Hermes and JSC. Browsers have TextDecoder anyway
     for (; i < fullChunksBytes; i += 5) {

package/fallback/base64.js

@@ -1,6 +1,6 @@
 import { assertUint8 } from '../assert.js'
 import { nativeEncoder, nativeDecoder } from './_utils.js'
-import { encodeAscii } from './latin1.js'
+import { encodeAscii, decodeAscii } from './latin1.js'
 
 // See https://datatracker.ietf.org/doc/html/rfc4648
 
@@ -82,7 +82,7 @@ export function toBase64(arr, isURL, padding) {
       oa[j + 1] = codepairs[((b & 0x0f) << 8) | c]
     }
 
-    o = nativeDecoder.decode(oa)
+    o = decodeAscii(oa)
   } else {
     // This can be optimized by ~25% with templates on Hermes, but this codepath is not called on Hermes, it uses btoa
     // Check git history for templates version

package/fallback/hex.js

@@ -1,6 +1,6 @@
 import { assertUint8 } from '../assert.js'
-import { nativeDecoder, nativeEncoder } from './_utils.js'
-import { encodeAscii } from './latin1.js'
+import { nativeDecoder, nativeEncoder, isHermes } from './_utils.js'
+import { encodeAscii, decodeAscii } from './latin1.js'
 
 let hexArray // array of 256 bytes converted to two-char hex strings
 let hexCodes // hexArray converted to u16 code pairs
@@ -61,7 +61,7 @@ function toHexPartTemplates(a, start, end) {
 
 // Using templates is significantly faster in Hermes and JSC
 // It's harder to detect JSC and not important anyway as it has native impl, so we detect only Hermes
-const toHexPart = globalThis.HermesInternal ? toHexPartTemplates : toHexPartAddition
+const toHexPart = isHermes ? toHexPartTemplates : toHexPartAddition
 
 export function toHex(arr) {
   assertUint8(arr)
@@ -97,7 +97,7 @@ export function toHex(arr) {
     }
 
     for (; i < length; i++) oa[i] = hexCodes[arr[i]]
-    return nativeDecoder.decode(oa)
+    return decodeAscii(oa)
   }
 
   if (length > 30_000) {

package/fallback/latin1.js

@@ -1,4 +1,10 @@
-import { nativeEncoder } from './_utils.js'
+import {
+  nativeEncoder,
+  nativeDecoder,
+  nativeDecoderLatin1,
+  nativeBuffer,
+  isHermes,
+} from './_utils.js'
 
 // See http://stackoverflow.com/a/22747272/680742, which says that lowest limit is in Chrome, with 0xffff args
 // On Hermes, actual max is 0x20_000 minus current stack depth, 1/16 of that should be safe
@@ -32,6 +38,7 @@ export function asciiPrefix(arr) {
   return length
 }
 
+// Capable of decoding Uint16Array to UTF-16 as well as Uint8Array to Latin-1
 export function decodeLatin1(arr, start = 0, stop = arr.length) {
   start |= 0
   stop |= 0
@@ -52,10 +59,23 @@ export function decodeLatin1(arr, start = 0, stop = arr.length) {
   return String.fromCharCode.apply(String, sliced)
 }
 
-export const encodeLatin1 = globalThis.HermesInternal
-  ? (str) => {
+// Does not check input, uses best available method
+// Building an array for this is only faster than proper string concatenation when TextDecoder or native Buffer are available
+export const decodeAscii = nativeBuffer
+  ? (a) =>
+      // Buffer is faster on Node.js (but only for long enough data), if we know that output is ascii
+      a.byteLength >= 0x3_00
+        ? nativeBuffer.from(a.buffer, a.byteOffset, a.byteLength).latin1Slice(0, a.byteLength) // .latin1Slice is faster than .asciiSlice
+        : nativeDecoder.decode(a) // On Node.js, utf8 decoder is faster than latin1
+  : nativeDecoderLatin1
+    ? (a) => nativeDecoderLatin1.decode(a) // On browsers (specifically WebKit), latin1 decoder is faster than utf8
+    : (a) => decodeLatin1(new Uint8Array(a.buffer, a.byteOffset, a.byteLength)) // Fallback. We shouldn't get here, constructing with strings directly is faster
+
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+
+export const encodeCharcodes = isHermes
+  ? (str, arr) => {
       const length = str.length
-      const arr = new Uint8Array(length)
       if (length > 64) {
         const at = str.charCodeAt.bind(str) // faster on strings from ~64 chars on Hermes, but can be 10x slower on e.g. JSC
         for (let i = 0; i < length; i++) arr[i] = at(i)
@@ -65,16 +85,19 @@ export const encodeLatin1 = globalThis.HermesInternal
 
       return arr
     }
-  : (str) => {
+  : (str, arr) => {
       const length = str.length
-      const arr = new Uint8Array(length)
       // Can be optimized with unrolling, but this is not used on non-Hermes atm
       for (let i = 0; i < length; i++) arr[i] = str.charCodeAt(i)
       return arr
     }
 
+/* eslint-enable @exodus/mutable/no-param-reassign-prop-only */
+
+export const encodeLatin1 = (str) => encodeCharcodes(str, new Uint8Array(str.length))
+
 // Expects nativeEncoder to be present
-export const encodeAscii = globalThis.HermesInternal
+export const encodeAscii = isHermes
   ? (str, ERR) => {
       // Much faster in Hermes
       const codes = new Uint8Array(str.length + 4) // overshoot by a full utf8 char
@@ -82,8 +105,15 @@ export const encodeAscii = globalThis.HermesInternal
       if (info.read !== str.length || info.written !== str.length) throw new SyntaxError(ERR) // non-ascii
       return codes.subarray(0, str.length)
     }
-  : (str, ERR) => {
-      const codes = nativeEncoder.encode(str)
-      if (codes.length !== str.length) throw new SyntaxError(ERR) // non-ascii
-      return codes
-    }
+  : nativeBuffer
+    ? (str, ERR) => {
+        // TextEncoder is slow on Node.js 24 / 25 (was ok on 22)
+        const codes = nativeBuffer.from(str, 'utf8') // ascii/latin1 coerces, we need to check
+        if (codes.length !== str.length) throw new SyntaxError(ERR) // non-ascii
+        return new Uint8Array(codes.buffer, codes.byteOffset, codes.byteLength)
+      }
+    : (str, ERR) => {
+        const codes = nativeEncoder.encode(str)
+        if (codes.length !== str.length) throw new SyntaxError(ERR) // non-ascii
+        return codes
+      }

package/hex.js

@@ -1,31 +1,19 @@
 import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
+import { skipWeb } from './fallback/_utils.js'
 import * as js from './fallback/hex.js'
 
-const { Buffer } = globalThis // Buffer is optional, only used when native
-const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 
-const { E_HEX } = js
-
 export function toHex(arr) {
   assertUint8(arr)
   if (arr.length === 0) return ''
-  if (webHex && arr.toHex === webHex) return arr.toHex()
-  if (!haveNativeBuffer) return js.toHex(arr)
-  if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.toString('hex')
-  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString('hex')
+  if (!skipWeb && webHex && arr.toHex === webHex) return arr.toHex()
+  return js.toHex(arr)
 }
 
 // Unlike Buffer.from(), throws on invalid input
-export const fromHex = Uint8Array.fromHex
-  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
-  : haveNativeBuffer
-    ? (str, format = 'uint8') => {
-        if (typeof str !== 'string') throw new TypeError('Input is not a string')
-        if (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
-        const buf = Buffer.from(str, 'hex') // will stop on first non-hex character, so we can just validate length
-        if (buf.length * 2 !== str.length) throw new SyntaxError(E_HEX)
-        return typedView(buf, format)
-      }
+export const fromHex =
+  !skipWeb && Uint8Array.fromHex
+    ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
     : (str, format = 'uint8') => typedView(js.fromHex(str), format)

package/hex.node.js

@@ -0,0 +1,26 @@
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { E_HEX } from './fallback/hex.js'
+
+if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
+
+const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
+
+export function toHex(arr) {
+  assertUint8(arr)
+  if (arr.length === 0) return ''
+  if (webHex && arr.toHex === webHex) return arr.toHex()
+  if (arr.constructor === Buffer && Buffer.isBuffer(arr)) return arr.hexSlice(0, arr.byteLength)
+  return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).hexSlice(0, arr.byteLength)
+}
+
+// Unlike Buffer.from(), throws on invalid input
+export const fromHex = Uint8Array.fromHex
+  ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
+  : (str, format = 'uint8') => {
+      if (typeof str !== 'string') throw new TypeError('Input is not a string')
+      if (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
+      const buf = Buffer.from(str, 'hex') // will stop on first non-hex character, so we can just validate length
+      if (buf.length * 2 !== str.length) throw new SyntaxError(E_HEX)
+      return typedView(buf, format)
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.6",
+  "version": "1.0.0-rc.8",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
@@ -50,8 +50,12 @@
     "/base58.js",
     "/base58check.js",
     "/base64.js",
+    "/bech32.js",
+    "/hex.node.js",
     "/hex.js",
-    "/utf8.js"
+    "/utf8.node.js",
+    "/utf8.js",
+    "/wif.js"
   ],
   "exports": {
     "./array.js": "./array.js",
@@ -59,8 +63,20 @@
     "./base58.js": "./base58.js",
     "./base58check.js": "./base58check.js",
     "./base64.js": "./base64.js",
-    "./hex.js": "./hex.js",
-    "./utf8.js": "./utf8.js"
+    "./bech32.js": "./bech32.js",
+    "./hex.js": {
+      "node": "./hex.node.js",
+      "default": "./hex.js"
+    },
+    "./utf16.js": {
+      "node": "./utf16.node.js",
+      "default": "./utf16.js"
+    },
+    "./utf8.js": {
+      "node": "./utf8.node.js",
+      "default": "./utf8.js"
+    },
+    "./wif.js": "./wif.js"
   },
   "peerDependencies": {
     "@exodus/crypto": "^1.0.0-rc.4"
@@ -72,7 +88,7 @@
   },
   "devDependencies": {
     "@ethersproject/strings": "^5.8.0",
-    "@exodus/crypto": "1.0.0-rc.29",
+    "@exodus/crypto": "^1.0.0-rc.30",
     "@exodus/eslint-config": "^5.24.0",
     "@exodus/prettier": "^1.0.0",
     "@exodus/test": "^1.0.0-rc.108",
@@ -84,19 +100,26 @@
     "base-x": "^5.0.1",
     "base32.js": "^0.1.0",
     "base64-js": "^1.5.1",
+    "bech32": "^2.0.0",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
     "bstring": "^0.3.9",
     "buffer": "^6.0.3",
+    "decode-utf8": "^1.0.1",
     "electron": "36.5.0",
+    "encode-utf8": "^2.0.0",
     "eslint": "^8.44.0",
     "fast-base64-decode": "^2.0.0",
     "fast-base64-encode": "^1.0.0",
     "hextreme": "^1.0.7",
     "hi-base32": "^0.5.1",
+    "iconv-lite": "^0.7.0",
     "jsvu": "^3.0.0",
     "text-encoding": "^0.7.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "uint8array-tools": "^0.0.9",
+    "utf8": "^3.0.0",
+    "wif": "^5.0.0"
   },
   "prettier": "@exodus/prettier",
   "packageManager": "pnpm@10.12.1+sha256.889bac470ec93ccc3764488a19d6ba8f9c648ad5e50a9a6e4be3768a5de387a3"

package/utf8.js

@@ -1,7 +1,8 @@
 import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
-import * as js from './fallback/utf8.js'
+import { isHermes } from './fallback/_utils.js'
 import { asciiPrefix, decodeLatin1 } from './fallback/latin1.js'
+import * as js from './fallback/utf8.js'
 
 const { Buffer, TextEncoder, TextDecoder, decodeURIComponent, escape } = globalThis // Buffer is optional
 const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
@@ -16,7 +17,7 @@ const { isWellFormed } = String.prototype
 
 const { E_STRICT, E_STRICT_UNICODE } = js
 
-const shouldUseEscapePath = Boolean(globalThis.HermesInternal) // faster only on Hermes, js path beats it on normal engines
+const shouldUseEscapePath = isHermes // faster only on Hermes, js path beats it on normal engines
 
 function deLoose(str, loose, res) {
   if (loose || str.length === res.length) return res // length is equal only for ascii, which is automatically fine
@@ -46,16 +47,16 @@ function deLoose(str, loose, res) {
 
 function encode(str, loose = false) {
   if (typeof str !== 'string') throw new TypeError('Input is not a string')
-  if (haveNativeBuffer) return deLoose(str, loose, Buffer.from(str)) // faster on ascii on Node.js
-  if (nativeEncoder) return deLoose(str, loose, nativeEncoder.encode(str)) // Node.js, browsers, and Hermes
+  if (str.length === 0) return new Uint8Array() // faster than Uint8Array.of
+  if (nativeEncoder) return deLoose(str, loose, nativeEncoder.encode(str))
   // No reason to use unescape + encodeURIComponent: it's slower than JS on normal engines, and modern Hermes already has TextEncoder
   return js.encode(str, loose)
 }
 
 function decode(arr, loose = false) {
   assertUint8(arr)
+  if (arr.byteLength === 0) return ''
   if (haveDecoder) return loose ? decoderLoose.decode(arr) : decoderFatal.decode(arr) // Node.js and browsers
-  // No reason to use native Buffer: it's not faster than TextDecoder, needs rechecks in non-loose mode, and Node.js has TextDecoder
 
   // Fast path for ASCII prefix, this is faster than all alternatives below
   const prefix = decodeLatin1(arr, 0, asciiPrefix(arr))

package/utf8.node.js

@@ -0,0 +1,51 @@
+import { assertUint8 } from './assert.js'
+import { typedView } from './array.js'
+import { E_STRICT_UNICODE } from './fallback/utf8.js'
+import { isAscii } from 'node:buffer'
+
+if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
+
+const decoderFatal = new TextDecoder('utf8', { ignoreBOM: true, fatal: true })
+const decoderLoose = new TextDecoder('utf8', { ignoreBOM: true })
+const { isWellFormed } = String.prototype
+
+function encode(str, loose = false) {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  const strLength = str.length
+  if (strLength === 0) return new Uint8Array() // faster than Uint8Array.of
+  let res
+  if (strLength > 0x4_00) {
+    // Faster for large strings
+    const byteLength = Buffer.byteLength(str)
+    res = Buffer.allocUnsafe(byteLength)
+    const ascii = byteLength === strLength
+    const written = ascii ? res.latin1Write(str) : res.utf8Write(str)
+    if (written !== byteLength) throw new Error('Failed to write all bytes') // safeguard just in case
+    if (ascii || loose) return res // no further checks needed
+  } else {
+    res = Buffer.from(str)
+    if (res.length === strLength || loose) return res
+  }
+
+  if (!isWellFormed.call(str)) throw new TypeError(E_STRICT_UNICODE)
+  return res
+}
+
+function decode(arr, loose = false) {
+  assertUint8(arr)
+  const byteLength = arr.byteLength
+  if (byteLength === 0) return ''
+  if (byteLength > 0x6_00 && isAscii(arr)) {
+    // On non-ascii strings, this loses ~10% * [relative position of the first non-ascii byte] (up to 10% total)
+    // On ascii strings, this wins 1.5x on loose = false and 1.3x on loose = true
+    // Only makes sense for large enough strings
+    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).latin1Slice(0, arr.byteLength) // .latin1Slice is faster than .asciiSlice
+  }
+
+  return loose ? decoderLoose.decode(arr) : decoderFatal.decode(arr)
+}
+
+export const utf8fromString = (str, format = 'uint8') => typedView(encode(str, false), format)
+export const utf8fromStringLoose = (str, format = 'uint8') => typedView(encode(str, true), format)
+export const utf8toString = (arr) => decode(arr, false)
+export const utf8toStringLoose = (arr) => decode(arr, true)

package/wif.js

@@ -0,0 +1,42 @@
+import { toBase58checkSync, fromBase58checkSync } from './base58check.js'
+import { assertUint8 } from './assert.js'
+
+// Mostly matches npmjs.com/wif, but with extra checks + using our base58check
+// Also no inconsistent behavior on Buffer/Uint8Array input
+
+function from(arr, expectedVersion) {
+  assertUint8(arr)
+  const version = arr[0]
+  if (expectedVersion !== undefined && version !== expectedVersion) {
+    throw new Error('Invalid network version')
+  }
+
+  // Makes a copy, regardless of input being a Buffer or a Uint8Array (unlike .slice)
+  const privateKey = Uint8Array.from(arr.subarray(1, 33))
+  if (arr.length === 33) return { version, privateKey, compressed: false }
+  if (arr.length !== 34) throw new Error('Invalid WIF length')
+  if (arr[33] !== 1) throw new Error('Invalid compression flag')
+  return { version, privateKey, compressed: true }
+}
+
+function to({ version: v, privateKey, compressed }) {
+  if (!Number.isSafeInteger(v) || v < 0 || v > 0xff) throw new Error('Missing or invalid version')
+  assertUint8(privateKey, { length: 32, name: 'privateKey' })
+  if (privateKey.length !== 32) throw new TypeError('Invalid privateKey length')
+  const out = new Uint8Array(compressed ? 34 : 33)
+  out[0] = v
+  out.set(privateKey, 1)
+  if (compressed) out[33] = 1
+  return out
+}
+
+// Async performance is worse here, so expose the same internal methods as sync for now
+// ./base58check is sync internally anyway for now, so doesn't matter until that is changed
+
+export const fromWifStringSync = (string, version) => from(fromBase58checkSync(string), version)
+// export const fromWifString = async (string, version) => from(await fromBase58check(string), version)
+export const fromWifString = async (string, version) => from(fromBase58checkSync(string), version)
+
+export const toWifStringSync = (wif) => toBase58checkSync(to(wif))
+// export const toWifString = async (wif) => toBase58check(to(wif))
+export const toWifString = async (wif) => toBase58checkSync(to(wif))