@exodus/bytes 1.8.0 → 1.10.0

package/single-byte.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Decode / encode the legacy single-byte encodings according to the
+ * [Encoding standard](https://encoding.spec.whatwg.org/)
+ * ([§9](https://encoding.spec.whatwg.org/#legacy-single-byte-encodings),
+ * [§14.5](https://encoding.spec.whatwg.org/#x-user-defined)),
+ * and [unicode.org](https://unicode.org/Public/MAPPINGS/ISO8859) `iso-8859-*` mappings.
+ *
+ * ```js
+ * import { createSinglebyteDecoder, createSinglebyteEncoder } from '@exodus/bytes/single-byte.js'
+ * import { windows1252toString, windows1252fromString } from '@exodus/bytes/single-byte.js'
+ * import { latin1toString, latin1fromString } from '@exodus/bytes/single-byte.js'
+ * ```
+ *
+ * Supports all single-byte encodings listed in the WHATWG Encoding standard:
+ * `ibm866`, `iso-8859-2`, `iso-8859-3`, `iso-8859-4`, `iso-8859-5`, `iso-8859-6`, `iso-8859-7`, `iso-8859-8`,
+ * `iso-8859-8-i`, `iso-8859-10`, `iso-8859-13`, `iso-8859-14`, `iso-8859-15`, `iso-8859-16`, `koi8-r`, `koi8-u`,
+ * `macintosh`, `windows-874`, `windows-1250`, `windows-1251`, `windows-1252`, `windows-1253`, `windows-1254`,
+ * `windows-1255`, `windows-1256`, `windows-1257`, `windows-1258`, `x-mac-cyrillic` and `x-user-defined`.
+ *
+ * Also supports `iso-8859-1`, `iso-8859-9`, `iso-8859-11` as defined at
+ * [unicode.org](https://unicode.org/Public/MAPPINGS/ISO8859)
+ * (and all other `iso-8859-*` encodings there as they match WHATWG).
+ *
+ * > [!NOTE]
+ * > While all `iso-8859-*` encodings supported by the [WHATWG Encoding standard](https://encoding.spec.whatwg.org/) match
+ * > [unicode.org](https://unicode.org/Public/MAPPINGS/ISO8859), the WHATWG Encoding spec doesn't support
+ * > `iso-8859-1`, `iso-8859-9`, `iso-8859-11`, and instead maps them as labels to `windows-1252`, `windows-1254`, `windows-874`.\
+ * > `createSinglebyteDecoder()` (unlike `TextDecoder` or `legacyHookDecode()`) does not do such mapping,
+ * > so its results will differ from `TextDecoder` for those encoding names.
+ *
+ * ```js
+ * > new TextDecoder('iso-8859-1').encoding
+ * 'windows-1252'
+ * > new TextDecoder('iso-8859-9').encoding
+ * 'windows-1254'
+ * > new TextDecoder('iso-8859-11').encoding
+ * 'windows-874'
+ * > new TextDecoder('iso-8859-9').decode(Uint8Array.of(0x80, 0x81, 0xd0))
+ * '€\x81Ğ' // this is actually decoded according to windows-1254 per TextDecoder spec
+ * > createSinglebyteDecoder('iso-8859-9')(Uint8Array.of(0x80, 0x81, 0xd0))
+ * '\x80\x81Ğ' // this is iso-8859-9 as defined at https://unicode.org/Public/MAPPINGS/ISO8859/8859-9.txt
+ * ```
+ *
+ * All WHATWG Encoding spec [`windows-*` encodings](https://encoding.spec.whatwg.org/#windows-874) are supersets of
+ * corresponding [unicode.org encodings](https://unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/), meaning that
+ * they encode/decode all the old valid (non-replacement) strings / byte sequences identically, but can also support
+ * a wider range of inputs.
+ *
+ * @module @exodus/bytes/single-byte.js
+ */
+
+/// <reference types="node" />
+
+import type { Uint8ArrayBuffer } from './array.js';
+
+/**
+ * Create a decoder for a supported one-byte `encoding`, given its lowercased name `encoding`.
+ *
+ * Returns a function `decode(arr)` that decodes bytes to a string.
+ *
+ * @param encoding - The encoding name (e.g., 'iso-8859-1', 'windows-1252')
+ * @param loose - If true, replaces unmapped bytes with replacement character instead of throwing (default: false)
+ * @returns A function that decodes bytes to string
+ */
+export function createSinglebyteDecoder(
+  encoding: string,
+  loose?: boolean
+): (arr: Uint8Array) => string;
+
+/**
+ * Create an encoder for a supported one-byte `encoding`, given its lowercased name `encoding`.
+ *
+ * Returns a function `encode(string)` that encodes a string to bytes.
+ *
+ * In `'fatal'` mode (default), will throw on non well-formed strings or any codepoints which could
+ * not be encoded in the target encoding.
+ *
+ * @param encoding - The encoding name (e.g., 'iso-8859-1', 'windows-1252')
+ * @param options - Encoding options
+ * @param options.mode - Encoding mode (default: 'fatal'). Currently, only 'fatal' mode is supported.
+ * @returns A function that encodes string to bytes
+ */
+export function createSinglebyteEncoder(
+  encoding: string,
+  options?: { mode?: 'fatal' }
+): (string: string) => Uint8ArrayBuffer;
+
+/**
+ * Decode `iso-8859-1` bytes to a string.
+ *
+ * There is no loose variant for this encoding, all bytes can be decoded.
+ *
+ * Same as:
+ * ```js
+ * const latin1toString = createSinglebyteDecoder('iso-8859-1')
+ * ```
+ *
+ * Note: this is different from `new TextDecoder('iso-8859-1')` and `new TextDecoder('latin1')`, as
+ * those alias to `new TextDecoder('windows-1252')`.
+ *
+ * @param arr - The bytes to decode
+ * @returns The decoded string
+ */
+export function latin1toString(arr: Uint8Array): string;
+
+/**
+ * Encode a string to `iso-8859-1` bytes.
+ *
+ * Throws on non well-formed strings or any codepoints which could not be encoded in `iso-8859-1`.
+ *
+ * Same as:
+ * ```js
+ * const latin1fromString = createSinglebyteEncoder('iso-8859-1', { mode: 'fatal' })
+ * ```
+ *
+ * @param string - The string to encode
+ * @returns The encoded bytes
+ */
+export function latin1fromString(string: string): Uint8ArrayBuffer;
+
+/**
+ * Decode `windows-1252` bytes to a string.
+ *
+ * There is no loose variant for this encoding, all bytes can be decoded.
+ *
+ * Same as:
+ * ```js
+ * const windows1252toString = createSinglebyteDecoder('windows-1252')
+ * ```
+ *
+ * @param arr - The bytes to decode
+ * @returns The decoded string
+ */
+export function windows1252toString(arr: Uint8Array): string;
+
+/**
+ * Encode a string to `windows-1252` bytes.
+ *
+ * Throws on non well-formed strings or any codepoints which could not be encoded in `windows-1252`.
+ *
+ * Same as:
+ * ```js
+ * const windows1252fromString = createSinglebyteEncoder('windows-1252', { mode: 'fatal' })
+ * ```
+ *
+ * @param string - The string to encode
+ * @returns The encoded bytes
+ */
+export function windows1252fromString(string: string): Uint8ArrayBuffer;

package/single-byte.js

@@ -1,5 +1,5 @@
 import { assertUint8 } from './assert.js'
-import { canDecoders, nativeEncoder, isHermes, skipWeb, E_STRING } from './fallback/_utils.js'
+import { canDecoders, nativeEncoder, skipWeb, E_STRING } from './fallback/_utils.js'
 import { encodeAscii, encodeAsciiPrefix, encodeLatin1 } from './fallback/latin1.js'
 import { assertEncoding, encodingDecoder, encodeMap, E_STRICT } from './fallback/single-byte.js'
 
@@ -66,17 +66,15 @@ function encode(s, m) {
   const x = new Uint8Array(len)
   let i = nativeEncoder ? 0 : encodeAsciiPrefix(x, s)
 
-  if (!isHermes) {
-    for (const len3 = len - 3; i < len3; i += 4) {
-      const x0 = s.charCodeAt(i), x1 = s.charCodeAt(i + 1), x2 = s.charCodeAt(i + 2), x3 = s.charCodeAt(i + 3) // prettier-ignore
-      const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
-      if ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3)) throw new TypeError(E_STRICT)
+  for (const len3 = len - 3; i < len3; i += 4) {
+    const x0 = s.charCodeAt(i), x1 = s.charCodeAt(i + 1), x2 = s.charCodeAt(i + 2), x3 = s.charCodeAt(i + 3) // prettier-ignore
+    const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
+    if ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3)) return null
 
-      x[i] = c0
-      x[i + 1] = c1
-      x[i + 2] = c2
-      x[i + 3] = c3
-    }
+    x[i] = c0
+    x[i + 1] = c1
+    x[i + 2] = c2
+    x[i + 3] = c3
   }
 
   for (; i < len; i++) {

package/single-byte.node.js

@@ -61,6 +61,32 @@ export function createSinglebyteDecoder(encoding, loose = false) {
 
 const NON_LATIN = /[^\x00-\xFF]/ // eslint-disable-line no-control-regex
 
+function encode(s, m) {
+  const len = s.length
+  let i = 0
+  const b = Buffer.from(s, 'utf-16le') // aligned
+  if (!isLE) b.swap16()
+  const x = new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
+  for (const len3 = len - 3; i < len3; i += 4) {
+    const x0 = x[i], x1 = x[i + 1], x2 = x[i + 2], x3 = x[i + 3] // prettier-ignore
+    const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
+    if (!(c0 && c1 && c2 && c3) && ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3))) return null // prettier-ignore
+    x[i] = c0
+    x[i + 1] = c1
+    x[i + 2] = c2
+    x[i + 3] = c3
+  }
+
+  for (; i < len; i++) {
+    const x0 = x[i]
+    const c0 = m[x0]
+    if (!c0 && x0) return null
+    x[i] = c0
+  }
+
+  return new Uint8Array(x)
+}
+
 export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
   // TODO: replacement, truncate (replacement will need varying length)
   if (mode !== 'fatal') throw new Error('Unsupported mode')
@@ -82,32 +108,9 @@ export function createSinglebyteEncoder(encoding, { mode = 'fatal' } = {}) {
       if (b.length === s.length) return new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
     }
 
-    const len = s.length
-    let i = 0
-    const b = Buffer.from(s, 'utf-16le') // aligned
-    if (!isLE) b.swap16()
-    const x = new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
-    for (const len3 = len - 3; i < len3; i += 4) {
-      const x0 = x[i], x1 = x[i + 1], x2 = x[i + 2], x3 = x[i + 3] // prettier-ignore
-      const c0 = m[x0], c1 = m[x1], c2 = m[x2], c3 = m[x3] // prettier-ignore
-      if (!(c0 && c1 && c2 && c3) && ((!c0 && x0) || (!c1 && x1) || (!c2 && x2) || (!c3 && x3))) {
-        throw new TypeError(E_STRICT)
-      }
-
-      x[i] = c0
-      x[i + 1] = c1
-      x[i + 2] = c2
-      x[i + 3] = c3
-    }
-
-    for (; i < len; i++) {
-      const x0 = x[i]
-      const c0 = m[x0]
-      if (!c0 && x0) throw new TypeError(E_STRICT)
-      x[i] = c0
-    }
-
-    return new Uint8Array(x)
+    const res = encode(s, m)
+    if (!res) throw new TypeError(E_STRICT)
+    return res
   }
 }
 

package/utf16.d.ts

@@ -0,0 +1,92 @@
+/**
+ * UTF-16 encoding/decoding
+ *
+ * ```js
+ * import { utf16fromString, utf16toString } from '@exodus/bytes/utf16.js'
+ *
+ * // loose
+ * import { utf16fromStringLoose, utf16toStringLoose } from '@exodus/bytes/utf16.js'
+ * ```
+ *
+ * _These methods by design encode/decode BOM (codepoint `U+FEFF` Byte Order Mark) as-is._\
+ * _If you need BOM handling or detection, use `@exodus/bytes/encoding.js`_
+ *
+ * @module @exodus/bytes/utf16.js
+ */
+
+/// <reference types="node" />
+
+import type { Uint8ArrayBuffer, Uint16ArrayBuffer } from './array.js';
+
+/**
+ * Output format for UTF-16 encoding
+ */
+export type Utf16Format = 'uint16' | 'uint8-le' | 'uint8-be';
+
+/**
+ * Encode a string to UTF-16 bytes (strict mode)
+ *
+ * Throws on invalid Unicode (unpaired surrogates)
+ *
+ * @param string - The string to encode
+ * @param format - Output format (default: 'uint16')
+ * @returns The encoded bytes
+ */
+export function utf16fromString(string: string, format?: 'uint16'): Uint16ArrayBuffer;
+export function utf16fromString(string: string, format: 'uint8-le'): Uint8ArrayBuffer;
+export function utf16fromString(string: string, format: 'uint8-be'): Uint8ArrayBuffer;
+export function utf16fromString(string: string, format?: Utf16Format): Uint16ArrayBuffer | Uint8ArrayBuffer;
+
+/**
+ * Encode a string to UTF-16 bytes (loose mode)
+ *
+ * Replaces invalid Unicode (unpaired surrogates) with replacement codepoints `U+FFFD`
+ * per [WHATWG Encoding](https://encoding.spec.whatwg.org/) specification.
+ *
+ * _Such replacement is a non-injective function, is irreversible and causes collisions.\
+ * Prefer using strict throwing methods for cryptography applications._
+ *
+ * @param string - The string to encode
+ * @param format - Output format (default: 'uint16')
+ * @returns The encoded bytes
+ */
+export function utf16fromStringLoose(string: string, format?: 'uint16'): Uint16ArrayBuffer;
+export function utf16fromStringLoose(string: string, format: 'uint8-le'): Uint8ArrayBuffer;
+export function utf16fromStringLoose(string: string, format: 'uint8-be'): Uint8ArrayBuffer;
+export function utf16fromStringLoose(string: string, format?: Utf16Format): Uint16ArrayBuffer | Uint8ArrayBuffer;
+
+/**
+ * Decode UTF-16 bytes to a string (strict mode)
+ *
+ * Throws on invalid UTF-16 byte sequences
+ *
+ * Throws on non-even byte length.
+ *
+ * @param arr - The bytes to decode
+ * @param format - Input format (default: 'uint16')
+ * @returns The decoded string
+ */
+export function utf16toString(arr: Uint16Array, format?: 'uint16'): string;
+export function utf16toString(arr: Uint8Array, format: 'uint8-le'): string;
+export function utf16toString(arr: Uint8Array, format: 'uint8-be'): string;
+export function utf16toString(arr: Uint16Array | Uint8Array, format?: Utf16Format): string;
+
+/**
+ * Decode UTF-16 bytes to a string (loose mode)
+ *
+ * Replaces invalid UTF-16 byte sequences with replacement codepoints `U+FFFD`
+ * per [WHATWG Encoding](https://encoding.spec.whatwg.org/) specification.
+ *
+ * _Such replacement is a non-injective function, is irreversible and causes collisions.\
+ * Prefer using strict throwing methods for cryptography applications._
+ *
+ * Throws on non-even byte length.
+ *
+ * @param arr - The bytes to decode
+ * @param format - Input format (default: 'uint16')
+ * @returns The decoded string
+ */
+export function utf16toStringLoose(arr: Uint16Array, format?: 'uint16'): string;
+export function utf16toStringLoose(arr: Uint8Array, format: 'uint8-le'): string;
+export function utf16toStringLoose(arr: Uint8Array, format: 'uint8-be'): string;
+export function utf16toStringLoose(arr: Uint16Array | Uint8Array, format?: Utf16Format): string;

package/utf16.js

@@ -34,6 +34,7 @@ function encode(str, loose = false, format = 'uint16') {
 
   if (format === 'uint8-le' || format === 'uint8-be') return to8(u16) // Already swapped
   if (format === 'uint16') return u16
+  /* c8 ignore next */
   throw new Error('Unreachable')
 }
 

package/utf16.node.js

@@ -30,11 +30,15 @@ function encode(str, loose = false, format = 'uint16') {
     return new Uint16Array(b.buffer, b.byteOffset, b.byteLength / 2)
   }
 
+  /* c8 ignore next */
   throw new Error('Unreachable')
 }
 
-const swapped = (x, swap) =>
-  swap ? Buffer.from(x).swap16() : Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+// Convert to Buffer view or a swapped Buffer copy
+const swapped = (x, swap) => {
+  const b = Buffer.from(x.buffer, x.byteOffset, x.byteLength)
+  return swap ? Buffer.from(b).swap16() : b
+}
 
 // We skip TextDecoder on Node.js, as it's is somewhy significantly slower than Buffer for utf16
 // Also, it incorrectly misses replacements with Node.js is built without ICU, we fix that

package/utf8.d.ts

@@ -1,42 +1,76 @@
+/**
+ * UTF-8 encoding/decoding
+ *
+ * ```js
+ * import { utf8fromString, utf8toString } from '@exodus/bytes/utf8.js'
+ *
+ * // loose
+ * import { utf8fromStringLoose, utf8toStringLoose } from '@exodus/bytes/utf8.js'
+ * ```
+ *
+ * _These methods by design encode/decode BOM (codepoint `U+FEFF` Byte Order Mark) as-is._\
+ * _If you need BOM handling or detection, use `@exodus/bytes/encoding.js`_
+ *
+ * @module @exodus/bytes/utf8.js
+ */
+
 /// <reference types="node" />
 
 import type { OutputFormat, Uint8ArrayBuffer } from './array.js';
 
 /**
- * Encodes a string to UTF-8 bytes (strict mode)
+ * Encode a string to UTF-8 bytes (strict mode)
+ *
  * Throws on invalid Unicode (unpaired surrogates)
- * @param str - The string to encode
+ *
+ * @param string - The string to encode
  * @param format - Output format (default: 'uint8')
  * @returns The encoded bytes
  */
-export function utf8fromString(str: string, format?: 'uint8'): Uint8ArrayBuffer;
-export function utf8fromString(str: string, format: 'buffer'): Buffer;
-export function utf8fromString(str: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function utf8fromString(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function utf8fromString(string: string, format: 'buffer'): Buffer;
+export function utf8fromString(string: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
 
 /**
- * Encodes a string to UTF-8 bytes (loose mode)
- * Replaces invalid Unicode with replacement character
- * @param str - The string to encode
+ * Encode a string to UTF-8 bytes (loose mode)
+ *
+ * Replaces invalid Unicode (unpaired surrogates) with replacement codepoints `U+FFFD`
+ * per [WHATWG Encoding](https://encoding.spec.whatwg.org/) specification.
+ *
+ * _Such replacement is a non-injective function, is irreversable and causes collisions.\
+ * Prefer using strict throwing methods for cryptography applications._
+ *
+ * @param string - The string to encode
  * @param format - Output format (default: 'uint8')
  * @returns The encoded bytes
  */
-export function utf8fromStringLoose(str: string, format?: 'uint8'): Uint8ArrayBuffer;
-export function utf8fromStringLoose(str: string, format: 'buffer'): Buffer;
-export function utf8fromStringLoose(str: string, format?: OutputFormat): Uint8ArrayBuffer | Buffer;
+export function utf8fromStringLoose(string: string, format?: 'uint8'): Uint8ArrayBuffer;
+export function utf8fromStringLoose(string: string, format: 'buffer'): Buffer;
+export function utf8fromStringLoose(
+  string: string,
+  format?: OutputFormat
+): Uint8ArrayBuffer | Buffer;
 
 /**
- * Decodes UTF-8 bytes to a string (strict mode)
- * Throws on invalid UTF-8 sequences
+ * Decode UTF-8 bytes to a string (strict mode)
+ *
+ * Throws on invalid UTF-8 byte sequences
+ *
  * @param arr - The bytes to decode
  * @returns The decoded string
  */
-export function utf8toString(arr: Uint8ArrayBuffer): string;
+export function utf8toString(arr: Uint8Array): string;
 
 /**
- * Decodes UTF-8 bytes to a string (loose mode)
- * Replaces invalid sequences with replacement character
+ * Decode UTF-8 bytes to a string (loose mode)
+ *
+ * Replaces invalid UTF-8 byte sequences with replacement codepoints `U+FFFD`
+ * per [WHATWG Encoding](https://encoding.spec.whatwg.org/) specification.
+ *
+ * _Such replacement is a non-injective function, is irreversable and causes collisions.\
+ * Prefer using strict throwing methods for cryptography applications._
+ *
  * @param arr - The bytes to decode
  * @returns The decoded string
  */
-export function utf8toStringLoose(arr: Uint8ArrayBuffer): string;
-
+export function utf8toStringLoose(arr: Uint8Array): string;

package/utf8.js

@@ -35,8 +35,13 @@ 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
-      if (str !== decode(res)) throw new TypeError(E_STRICT_UNICODE)
-      return res
+      if (!nativeDecoder && str.length < 1e7) {
+        // This is ~2x faster than decode in Hermes
+        try {
+          if (encodeURI(str) !== null) return res // guard against optimizing out
+        } catch {}
+      } else if (str === decode(res)) return res
+      throw new TypeError(E_STRICT_UNICODE)
     }
   }
 

package/utf8.node.js

@@ -9,7 +9,7 @@ if (Buffer.TYPED_ARRAY_SUPPORT) throw new Error('Unexpected Buffer polyfill')
 let decoderFatal
 const decoderLoose = new TextDecoder('utf-8', { ignoreBOM: true })
 const { isWellFormed } = String.prototype
-const isDeno = Boolean(globalThis.Deno)
+const isDeno = !!globalThis.Deno
 
 try {
   decoderFatal = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true })

package/wif.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Wallet Import Format (WIF) encoding and decoding.
+ *
+ * ```js
+ * import { fromWifString, toWifString } from '@exodus/bytes/wif.js'
+ * import { fromWifStringSync, toWifStringSync } from '@exodus/bytes/wif.js'
+ * ```
+ *
+ * On non-Node.js, requires peer dependency [@noble/hashes](https://www.npmjs.com/package/@noble/hashes) to be installed.
+ *
+ * @module @exodus/bytes/wif.js
+ */
+
+/// <reference types="node" />
+
+import type { Uint8ArrayBuffer } from './array.js';
+
+/**
+ * WIF (Wallet Import Format) data structure
+ */
+export interface Wif {
+  /** Network version byte */
+  version: number;
+  /** 32-byte private key */
+  privateKey: Uint8ArrayBuffer;
+  /** Whether the key is compressed */
+  compressed: boolean;
+}
+
+/**
+ * Decode a WIF string to WIF data
+ *
+ * Returns a promise that resolves to an object with `{ version, privateKey, compressed }`.
+ *
+ * The optional `version` parameter validates the version byte.
+ *
+ * Throws if the WIF string is invalid or version doesn't match.
+ *
+ * @param string - The WIF encoded string
+ * @param version - Optional expected version byte to validate against
+ * @returns The decoded WIF data
+ * @throws Error if the WIF string is invalid or version doesn't match
+ */
+export function fromWifString(string: string, version?: number): Promise<Wif>;
+
+/**
+ * Decode a WIF string to WIF data (synchronous)
+ *
+ * Returns an object with `{ version, privateKey, compressed }`.
+ *
+ * The optional `version` parameter validates the version byte.
+ *
+ * Throws if the WIF string is invalid or version doesn't match.
+ *
+ * @param string - The WIF encoded string
+ * @param version - Optional expected version byte to validate against
+ * @returns The decoded WIF data
+ * @throws Error if the WIF string is invalid or version doesn't match
+ */
+export function fromWifStringSync(string: string, version?: number): Wif;
+
+/**
+ * Encode WIF data to a WIF string
+ *
+ * @param wif - The WIF data to encode
+ * @returns The WIF encoded string
+ */
+export function toWifString(wif: Wif): Promise<string>;
+
+/**
+ * Encode WIF data to a WIF string (synchronous)
+ *
+ * @param wif - The WIF data to encode
+ * @returns The WIF encoded string
+ */
+export function toWifStringSync(wif: Wif): string;