quantumcoin 6.14.5 → 7.0.2

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

@@ -1,81 +0,0 @@
-import { assert, makeError } from "./errors.js";
-
-import type {
-    FetchGetUrlFunc, FetchRequest, FetchCancelSignal, GetUrlResponse
-} from "./fetch.js";
-
-export function createGetUrl(options?: Record<string, any>): FetchGetUrlFunc {
-
-    async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise<GetUrlResponse> {
-        assert(_signal == null || !_signal.cancelled, "request cancelled before sending", "CANCELLED");
-
-        const protocol = req.url.split(":")[0].toLowerCase();
-
-        assert(protocol === "http" || protocol === "https", `unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", {
-            info: { protocol },
-            operation: "request"
-        });
-
-        assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
-            operation: "request"
-        });
-
-        let error: null | Error = null;
-
-        const controller = new AbortController();
-
-        const timer = setTimeout(() => {
-            error = makeError("request timeout", "TIMEOUT");
-            controller.abort();
-        }, req.timeout);
-
-        if (_signal) {
-            _signal.addListener(() => {
-                error = makeError("request cancelled", "CANCELLED");
-                controller.abort();
-            });
-        }
-
-        const init = Object.assign({ }, options, {
-            method: req.method,
-            headers: new Headers(Array.from(req)),
-            body: req.body || undefined,
-            signal: controller.signal
-        });
-
-        let resp: Awaited<ReturnType<typeof fetch>>;
-        try {
-            resp = await fetch(req.url, init);
-        } catch (_error) {
-            clearTimeout(timer);
-            if (error) { throw error; }
-            throw _error;
-        }
-
-        clearTimeout(timer);
-
-        const headers: Record<string, string> = { };
-        resp.headers.forEach((value, key) => {
-            headers[key.toLowerCase()] = value;
-        });
-
-        const respBody = await resp.arrayBuffer();
-        const body = (respBody == null) ? null: new Uint8Array(respBody);
-
-        return {
-            statusCode: resp.status,
-            statusMessage: resp.statusText,
-            headers, body
-        };
-    }
-
-    return getUrl;
-}
-
-// @TODO: remove in v7; provided for backwards compat
-const defaultGetUrl: FetchGetUrlFunc = createGetUrl({ });
-
-export async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise<GetUrlResponse> {
-    return defaultGetUrl(req, _signal);
-}
-

package/src.ts/utils/geturl.ts

@@ -1,134 +0,0 @@
-import http from "http";
-import https from "https";
-import { gunzipSync } from "zlib";
-
-import { assert, makeError } from "./errors.js";
-import { getBytes } from "./data.js";
-
-import type {
-    FetchGetUrlFunc, FetchRequest, FetchCancelSignal, GetUrlResponse
-} from "./fetch.js";
-
-/**
- *  @_ignore:
- */
-export function createGetUrl(options?: Record<string, any>): FetchGetUrlFunc {
-
-    async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise<GetUrlResponse> {
-        // Make sure we weren't cancelled before sending
-        assert(signal == null || !signal.cancelled, "request cancelled before sending", "CANCELLED");
-
-        const protocol = req.url.split(":")[0].toLowerCase();
-
-        assert(protocol === "http" || protocol === "https", `unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", {
-            info: { protocol },
-            operation: "request"
-        });
-
-        assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", {
-            operation: "request"
-        });
-
-        const method = req.method;
-        const headers = Object.assign({ }, req.headers);
-
-        const reqOptions: any = { method, headers };
-        if (options) {
-            if (options.agent) { reqOptions.agent = options.agent; }
-        }
-
-        // Create a Node-specific AbortController, if available
-        let abort: null | AbortController = null;
-        try {
-            abort = new AbortController();
-            reqOptions.abort = abort.signal;
-        } catch (e) { console.log(e); }
-
-        const request = ((protocol === "http") ? http: https).request(req.url, reqOptions);
-
-        request.setTimeout(req.timeout);
-
-        const body = req.body;
-        if (body) { request.write(Buffer.from(body)); }
-
-        request.end();
-
-        return new Promise((resolve, reject) => {
-
-            if (signal) {
-                signal.addListener(() => {
-                    if (abort) { abort.abort(); }
-                    reject(makeError("request cancelled", "CANCELLED"));
-                });
-            }
-
-            request.on("timeout", () => {
-                reject(makeError("request timeout", "TIMEOUT"));
-            });
-
-            request.once("response", (resp: http.IncomingMessage) => {
-                const statusCode = resp.statusCode || 0;
-                const statusMessage = resp.statusMessage || "";
-                const headers = Object.keys(resp.headers || {}).reduce((accum, name) => {
-                    let value = resp.headers[name] || "";
-                    if (Array.isArray(value)) {
-                        value = value.join(", ");
-                    }
-                    accum[name] = value;
-                    return accum;
-                }, <{ [ name: string ]: string }>{ });
-
-                let body: null | Uint8Array = null;
-                //resp.setEncoding("utf8");
-
-                resp.on("data", (chunk: Uint8Array) => {
-                    if (signal) {
-                        try {
-                            signal.checkSignal();
-                        } catch (error) {
-                            return reject(error);
-                        }
-                    }
-
-                    if (body == null) {
-                        body = chunk;
-                    } else {
-                        const newBody = new Uint8Array(body.length + chunk.length);
-                        newBody.set(body, 0);
-                        newBody.set(chunk, body.length);
-                        body = newBody;
-                    }
-                });
-
-                resp.on("end", () => {
-                    if (headers["content-encoding"] === "gzip" && body) {
-                        body = getBytes(gunzipSync(body));
-                    }
-
-                    resolve({ statusCode, statusMessage, headers, body });
-                });
-
-                resp.on("error", (error) => {
-                //@TODO: Should this just return nornal response with a server error?
-                    (<any>error).response = { statusCode, statusMessage, headers, body };
-                    reject(error);
-                });
-            });
-
-            request.on("error", (error) => { reject(error); });
-        });
-    }
-
-    return getUrl;
-}
-
-// @TODO: remove in v7; provided for backwards compat
-const defaultGetUrl: FetchGetUrlFunc = createGetUrl({ });
-
-/**
- *  @_ignore:
- */
-export async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise<GetUrlResponse> {
-    return defaultGetUrl(req, signal);
-}
-

package/src.ts/utils/index.ts

@@ -1,95 +0,0 @@
-/**
- *  There are many simple utilities required to interact with
- *  Ethereum and to simplify the library, without increasing
- *  the library dependencies for simple functions.
- *
- *  @_section api/utils:Utilities  [about-utils]
- */
-
-export { decodeBase58, encodeBase58 } from "./base58.js";
-
-export { decodeBase64, encodeBase64 } from "./base64.js";
-
-export {
-    getBytes, getBytesCopy, isHexString, isBytesLike, hexlify, concat, dataLength, dataSlice,
-    stripZerosLeft, zeroPadValue, zeroPadBytes
-} from "./data.js";
-
-export {
-    isCallException, isError,
-    assert, assertArgument, assertArgumentCount, assertPrivate, assertNormalize, makeError
-} from "./errors.js"
-
-export { EventPayload } from "./events.js";
-
-export {
-    FetchRequest, FetchResponse, FetchCancelSignal,
-} from "./fetch.js";
-
-export { FixedNumber } from "./fixednumber.js"
-
-export {
-    fromTwos, toTwos, mask,
-    getBigInt, getNumber, getUint, toBigInt, toNumber, toBeHex, toBeArray, toQuantity
-} from "./maths.js";
-
-export { resolveProperties, defineProperties} from "./properties.js";
-
-export { decodeRlp } from "./rlp-decode.js";
-export { encodeRlp } from "./rlp-encode.js";
-
-export { formatEther, parseEther, formatUnits, parseUnits } from "./units.js";
-
-export {
-    toUtf8Bytes,
-    toUtf8CodePoints,
-    toUtf8String,
-
-    Utf8ErrorFuncs,
-} from "./utf8.js";
-
-export { uuidV4 } from "./uuid.js";
-
-/////////////////////////////
-// Types
-
-export type { BytesLike } from "./data.js";
-
-export type {
-
-    //ErrorFetchRequestWithBody, ErrorFetchRequest,
-    //ErrorFetchResponseWithBody, ErrorFetchResponse,
-
-    ErrorCode,
-
-    EthersError, UnknownError, NotImplementedError, UnsupportedOperationError, NetworkError,
-    ServerError, TimeoutError, BadDataError, CancelledError, BufferOverrunError,
-    NumericFaultError, InvalidArgumentError, MissingArgumentError, UnexpectedArgumentError,
-    CallExceptionError, InsufficientFundsError, NonceExpiredError, OffchainFaultError,
-    ReplacementUnderpricedError, TransactionReplacedError, UnconfiguredNameError,
-    ActionRejectedError,
-
-    CallExceptionAction, CallExceptionTransaction,
-
-    CodedEthersError
-} from "./errors.js"
-
-export type { EventEmitterable, Listener } from "./events.js";
-
-export type {
-    GetUrlResponse,
-    FetchPreflightFunc, FetchProcessFunc, FetchRetryFunc,
-    FetchGatewayFunc, FetchGetUrlFunc
-} from "./fetch.js";
-
-export type { FixedFormat } from "./fixednumber.js"
-
-export type { BigNumberish, Numeric } from "./maths.js";
-
-export type { RlpStructuredData, RlpStructuredDataish } from "./rlp.js";
-
-export type {
-    Utf8ErrorFunc,
-    UnicodeNormalizationForm,
-    Utf8ErrorReason
-} from "./utf8.js";

package/src.ts/utils/maths.ts

@@ -1,240 +0,0 @@
-/**
- *  Some mathematic operations.
- *
- *  @_subsection: api/utils:Math Helpers  [about-maths]
- */
-import { hexlify, isBytesLike } from "./data.js";
-import { assert, assertArgument } from "./errors.js";
-
-import type { BytesLike } from "./data.js";
-
-/**
- *  Any type that can be used where a numeric value is needed.
- */
-export type Numeric = number | bigint;
-
-/**
- *  Any type that can be used where a big number is needed.
- */
-export type BigNumberish = string | Numeric;
-
-
-const BN_0 = BigInt(0);
-const BN_1 = BigInt(1);
-
-//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;
-
-
-// IEEE 754 support 53-bits of mantissa
-const maxValue = 0x1fffffffffffff;
-
-/**
- *  Convert %%value%% from a twos-compliment representation of %%width%%
- *  bits to its value.
- *
- *  If the highest bit is ``1``, the result will be negative.
- */
-export function fromTwos(_value: BigNumberish, _width: Numeric): bigint {
-    const value = getUint(_value, "value");
-    const width = BigInt(getNumber(_width, "width"));
-
-    assert((value >> width) === BN_0, "overflow", "NUMERIC_FAULT", {
-        operation: "fromTwos", fault: "overflow", value: _value
-    });
-
-    // Top bit set; treat as a negative value
-    if (value >> (width - BN_1)) {
-        const mask = (BN_1 << width) - BN_1;
-        return -(((~value) & mask) + BN_1);
-    }
-
-    return value;
-}
-
-/**
- *  Convert %%value%% to a twos-compliment representation of
- *  %%width%% bits.
- *
- *  The result will always be positive.
- */
-export function toTwos(_value: BigNumberish, _width: Numeric): bigint {
-    let value = getBigInt(_value, "value");
-    const width = BigInt(getNumber(_width, "width"));
-
-    const limit = (BN_1 << (width - BN_1));
-
-    if (value < BN_0) {
-        value = -value;
-        assert(value <= limit, "too low", "NUMERIC_FAULT", {
-            operation: "toTwos", fault: "overflow", value: _value
-        });
-        const mask = (BN_1 << width) - BN_1;
-        return ((~value) & mask) + BN_1;
-    } else {
-        assert(value < limit, "too high", "NUMERIC_FAULT", {
-            operation: "toTwos", fault: "overflow", value: _value
-        });
-    }
-
-    return value;
-}
-
-/**
- *  Mask %%value%% with a bitmask of %%bits%% ones.
- */
-export function mask(_value: BigNumberish, _bits: Numeric): bigint {
-    const value = getUint(_value, "value");
-    const bits = BigInt(getNumber(_bits, "bits"));
-    return value & ((BN_1 << bits) - BN_1);
-}
-
-/**
- *  Gets a BigInt from %%value%%. If it is an invalid value for
- *  a BigInt, then an ArgumentError will be thrown for %%name%%.
- */
-export function getBigInt(value: BigNumberish, name?: string): bigint {
-    switch (typeof(value)) {
-        case "bigint": return value;
-        case "number":
-            assertArgument(Number.isInteger(value), "underflow", name || "value", value);
-            assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
-            return BigInt(value);
-        case "string":
-            try {
-                if (value === "") { throw new Error("empty string"); }
-                if (value[0] === "-" && value[1] !== "-") {
-                    return -BigInt(value.substring(1));
-                }
-                return BigInt(value);
-            } catch(e: any) {
-                assertArgument(false, `invalid BigNumberish string: ${ e.message }`, name || "value", value);
-            }
-    }
-    assertArgument(false, "invalid BigNumberish value", name || "value", value);
-}
-
-/**
- *  Returns %%value%% as a bigint, validating it is valid as a bigint
- *  value and that it is positive.
- */
-export function getUint(value: BigNumberish, name?: string): bigint {
-    const result = getBigInt(value, name);
-    assert(result >= BN_0, "unsigned value cannot be negative", "NUMERIC_FAULT", {
-        fault: "overflow", operation: "getUint", value
-    });
-    return result;
-}
-
-const Nibbles = "0123456789abcdef";
-
-/*
- * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it
- * is treated as Big Endian data.
- */
-export function toBigInt(value: BigNumberish | Uint8Array): bigint {
-    if (value instanceof Uint8Array) {
-        let result = "0x0";
-        for (const v of value) {
-            result += Nibbles[v >> 4];
-            result += Nibbles[v & 0x0f];
-        }
-        return BigInt(result);
-    }
-
-    return getBigInt(value);
-}
-
-/**
- *  Gets a //number// from %%value%%. If it is an invalid value for
- *  a //number//, then an ArgumentError will be thrown for %%name%%.
- */
-export function getNumber(value: BigNumberish, name?: string): number {
-    switch (typeof(value)) {
-        case "bigint":
-            assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
-            return Number(value);
-        case "number":
-            assertArgument(Number.isInteger(value), "underflow", name || "value", value);
-            assertArgument(value >= -maxValue && value <= maxValue, "overflow", name || "value", value);
-            return value;
-        case "string":
-            try {
-                if (value === "") { throw new Error("empty string"); }
-                return getNumber(BigInt(value), name);
-            } catch(e: any) {
-                assertArgument(false, `invalid numeric string: ${ e.message }`, name || "value", value);
-            }
-    }
-    assertArgument(false, "invalid numeric value", name || "value", value);
-}
-
-
-/**
- *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it
- *  is treated as Big Endian data. Throws if the value is not safe.
- */
-export function toNumber(value: BigNumberish | Uint8Array): number {
-    return getNumber(toBigInt(value));
-}
-
-/**
- *  Converts %%value%% to a Big Endian hexstring, optionally padded to
- *  %%width%% bytes.
- */
-export function toBeHex(_value: BigNumberish, _width?: Numeric): string {
-    const value = getUint(_value, "value");
-
-    let result = value.toString(16);
-
-    if (_width == null) {
-        // Ensure the value is of even length
-        if (result.length % 2) { result = "0" + result; }
-    } else {
-        const width = getNumber(_width, "width");
-        assert(width * 2 >= result.length, `value exceeds width (${ width } bytes)`, "NUMERIC_FAULT", {
-            operation: "toBeHex",
-            fault: "overflow",
-            value: _value
-        });
-
-        // Pad the value to the required width
-        while (result.length < (width * 2)) { result = "0" + result; }
-
-    }
-
-    return "0x" + result;
-}
-
-/**
- *  Converts %%value%% to a Big Endian Uint8Array.
- */
-export function toBeArray(_value: BigNumberish): Uint8Array {
-    const value = getUint(_value, "value");
-
-    if (value === BN_0) { return new Uint8Array([ ]); }
-
-    let hex = value.toString(16);
-    if (hex.length % 2) { hex = "0" + hex; }
-
-    const result = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < result.length; i++) {
-        const offset = i * 2;
-        result[i] = parseInt(hex.substring(offset, offset + 2), 16);
-    }
-
-    return result;
-}
-
-/**
- *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.
- *
- *  A //Quantity// does not have and leading 0 values unless the value is
- *  the literal value `0x0`. This is most commonly used for JSSON-RPC
- *  numeric values.
- */
-export function toQuantity(value: BytesLike | BigNumberish): string {
-    let result = hexlify(isBytesLike(value) ? value: toBeArray(value)).substring(2);
-    while (result.startsWith("0")) { result = result.substring(1); }
-    if (result === "") { result = "0"; }
-    return "0x" + result;
-}

package/src.ts/utils/properties.ts

@@ -1,60 +0,0 @@
-/**
- *  Property helper functions.
- *
- *  @_subsection api/utils:Properties  [about-properties]
- */
-
-function checkType(value: any, type: string, name: string): void {
-    const types = type.split("|").map(t => t.trim());
-    for (let i = 0; i < types.length; i++) {
-        switch (type) {
-            case "any":
-                return;
-            case "bigint":
-            case "boolean":
-            case "number":
-            case "string":
-                if (typeof(value) === type) { return; }
-        }
-    }
-
-    const error: any = new Error(`invalid value for type ${ type }`);
-    error.code = "INVALID_ARGUMENT";
-    error.argument = `value.${ name }`;
-    error.value = value;
-
-    throw error;
-}
-
-/**
- *  Resolves to a new object that is a copy of %%value%%, but with all
- *  values resolved.
- */
-export async function resolveProperties<T>(value: { [ P in keyof T ]: T[P] | Promise<T[P]>}): Promise<T> {
-    const keys = Object.keys(value);
-    const results = await Promise.all(keys.map((k) => Promise.resolve(value[<keyof T>k])));
-    return results.reduce((accum: any, v, index) => {
-        accum[keys[index]] = v;
-        return accum;
-    }, <{ [ P in keyof T]: T[P] }>{ });
-}
-
-/**
- *  Assigns the %%values%% to %%target%% as read-only values.
- *
- *  It %%types%% is specified, the values are checked.
- */
-export function defineProperties<T>(
- target: T,
- values: { [ K in keyof T ]?: T[K] },
- types?: { [ K in keyof T ]?: string }): void {
-
-    for (let key in values) {
-        let value = values[key];
-
-        const type = (types ? types[key]: null);
-        if (type) { checkType(value, type, key); }
-
-        Object.defineProperty(target, key, { enumerable: true, value, writable: false });
-    }
-}