refactor: simplify Uint8Array checks

Author: ChALkeR

base58.js

@@ -1,6 +1,5 @@
 import { typedView } from './array.js'
-import { assertUint8 } from './assert.js'
-import { E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
 import { nativeDecoder, nativeEncoder, isHermes } from './fallback/platform.js'
 import { encodeAscii, decodeAscii } from './fallback/latin1.js'
 
@@ -24,7 +23,7 @@ const E_CHAR = 'Invalid character in base58 input'
 const shouldUseBigIntFrom = isHermes // faster only on Hermes, numbers path beats it on normal engines
 
 function toBase58core(arr, alphabet, codes) {
-  assertUint8(arr)
+  assertU8(arr)
   const length = arr.length
   if (length === 0) return ''
 

base64.js

@@ -1,6 +1,6 @@
-import { assertUint8, assertEmptyRest } from './assert.js'
+import { assertEmptyRest } from './assert.js'
 import { typedView } from './array.js'
-import { E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
 import { isHermes } from './fallback/platform.js'
 import { decodeLatin1, encodeLatin1 } from './fallback/latin1.js'
 import * as js from './fallback/base64.js'
@@ -38,7 +38,7 @@ const toUrl = (x) => x.replaceAll('+', '-').replaceAll('/', '_')
 const haveWeb = (x) => web64 && x.toBase64 === web64
 
 export function toBase64(x, { padding = true } = {}) {
-  assertUint8(x)
+  assertU8(x)
   if (haveWeb(x)) return padding ? x.toBase64() : x.toBase64({ omitPadding: !padding }) // Modern, optionless is slightly faster
   if (haveNativeBuffer) return maybeUnpad(toBuffer(x).base64Slice(0, x.byteLength), padding) // Older Node.js
   if (shouldUseBtoa) return maybeUnpad(btoa(decodeLatin1(x)), padding)
@@ -47,7 +47,7 @@ export function toBase64(x, { padding = true } = {}) {
 
 // NOTE: base64url omits padding by default
 export function toBase64url(x, { padding = false } = {}) {
-  assertUint8(x)
+  assertU8(x)
   if (haveWeb(x)) return x.toBase64({ alphabet: 'base64url', omitPadding: !padding }) // Modern
   if (haveNativeBuffer) return maybePad(toBuffer(x).base64urlSlice(0, x.byteLength), padding) // Older Node.js
   if (shouldUseBtoa) return maybeUnpad(toUrl(btoa(decodeLatin1(x))), padding)

bech32.js

@@ -1,5 +1,4 @@
-import { assertUint8 } from './assert.js'
-import { E_STRING } from './fallback/_utils.js'
+import { assertU8, E_STRING } from './fallback/_utils.js'
 import { nativeEncoder } from './fallback/platform.js'
 import { decodeAscii, encodeAscii, encodeLatin1 } from './fallback/latin1.js'
 
@@ -110,7 +109,7 @@ function pPrefix(prefix) {
 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)
+  assertU8(bytes)
   const bytesLength = bytes.length
   const wordsLength = Math.ceil((bytesLength * 8) / 5)
   if (!(prefix.length + 7 + wordsLength <= limit)) throw new TypeError(E_SIZE)

fallback/_utils.js

@@ -6,6 +6,10 @@ export function assert(condition, msg) {
   if (!condition) throw new Error(msg)
 }
 
+export function assertU8(arg) {
+  if (!(arg instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+}
+
 // On arrays in heap (<= 64) it's cheaper to copy into a pooled buffer than lazy-create the ArrayBuffer storage
 export const toBuf = (x) =>
   x.byteLength <= 64 && x.BYTES_PER_ELEMENT === 1

fallback/base32.js

@@ -1,4 +1,4 @@
-import { assertUint8 } from '../assert.js'
+import { assertU8 } from './_utils.js'
 import { nativeEncoder, nativeDecoder, isHermes } from './platform.js'
 import { encodeAscii, decodeAscii } from './latin1.js'
 
@@ -18,7 +18,7 @@ const useTemplates = isHermes // Faster on Hermes and JSC, but we use it only on
 
 // We construct output by concatenating chars, this seems to be fine enough on modern JS engines
 export function toBase32(arr, isBase32Hex, padding) {
-  assertUint8(arr)
+  assertU8(arr)
   const fullChunks = Math.floor(arr.length / 5)
   const fullChunksBytes = fullChunks * 5
   let o = ''

fallback/base58check.js

@@ -1,6 +1,6 @@
 import { typedView } from '@exodus/bytes/array.js'
 import { toBase58, fromBase58 } from '@exodus/bytes/base58.js'
-import { assertUint8 } from '../assert.js'
+import { assertU8 } from './_utils.js'
 
 const E_CHECKSUM = 'Invalid checksum'
 
@@ -28,7 +28,7 @@ function assertChecksum(c, r) {
 export const makeBase58check = (hashAlgo, hashAlgoSync) => {
   const apis = {
     async encode(arr) {
-      assertUint8(arr)
+      assertU8(arr)
       return encodeWithChecksum(arr, await hashAlgo(arr))
     },
     async decode(str, format = 'uint8') {
@@ -41,7 +41,7 @@ export const makeBase58check = (hashAlgo, hashAlgoSync) => {
   return {
     ...apis,
     encodeSync(arr) {
-      assertUint8(arr)
+      assertU8(arr)
       return encodeWithChecksum(arr, hashAlgoSync(arr))
     },
     decodeSync(str, format = 'uint8') {

fallback/base64.js

@@ -1,4 +1,3 @@
-import { assertUint8 } from '../assert.js'
 import { nativeEncoder, nativeDecoder } from './platform.js'
 import { encodeAscii, decodeAscii } from './latin1.js'
 
@@ -15,8 +14,8 @@ export const E_LENGTH = 'Invalid base64 length'
 export const E_LAST = 'Invalid last chunk'
 
 // We construct output by concatenating chars, this seems to be fine enough on modern JS engines
+// Expects a checked Uint8Array
 export function toBase64(arr, isURL, padding) {
-  assertUint8(arr)
   const fullChunks = (arr.length / 3) | 0
   const fullChunksBytes = fullChunks * 3
   let o = ''

fallback/hex.js

@@ -1,4 +1,3 @@
-import { assertUint8 } from '../assert.js'
 import { E_STRING } from './_utils.js'
 import { nativeDecoder, nativeEncoder, decode2string } from './platform.js'
 import { encodeAscii, decodeAscii } from './latin1.js'
@@ -12,9 +11,8 @@ const allowed = '0123456789ABCDEFabcdef'
 
 export const E_HEX = 'Input is not a hex string'
 
+// Expects a checked Uint8Array
 export function toHex(arr) {
-  assertUint8(arr)
-
   if (!hexArray) hexArray = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))
   const length = arr.length // this helps Hermes
 

fallback/utf16.js

@@ -1,5 +1,5 @@
 import { decodeUCS2, encodeCharcodes } from './latin1.js'
-import { E_STRING, E_STRICT_UNICODE } from './_utils.js'
+import { assertU8, E_STRING, E_STRICT_UNICODE } from './_utils.js'
 import { nativeDecoder, isLE } from './platform.js'
 
 export const E_STRICT = 'Input is not well-formed utf16'
@@ -38,7 +38,7 @@ export function decodeApiDecoders(input, loose, format) {
   if (format === 'uint16') {
     if (!(input instanceof Uint16Array)) throw new TypeError('Expected an Uint16Array')
   } else if (format === 'uint8-le' || format === 'uint8-be') {
-    if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+    assertU8(input)
     if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
   } else {
     throw new TypeError('Unknown format')
@@ -56,12 +56,12 @@ export function decodeApiJS(input, loose, format) {
       u16 = input
       break
     case 'uint8-le':
-      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+      assertU8(input)
       if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
       u16 = to16input(input, true)
       break
     case 'uint8-be':
-      if (!(input instanceof Uint8Array)) throw new TypeError('Expected an Uint8Array')
+      assertU8(input)
       if (input.byteLength % 2 !== 0) throw new TypeError('Expected even number of bytes')
       u16 = to16input(input, false)
       break

hex.js

@@ -1,11 +1,11 @@
-import { assertUint8 } from './assert.js'
 import { typedView } from './array.js'
+import { assertU8 } from './fallback/_utils.js'
 import * as js from './fallback/hex.js'
 
 const { toHex: webHex } = Uint8Array.prototype // Modern engines have this
 
 export function toHex(arr) {
-  assertUint8(arr)
+  assertU8(arr)
   if (arr.length === 0) return ''
   if (webHex && arr.toHex === webHex) return arr.toHex()
   return js.toHex(arr)