@exodus/bytes 1.0.0-rc.4 → 1.0.0-rc.5

package/assert.js

@@ -1,7 +1,3 @@
-export function assert(x, msg) {
-  if (!x) throw new Error(msg || 'Assertion failed')
-}
-
 export function assertEmptyRest(rest) {
   if (Object.keys(rest).length > 0) throw new TypeError('Unexpected extra options')
 }

package/base58.js

@@ -0,0 +1,212 @@
+import { typedView } from './array.js'
+import { assertUint8 } from './assert.js'
+import { nativeDecoder, nativeEncoder } from './fallback/_utils.js'
+
+const alphabet = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
+const codes = new Uint8Array(alphabet.map((x) => x.charCodeAt(0)))
+const ZERO = alphabet[0]
+const zeroC = codes[0]
+
+const _0n = BigInt(0)
+const _1n = BigInt(1)
+const _8n = BigInt(8)
+const _32n = BigInt(32)
+const _58n = BigInt(58)
+const _0xffffffffn = BigInt(0xff_ff_ff_ff)
+
+let table // 15 * 82, diagonal, <1kb
+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
+
+export function toBase58(arr) {
+  assertUint8(arr)
+  const length = arr.length
+  if (length === 0) return ''
+
+  let zeros = 0
+  while (zeros < length && arr[zeros] === 0) zeros++
+
+  if (length > 60) {
+    // Slow path. Can be optimized ~10%, but the main factor is /58n division anyway, so doesn't matter much
+    let x = _0n
+    for (let i = 0; i < arr.length; i++) x = (x << _8n) | BigInt(arr[i])
+
+    let out = ''
+    while (x) {
+      const d = x / _58n
+      out = alphabet[Number(x - _58n * d)] + out
+      x = d
+    }
+
+    return ZERO.repeat(zeros) + out
+  }
+
+  // We run fast mode operations only on short (<=60 bytes) inputs, via precomputation table
+  if (!table) {
+    table = []
+    let x = _1n
+    for (let i = 0; i < 15; i++) {
+      // Convert x to base 58 digits
+      const in58 = []
+      let y = x
+      while (y) {
+        const d = y / _58n
+        in58.push(Number(y - _58n * d))
+        y = d
+      }
+
+      table.push(new Uint8Array(in58))
+      x <<= _32n
+    }
+  }
+
+  const res = []
+  {
+    let j = 0
+    // We group each 4 bytes into 32-bit chunks
+    // Not using u32arr to not deal with remainder + BE/LE differences
+    for (let i = length - 1; i >= 0; i -= 4) {
+      let c
+      if (i > 2) {
+        c = (arr[i] | (arr[i - 1] << 8) | (arr[i - 2] << 16) | (arr[i - 3] << 24)) >>> 0
+      } else if (i > 1) {
+        c = arr[i] | (arr[i - 1] << 8) | (arr[i - 2] << 16)
+      } else {
+        c = i === 1 ? arr[i] | (arr[i - 1] << 8) : arr[i]
+      }
+
+      const row = table[j++]
+      if (c === 0) continue
+      const olen = res.length
+      const nlen = row.length
+      let k = 0
+      for (; k < olen; k++) res[k] += c * row[k]
+      while (k < nlen) res.push(c * row[k++])
+    }
+  }
+
+  // We can now do a single scan over regular numbers under MAX_SAFE_INTEGER
+  // Note: can't use int32 operations on them, as they are outside of 2**32 range
+  // This is faster though
+  {
+    let carry = 0
+    let i = 0
+    while (i < res.length) {
+      const c = res[i] + carry
+      carry = Math.floor(c / 58)
+      res[i++] = c - carry * 58
+    }
+
+    while (carry) {
+      const c = carry
+      carry = Math.floor(c / 58)
+      res[i++] = c - carry * 58
+    }
+  }
+
+  if (nativeDecoder) {
+    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)
+  }
+
+  let out = ''
+  for (let i = res.length - 1; i >= 0; i--) out += alphabet[res[i]]
+  return ZERO.repeat(zeros) + out
+}
+
+// TODO: test on 'z'.repeat(from 1 to smth)
+export function fromBase58(str, format = 'uint8') {
+  if (typeof str !== 'string') throw new TypeError('Input is not a string')
+  const length = str.length
+  if (length === 0) return typedView(new Uint8Array(), format)
+
+  let zeros = 0
+  while (zeros < length && str.charCodeAt(zeros) === zeroC) zeros++
+
+  if (!fromMap) {
+    fromMap = new Int8Array(256).fill(-1)
+    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 res = new Uint8Array(size)
+  let at = size // where is the first significant byte written
+
+  if (shouldUseBigIntFrom) {
+    let x = _0n
+
+    // nativeEncoder gives a benefit here
+    if (nativeEncoder) {
+      const codes = nativeEncoder.encode(str)
+      if (codes.length !== str.length) throw new SyntaxError(E_CHAR) // non-ascii
+      for (let i = zeros; i < length; i++) {
+        const c = fromMap[codes[i]]
+        if (c < 0) throw new SyntaxError(E_CHAR)
+        x = x * _58n + BigInt(c)
+      }
+    } else {
+      for (let i = zeros; i < length; i++) {
+        const charCode = str.charCodeAt(i)
+        const c = fromMap[charCode]
+        if (charCode > 255 || c < 0) throw new SyntaxError(E_CHAR)
+        x = x * _58n + BigInt(c)
+      }
+    }
+
+    while (x) {
+      let y = Number(x & _0xffffffffn)
+      x >>= 32n
+      res[--at] = y & 0xff
+      y >>>= 8
+      if (!x && !y) break
+      res[--at] = y & 0xff
+      y >>>= 8
+      if (!x && !y) break
+      res[--at] = y & 0xff
+      y >>>= 8
+      if (!x && !y) break
+      res[--at] = y & 0xff
+    }
+  } else {
+    for (let i = zeros; i < length; i++) {
+      const charCode = str.charCodeAt(i)
+      let c = fromMap[charCode]
+      if (charCode > 255 || c < 0) throw new SyntaxError(E_CHAR)
+
+      let k = size - 1
+      for (;;) {
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+        // unroll a bit
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+        if (c === 0 && k < at) break
+        c += 58 * res[k]
+        res[k] = c & 0xff
+        c >>>= 8
+        k--
+      }
+
+      at = k + 1
+      if (c !== 0 || at < zeros) throw new Error('Unexpected') // unreachable
+    }
+  }
+
+  return typedView(res.slice(at - zeros), format) // slice is faster for small sizes than subarray
+}

package/base58check.js

@@ -0,0 +1,30 @@
+import { typedView } from './array.js'
+import { assertUint8 } from './assert.js'
+import { toBase58, fromBase58 } from './base58.js'
+import { hashSync } from '@exodus/crypto/hash'
+
+// 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
+
+const hash256 = (x) => hashSync('sha256', hashSync('sha256', x, 'uint8'), 'uint8')
+
+const E_CHECKSUM = 'Invalid checksum'
+
+export async function toBase58check(arr) {
+  assertUint8(arr)
+  const checksum = hash256(arr)
+  const res = new Uint8Array(arr.length + 4)
+  res.set(arr, 0)
+  res.set(checksum.subarray(0, 4), arr.length)
+  return toBase58(res)
+}
+
+export async function fromBase58check(str, format = 'uint8') {
+  const arr = fromBase58(str) // checks input
+  const len4 = arr.length - 4
+  const payload = arr.subarray(0, len4)
+  const c = arr.subarray(len4)
+  const r = hash256(payload)
+  if ((c[0] ^ r[0]) | (c[1] ^ r[1]) | (c[2] ^ r[2]) | (c[3] ^ r[3])) throw new Error(E_CHECKSUM)
+  return typedView(payload, format)
+}

package/fallback/hex.js

@@ -58,9 +58,6 @@ export function fromHex(str) {
   if (typeof str !== 'string') throw new TypeError('Input is not a string')
   if (str.length % 2 !== 0) throw new SyntaxError(E_HEX)
 
-  // We don't use native Buffer impl, as rechecking input make it slower than pure js
-  // This path is used only on older engines though
-
   if (!dehexArray) {
     dehexArray = new Int8Array(mapSize).fill(-1) // no regex input validation here, so we map all other bytes to -1 and recheck sign
     for (let i = 0; i < 16; i++) {

package/hex.js

@@ -6,6 +6,8 @@ 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 ''
@@ -18,4 +20,12 @@ export function toHex(arr) {
 // Unlike Buffer.from(), throws on invalid input
 export const fromHex = Uint8Array.fromHex
   ? (str, format = 'uint8') => typedView(Uint8Array.fromHex(str), format)
-  : (str, format = 'uint8') => typedView(js.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)
+      }
+    : (str, format = 'uint8') => typedView(js.fromHex(str), format)

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.5",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
-    "test:v8": "npm run test:d8 --",
     "test:javascriptcore": "npm run test:jsc --",
-    "test:d8": "exodus-test --engine=d8:bundle",
+    "test:v8": "exodus-test --engine=v8:bundle",
     "test:jsc": "exodus-test --engine=jsc:bundle",
     "test:spidermonkey": "exodus-test --engine=spidermonkey:bundle",
     "test:hermes": "exodus-test --engine=hermes:bundle",
@@ -47,6 +46,8 @@
     "/array.js",
     "/assert.js",
     "/base32.js",
+    "/base58.js",
+    "/base58check.js",
     "/base64.js",
     "/hex.js",
     "/utf8.js"
@@ -54,23 +55,42 @@
   "exports": {
     "./array.js": "./array.js",
     "./base32.js": "./base32.js",
+    "./base58.js": "./base58.js",
+    "./base58check.js": "./base58check.js",
     "./base64.js": "./base64.js",
     "./hex.js": "./hex.js",
     "./utf8.js": "./utf8.js"
   },
+  "peerDependencies": {
+    "@exodus/crypto": "^1.0.0-rc.4"
+  },
+  "peerDependenciesMeta": {
+    "@exodus/crypto": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@ethersproject/strings": "^5.8.0",
+    "@exodus/crypto": "1.0.0-rc.29",
     "@exodus/eslint-config": "^5.24.0",
     "@exodus/prettier": "^1.0.0",
-    "@exodus/test": "^1.0.0-rc.105",
+    "@exodus/test": "^1.0.0-rc.107",
+    "@noble/hashes": "^2.0.1",
     "@scure/base": "^1.2.6",
+    "@stablelib/base64": "^2.0.1",
+    "@stablelib/hex": "^2.0.1",
     "@types/node": "^24.0.10",
     "base-x": "^5.0.1",
     "base32.js": "^0.1.0",
     "base64-js": "^1.5.1",
+    "bs58": "^6.0.0",
+    "bs58check": "^4.0.0",
+    "bstring": "^0.3.9",
     "buffer": "^6.0.3",
     "electron": "36.5.0",
     "eslint": "^8.44.0",
     "fast-base64-decode": "^2.0.0",
+    "fast-base64-encode": "^1.0.0",
     "hi-base32": "^0.5.1",
     "jsvu": "^3.0.0",
     "text-encoding": "^0.7.0"

package/utf8.js

@@ -1,4 +1,4 @@
-import { assert, assertUint8 } from './assert.js'
+import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
 import * as js from './fallback/utf8.js'
 
@@ -11,6 +11,7 @@ const nativeEncoder = isNative(TextEncoder) ? new TextEncoder() : null
 // We don't want to strip anything unexpectedly
 const decoderFatal = haveDecoder ? new TextDecoder('utf8', { ignoreBOM: true, fatal: true }) : null
 const decoderLoose = haveDecoder ? new TextDecoder('utf8', { ignoreBOM: true }) : null
+const { isWellFormed } = String.prototype
 
 const { E_STRICT, E_STRICT_UNICODE } = js
 
@@ -18,6 +19,12 @@ const shouldUseEscapePath = Boolean(globalThis.HermesInternal) // faster only on
 
 function deLoose(str, loose, res) {
   if (loose) return res
+  if (isWellFormed) {
+    // We have a fast native method
+    if (isWellFormed.call(str)) return res
+    throw new TypeError(E_STRICT_UNICODE)
+  }
+
   // Recheck if the string was encoded correctly
   let start = 0
   const last = res.length - 2
@@ -28,7 +35,7 @@ function deLoose(str, loose, res) {
     start = pos + 1
     if (res[pos + 1] === 0xbf && res[pos + 2] === 0xbd) {
       // Found a replacement char in output, need to recheck if we encoded the input correctly
-      assert(str === decode(res), E_STRICT_UNICODE)
+      if (str !== decode(res)) throw new TypeError(E_STRICT_UNICODE)
       return res
     }
   }
@@ -37,7 +44,7 @@ function deLoose(str, loose, res) {
 }
 
 function encode(str, loose = false) {
-  assert(typeof str === 'string')
+  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
   // No reason to use unescape + encodeURIComponent: it's slower than JS on normal engines, and modern Hermes already has TextEncoder