quantumcoin 6.14.2 → 6.14.5

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

@@ -1,81 +1,81 @@
-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);
-}
-
+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 +1,134 @@
-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);
-}
-
+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 +1,95 @@
-/**
- *  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";
+/**
+ *  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";