@exodus/bytes 1.0.0-rc.10 → 1.0.0-rc.11

package/README.md

@@ -150,6 +150,9 @@ Same as `windows1252toString = createSinglebyteDecoder('windows-1252')`.
 ##### `toBase58(arr)`
 ##### `fromBase58(str, format = 'uint8')`
 
+##### `toBase58xrp(arr)`
+##### `fromBase58xrp(str, format = 'uint8')`
+
 ### `@exodus/bytes/base58check.js`
 
 ##### `async toBase58check(arr)`

package/base58.js

@@ -3,10 +3,10 @@ import { assertUint8 } from './assert.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)))
-const ZERO = alphabet[0]
-const zeroC = codes[0]
+const alphabet58 = [...'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz']
+const alphabetXRP = [...'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz']
+const codes58 = new Uint8Array(alphabet58.map((x) => x.charCodeAt(0)))
+const codesXRP = new Uint8Array(alphabetXRP.map((x) => x.charCodeAt(0)))
 
 const _0n = BigInt(0)
 const _1n = BigInt(1)
@@ -16,17 +16,18 @@ const _58n = BigInt(58)
 const _0xffffffffn = BigInt(0xff_ff_ff_ff)
 
 let table // 15 * 82, diagonal, <1kb
-let fromMap
+const fromMaps = new Map()
 
 const E_CHAR = 'Invalid character in base58 input'
 
 const shouldUseBigIntFrom = isHermes // faster only on Hermes, numbers path beats it on normal engines
 
-export function toBase58(arr) {
+function toBase58core(arr, alphabet, codes) {
   assertUint8(arr)
   const length = arr.length
   if (length === 0) return ''
 
+  const ZERO = alphabet[0]
   let zeros = 0
   while (zeros < length && arr[zeros] === 0) zeros++
 
@@ -120,18 +121,20 @@ export function toBase58(arr) {
   return ZERO.repeat(zeros) + out
 }
 
-// TODO: test on 'z'.repeat(from 1 to smth)
-export function fromBase58(str, format = 'uint8') {
+function fromBase58core(str, alphabet, codes, 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)
 
+  const zeroC = codes[0]
   let zeros = 0
   while (zeros < length && str.charCodeAt(zeros) === zeroC) zeros++
 
+  let fromMap = fromMaps.get(alphabet)
   if (!fromMap) {
     fromMap = new Int8Array(256).fill(-1)
     for (let i = 0; i < 58; i++) fromMap[alphabet[i].charCodeAt(0)] = i
+    fromMaps.set(alphabet, fromMap)
   }
 
   const size = zeros + (((length - zeros + 1) * 3) >> 2) // 3/4 rounded up, larger than ~0.73 coef to fit everything
@@ -210,3 +213,8 @@ export function fromBase58(str, format = 'uint8') {
 
   return typedView(res.slice(at - zeros), format) // slice is faster for small sizes than subarray
 }
+
+export const toBase58 = (arr) => toBase58core(arr, alphabet58, codes58)
+export const fromBase58 = (str, format) => fromBase58core(str, alphabet58, codes58, format)
+export const toBase58xrp = (arr) => toBase58core(arr, alphabetXRP, codesXRP)
+export const fromBase58xrp = (str, format) => fromBase58core(str, alphabetXRP, codesXRP, format)

package/fallback/_utils.js

@@ -1,22 +1,30 @@
 const { Buffer, TextEncoder, TextDecoder } = globalThis
 const haveNativeBuffer = Buffer && !Buffer.TYPED_ARRAY_SUPPORT
-let isNative = (x) => x && (haveNativeBuffer || `${x}`.includes('[native code]')) // we consider Node.js TextDecoder/TextEncoder native
+export const nativeBuffer = haveNativeBuffer ? Buffer : null
+export const isHermes = Boolean(globalThis.HermesInternal)
+export const isDeno = Boolean(globalThis.Deno)
+export const isLE = new Uint8Array(Uint16Array.of(258).buffer)[0] === 2
+
+let isNative = (x) => {
+  if (!x) return false
+  if (haveNativeBuffer) return true // we consider Node.js TextDecoder/TextEncoder native
+  const s = `${x}`
+  // See https://github.com/facebook/hermes/pull/1855#issuecomment-3659386410
+  return s.includes('[native code]') || s.includes(`[bytecode]`) // Static Hermes has [bytecode] for contrib, which includes TextEncoder/TextDecoder
+}
+
 if (!haveNativeBuffer && isNative(() => {})) isNative = () => false // e.g. XS, we don't want false positives
 
 export const nativeEncoder = isNative(TextEncoder) ? new TextEncoder() : null
 export const nativeDecoder = isNative(TextDecoder)
   ? new TextDecoder('utf-8', { ignoreBOM: true })
   : null
-export const nativeBuffer = haveNativeBuffer ? Buffer : null
-export const isHermes = Boolean(globalThis.HermesInternal)
-export const isDeno = Boolean(globalThis.Deno)
-export const isLE = new Uint8Array(Uint16Array.of(258).buffer)[0] === 2
 
 // 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
 let nativeDecoderLatin1impl = null
-if (isNative(TextDecoder)) {
+if (nativeDecoder) {
   // Not all barebone engines with TextDecoder support something except utf-8, detect
   try {
     nativeDecoderLatin1impl = new TextDecoder('latin1', { ignoreBOM: true })

package/fallback/encoding.js

@@ -51,10 +51,7 @@ const fromSource = (x) => {
   if (x instanceof Uint8Array) return x
   if (x instanceof ArrayBuffer) return new Uint8Array(x)
   if (ArrayBuffer.isView(x)) return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
-  if (globalThis.SharedArrayBuffer && x instanceof globalThis.SharedArrayBuffer) {
-    return new Uint8Array(x.buffer, x.byteOffset, x.byteLength)
-  }
-
+  if (globalThis.SharedArrayBuffer && x instanceof SharedArrayBuffer) return new Uint8Array(x)
   throw new TypeError('Argument must be a SharedArrayBuffer, ArrayBuffer or ArrayBufferView')
 }
 
@@ -265,15 +262,28 @@ export function legacyHookDecode(input, fallbackEncoding) {
   const bomEncoding = getBOMEncoding(u8)
   if (bomEncoding) u8 = u8.subarray(bomEncoding === 'utf-8' ? 3 : 2)
   const enc = bomEncoding ?? fallbackEncoding ?? 'utf-8' // "the byte order mark is more authoritative than anything else"
+
   if (enc === 'utf-8') return utf8toStringLoose(u8)
-  if (enc === 'utf-16le') return utf16toStringLoose(u8, 'uint8-le')
-  if (enc === 'utf-16be') return utf16toStringLoose(u8, 'uint8-be')
-  if (!Object.hasOwn(labels, enc) || enc === 'replacement') throw new RangeError(E_ENCODING)
+  if (enc === 'utf-16le' || enc === 'utf-16be') {
+    let suffix = ''
+    if (u8.byteLength % 2 !== 0) {
+      suffix = replacementChar
+      u8 = u8.subarray(0, -1)
+    }
+
+    return utf16toStringLoose(u8, enc === 'utf-16le' ? 'uint8-le' : 'uint8-be') + suffix
+  }
+
+  if (!Object.hasOwn(labels, enc)) throw new RangeError(E_ENCODING)
 
   if (multibyteSet.has(enc)) {
     if (!createMultibyteDecoder) throw new Error(E_MULTI)
     return createMultibyteDecoder(enc, true)(u8)
   }
 
+  // https://encoding.spec.whatwg.org/#replacement-decoder
+  // On non-streaming non-fatal case, it just replaces any non-empty input with a single replacement char
+  if (enc === 'replacement') return input.byteLength > 0 ? replacementChar : ''
+
   return createSinglebyteDecoder(enc, true)(u8)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/bytes",
-  "version": "1.0.0-rc.10",
+  "version": "1.0.0-rc.11",
   "description": "Various operations on Uint8Array data",
   "scripts": {
     "lint": "eslint .",
@@ -132,6 +132,7 @@
     "@types/node": "^22.13.0",
     "base-x": "^5.0.1",
     "base32.js": "^0.1.0",
+    "base58-js": "^3.0.3",
     "base64-js": "^1.5.1",
     "bech32": "^2.0.0",
     "bs58": "^6.0.0",