eteres 0.0.1-security → 6.7.1

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

@@ -0,0 +1,72 @@
+import { assert } from "./errors.js";
+
+import type { FetchRequest, FetchCancelSignal, GetUrlResponse } from "./fetch.js";
+
+
+declare global {
+    class Headers {
+        constructor(values: Array<[ string, string ]>);
+        forEach(func: (v: string, k: string) => void): void;
+    }
+
+    class Response {
+        status: number;
+        statusText: string;
+        headers: Headers;
+        arrayBuffer(): Promise<ArrayBuffer>;
+    }
+
+    type FetchInit = {
+        method?: string,
+        headers?: Headers,
+        body?: Uint8Array
+    };
+
+    function fetch(url: string, init: FetchInit): Promise<Response>;
+}
+
+// @TODO: timeout is completely ignored; start a Promise.any with a reject?
+
+export async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise<GetUrlResponse> {
+    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 signal: undefined | AbortSignal = undefined;
+    if (_signal) {
+        const controller = new AbortController();
+        signal = controller.signal;
+        _signal.addListener(() => { controller.abort(); });
+    }
+
+    const init = {
+        method: req.method,
+        headers: new Headers(Array.from(req)),
+        body: req.body || undefined,
+        signal
+    };
+
+    const resp = await fetch(req.url, init);
+
+    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
+    };
+}
+

package/src.ts/utils/geturl.ts

@@ -0,0 +1,96 @@
+import http from "http";
+import https from "https";
+import { gunzipSync } from "zlib";
+
+import { assert } from "./errors.js";
+import { getBytes } from "./data.js";
+
+import type { FetchRequest, FetchCancelSignal, GetUrlResponse } from "./fetch.js";
+
+/**
+ *  @_ignore:
+ */
+export async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise<GetUrlResponse> {
+
+    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 options: any = { method, headers };
+
+    const request = ((protocol === "http") ? http: https).request(req.url, options);
+
+    request.setTimeout(req.timeout);
+
+    const body = req.body;
+    if (body) { request.write(Buffer.from(body)); }
+
+    request.end();
+
+    return new Promise((resolve, reject) => {
+        // @TODO: Node 15 added AbortSignal; once we drop support for
+        // Node14, we can add that in here too
+
+        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); });
+    });
+}
+

package/src.ts/utils/index.ts

@@ -0,0 +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 } from "./rlp.js";
+
+export type {
+    Utf8ErrorFunc,
+    UnicodeNormalizationForm,
+    Utf8ErrorReason
+} from "./utf8.js";

package/src.ts/utils/maths.ts

@@ -0,0 +1,240 @@
+/**
+ *  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 } bits)`, "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

@@ -0,0 +1,60 @@
+/**
+ *  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 });
+    }
+}

package/src.ts/utils/rlp-decode.ts

@@ -0,0 +1,104 @@
+//See: https://github.com/ethereum/wiki/wiki/RLP
+
+import { hexlify } from "./data.js";
+import { assert, assertArgument } from "./errors.js";
+import { getBytes } from "./data.js";
+
+import type { BytesLike, RlpStructuredData } from "./index.js";
+
+
+function hexlifyByte(value: number): string {
+    let result = value.toString(16);
+    while (result.length < 2) { result = "0" + result; }
+    return "0x" + result;
+}
+
+function unarrayifyInteger(data: Uint8Array, offset: number, length: number): number {
+    let result = 0;
+    for (let i = 0; i < length; i++) {
+        result = (result * 256) + data[offset + i];
+    }
+    return result;
+}
+
+type Decoded = {
+    result: any;
+    consumed: number;
+};
+
+function _decodeChildren(data: Uint8Array, offset: number, childOffset: number, length: number): Decoded {
+    const result: Array<any> = [];
+
+    while (childOffset < offset + 1 + length) {
+        const decoded = _decode(data, childOffset);
+
+        result.push(decoded.result);
+
+        childOffset += decoded.consumed;
+        assert(childOffset <= offset + 1 + length, "child data too short", "BUFFER_OVERRUN", {
+            buffer: data, length, offset
+        });
+    }
+
+    return {consumed: (1 + length), result: result};
+}
+
+// returns { consumed: number, result: Object }
+function _decode(data: Uint8Array, offset: number): { consumed: number, result: any } {
+    assert(data.length !== 0, "data too short", "BUFFER_OVERRUN", {
+        buffer: data, length: 0, offset: 1
+    });
+
+    const checkOffset = (offset: number) => {
+        assert(offset <= data.length, "data short segment too short", "BUFFER_OVERRUN", {
+            buffer: data, length: data.length, offset
+        });
+    };
+
+    // Array with extra length prefix
+    if (data[offset] >= 0xf8) {
+        const lengthLength = data[offset] - 0xf7;
+        checkOffset(offset + 1 + lengthLength);
+
+        const length = unarrayifyInteger(data, offset + 1, lengthLength);
+        checkOffset(offset + 1 + lengthLength + length);
+
+        return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);
+
+    } else if (data[offset] >= 0xc0) {
+        const length = data[offset] - 0xc0;
+        checkOffset(offset + 1 + length);
+
+        return _decodeChildren(data, offset, offset + 1, length);
+
+    } else if (data[offset] >= 0xb8) {
+        const lengthLength = data[offset] - 0xb7;
+        checkOffset(offset + 1 + lengthLength);
+
+        const length = unarrayifyInteger(data, offset + 1, lengthLength);
+        checkOffset(offset + 1 + lengthLength + length);
+
+        const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));
+        return { consumed: (1 + lengthLength + length), result: result }
+
+    } else if (data[offset] >= 0x80) {
+        const length = data[offset] - 0x80;
+        checkOffset(offset + 1 + length);
+
+        const result = hexlify(data.slice(offset + 1, offset + 1 + length));
+        return { consumed: (1 + length), result: result }
+    }
+
+    return { consumed: 1, result: hexlifyByte(data[offset]) };
+}
+
+/**
+ *  Decodes %%data%% into the structured data it represents.
+ */
+export function decodeRlp(_data: BytesLike): RlpStructuredData {
+    const data = getBytes(_data, "data");
+    const decoded = _decode(data, 0);
+    assertArgument(decoded.consumed === data.length, "unexpected junk after rlp payload", "data", _data);
+    return decoded.result;
+}
+