quantum-coin-js-sdk 1.0.36 → 1.0.39

package/example/node_modules/ethers/src.ts/utils/base58.ts

@@ -1,73 +0,0 @@
-/**
- *  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 {
-    const bytes = getBytes(_value);
-
-    let value = toBigInt(bytes);
-    let result = "";
-    while (value) {
-        result = Alphabet[Number(value % BN_58)] + result;
-        value /= BN_58;
-    }
-
-    // Account for leading padding zeros
-    for (let i = 0; i < bytes.length; i++) {
-        if (bytes[i]) { break; }
-        result = Alphabet[0] + result;
-    }
-
-    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/example/node_modules/ethers/src.ts/utils/base64-browser.ts

@@ -1,25 +0,0 @@
-
-// 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/example/node_modules/ethers/src.ts/utils/base64.ts

@@ -1,56 +0,0 @@
-/**
- *  [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/example/node_modules/ethers/src.ts/utils/data.ts

@@ -1,200 +0,0 @@
-/**
- *  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.length % 2) === 0 &&
-      value.match(/^0x[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);
-}