eteres 0.0.1-security → 6.7.1

package/src.ts/utils/base58.ts

@@ -0,0 +1,64 @@
+/**
+ *  The [Base58 Encoding](link-base58) scheme allows a **numeric** value
+ *  to be encoded as a compact string using a radix of 58 using only
+ *  alpha-numeric characters. Confusingly similar characters are omitted
+ *  (i.e. ``"l0O"``).
+ *
+ *  Note that Base58 encodes a **numeric** value, not arbitrary bytes,
+ *  since any zero-bytes on the left would get removed. To mitigate this
+ *  issue most schemes that use Base58 choose specific high-order values
+ *  to ensure non-zero prefixes.
+ *
+ *  @_subsection: api/utils:Base58 Encoding [about-base58]
+ */
+
+import { getBytes } from "./data.js";
+import { assertArgument } from "./errors.js";
+import { toBigInt } from "./maths.js";
+
+import type { BytesLike } from "./index.js";
+
+
+const Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+let Lookup: null | Record<string, bigint> = null;
+
+function getAlpha(letter: string): bigint {
+    if (Lookup == null) {
+        Lookup = { };
+        for (let i = 0; i < Alphabet.length; i++) {
+            Lookup[Alphabet[i]] = BigInt(i);
+        }
+    }
+    const result = Lookup[letter];
+    assertArgument(result != null, `invalid base58 value`, "letter", letter);
+    return result;
+}
+
+
+const BN_0 = BigInt(0);
+const BN_58 = BigInt(58);
+
+/**
+ *  Encode %%value%% as a Base58-encoded string.
+ */
+export function encodeBase58(_value: BytesLike): string {
+    let value = toBigInt(getBytes(_value));
+    let result = "";
+    while (value) {
+        result = Alphabet[Number(value % BN_58)] + result;
+        value /= BN_58;
+    }
+    return result;
+}
+
+/**
+ *  Decode the Base58-encoded %%value%%.
+ */
+export function decodeBase58(value: string): bigint {
+    let result = BN_0;
+    for (let i = 0; i < value.length; i++) {
+        result *= BN_58;
+        result += getAlpha(value[i]);
+    }
+    return result;
+}

package/src.ts/utils/base64-browser.ts

@@ -0,0 +1,25 @@
+
+// utils/base64-browser
+
+import { getBytes } from "./data.js";
+
+import type { BytesLike } from "./data.js";
+
+
+export function decodeBase64(textData: string): Uint8Array {
+    textData = atob(textData);
+    const data = new Uint8Array(textData.length);
+    for (let i = 0; i < textData.length; i++) {
+        data[i] = textData.charCodeAt(i);
+    }
+    return getBytes(data);
+}
+
+export function encodeBase64(_data: BytesLike): string {
+    const data = getBytes(_data);
+    let textData = "";
+    for (let i = 0; i < data.length; i++) {
+        textData += String.fromCharCode(data[i]);
+    }
+    return btoa(textData);
+}

package/src.ts/utils/base64.ts

@@ -0,0 +1,56 @@
+/**
+ *  [Base64 encoding](link-wiki-base64) using 6-bit words to encode
+ *  arbitrary bytes into a string using 65 printable symbols, the
+ *  upper-case and lower-case alphabet, the digits ``0`` through ``9``,
+ *  ``"+"`` and ``"/"`` with the ``"="`` used for padding.
+ *
+ *  @_subsection: api/utils:Base64 Encoding  [about-base64]
+ */
+import { getBytes, getBytesCopy } from "./data.js";
+
+import type { BytesLike } from "./data.js";
+
+
+/**
+ *  Decodes the base-64 encoded %%value%%.
+ *
+ *  @example:
+ *    // The decoded value is always binary data...
+ *    result = decodeBase64("SGVsbG8gV29ybGQhIQ==")
+ *    //_result:
+ *
+ *    // ...use toUtf8String to convert it to a string.
+ *    toUtf8String(result)
+ *    //_result:
+ *
+ *    // Decoding binary data
+ *    decodeBase64("EjQ=")
+ *    //_result:
+ */
+export function decodeBase64(value: string): Uint8Array {
+    return getBytesCopy(Buffer.from(value, "base64"));
+};
+
+/**
+ *  Encodes %%data%% as a base-64 encoded string.
+ *
+ *  @example:
+ *    // Encoding binary data as a hexstring
+ *    encodeBase64("0x1234")
+ *    //_result:
+ *
+ *    // Encoding binary data as a Uint8Array
+ *    encodeBase64(new Uint8Array([ 0x12, 0x34 ]))
+ *    //_result:
+ *
+ *    // The input MUST be data...
+ *    encodeBase64("Hello World!!")
+ *    //_error:
+ *
+ *    // ...use toUtf8Bytes for this.
+ *    encodeBase64(toUtf8Bytes("Hello World!!"))
+ *    //_result:
+ */
+export function encodeBase64(data: BytesLike): string {
+    return Buffer.from(getBytes(data)).toString("base64");
+}

package/src.ts/utils/data.ts

@@ -0,0 +1,199 @@
+/**
+ *  Some data helpers.
+ *
+ *
+ *  @_subsection api/utils:Data Helpers  [about-data]
+ */
+import { assert, assertArgument } from "./errors.js";
+
+/**
+ *  A [[HexString]] whose length is even, which ensures it is a valid
+ *  representation of binary data.
+ */
+export type DataHexString = string;
+
+/**
+ *  A string which is prefixed with ``0x`` and followed by any number
+ *  of case-agnostic hexadecimal characters.
+ *
+ *  It must match the regular expression ``/0x[0-9A-Fa-f]*\/``.
+ */
+export type HexString = string;
+
+/**
+ *  An object that can be used to represent binary data.
+ */
+export type BytesLike = DataHexString | Uint8Array;
+
+function _getBytes(value: BytesLike, name?: string, copy?: boolean): Uint8Array {
+    if (value instanceof Uint8Array) {
+        if (copy) { return new Uint8Array(value); }
+        return value;
+    }
+
+    if (typeof(value) === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {
+        const result = new Uint8Array((value.length - 2) / 2);
+        let offset = 2;
+        for (let i = 0; i < result.length; i++) {
+            result[i] = parseInt(value.substring(offset, offset + 2), 16);
+            offset += 2;
+        }
+        return result;
+    }
+
+    assertArgument(false, "invalid BytesLike value", name || "value", value);
+}
+
+/**
+ *  Get a typed Uint8Array for %%value%%. If already a Uint8Array
+ *  the original %%value%% is returned; if a copy is required use
+ *  [[getBytesCopy]].
+ *
+ *  @see: getBytesCopy
+ */
+export function getBytes(value: BytesLike, name?: string): Uint8Array {
+    return _getBytes(value, name, false);
+}
+
+/**
+ *  Get a typed Uint8Array for %%value%%, creating a copy if necessary
+ *  to prevent any modifications of the returned value from being
+ *  reflected elsewhere.
+ *
+ *  @see: getBytes
+ */
+export function getBytesCopy(value: BytesLike, name?: string): Uint8Array {
+    return _getBytes(value, name, true);
+}
+
+
+/**
+ *  Returns true if %%value%% is a valid [[HexString]].
+ *
+ *  If %%length%% is ``true`` or a //number//, it also checks that
+ *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)
+ *  bytes of data (e.g. ``0x1234`` is 2 bytes).
+ */
+export function isHexString(value: any, length?: number | boolean): value is `0x${ string }` {
+    if (typeof(value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+        return false
+    }
+
+    if (typeof(length) === "number" && value.length !== 2 + 2 * length) { return false; }
+    if (length === true && (value.length % 2) !== 0) { return false; }
+
+    return true;
+}
+
+/**
+ *  Returns true if %%value%% is a valid representation of arbitrary
+ *  data (i.e. a valid [[DataHexString]] or a Uint8Array).
+ */
+export function isBytesLike(value: any): value is BytesLike {
+    return (isHexString(value, true) || (value instanceof Uint8Array));
+}
+
+const HexCharacters: string = "0123456789abcdef";
+
+/**
+ *  Returns a [[DataHexString]] representation of %%data%%.
+ */
+export function hexlify(data: BytesLike): string {
+    const bytes = getBytes(data);
+
+    let result = "0x";
+    for (let i = 0; i < bytes.length; i++) {
+        const v = bytes[i];
+        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+    }
+    return result;
+}
+
+/**
+ *  Returns a [[DataHexString]] by concatenating all values
+ *  within %%data%%.
+ */
+export function concat(datas: ReadonlyArray<BytesLike>): string {
+    return "0x" + datas.map((d) => hexlify(d).substring(2)).join("");
+}
+
+/**
+ *  Returns the length of %%data%%, in bytes.
+ */
+export function dataLength(data: BytesLike): number {
+    if (isHexString(data, true)) { return (data.length - 2) / 2; }
+    return getBytes(data).length;
+}
+
+/**
+ *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%
+ *  offset to the %%end%% offset.
+ *
+ *  By default %%start%% is 0 and %%end%% is the length of %%data%%.
+ */
+export function dataSlice(data: BytesLike, start?: number, end?: number): string {
+    const bytes = getBytes(data);
+    if (end != null && end > bytes.length) {
+        assert(false, "cannot slice beyond data bounds", "BUFFER_OVERRUN", {
+            buffer: bytes, length: bytes.length, offset: end
+        });
+    }
+    return hexlify(bytes.slice((start == null) ? 0: start, (end == null) ? bytes.length: end));
+}
+
+/**
+ *  Return the [[DataHexString]] result by stripping all **leading**
+ ** zero bytes from %%data%%.
+ */
+export function stripZerosLeft(data: BytesLike): string {
+    let bytes = hexlify(data).substring(2);
+    while (bytes.startsWith("00")) { bytes = bytes.substring(2); }
+    return "0x" + bytes;
+}
+
+function zeroPad(data: BytesLike, length: number, left: boolean): string {
+    const bytes = getBytes(data);
+    assert(length >= bytes.length, "padding exceeds data length", "BUFFER_OVERRUN", {
+        buffer: new Uint8Array(bytes),
+        length: length,
+        offset: length + 1
+    });
+
+    const result = new Uint8Array(length);
+    result.fill(0);
+    if (left) {
+        result.set(bytes, length - bytes.length);
+    } else {
+        result.set(bytes, 0);
+    }
+
+    return hexlify(result);
+}
+
+/**
+ *  Return the [[DataHexString]] of %%data%% padded on the **left**
+ *  to %%length%% bytes.
+ *
+ *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is
+ *  thrown.
+ *
+ *  This pads data the same as **values** are in Solidity
+ *  (e.g. ``uint128``).
+ */
+export function zeroPadValue(data: BytesLike, length: number): string {
+    return zeroPad(data, length, true);
+}
+
+/**
+ *  Return the [[DataHexString]] of %%data%% padded on the **right**
+ *  to %%length%% bytes.
+ *
+ *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is
+ *  thrown.
+ *
+ *  This pads data the same as **bytes** are in Solidity
+ *  (e.g. ``bytes16``).
+ */
+export function zeroPadBytes(data: BytesLike, length: number): string {
+    return zeroPad(data, length, false);
+}