quantumcoin 6.14.2 → 6.14.5

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

@@ -1,104 +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;
-}
-
+//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;
+}
+

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

@@ -1,64 +1,64 @@
-//See: https://github.com/ethereum/wiki/wiki/RLP
-
-import { getBytes } from "./data.js";
-
-import type { RlpStructuredDataish } from "./rlp.js";
-
-
-function arrayifyInteger(value: number): Array<number> {
-    const result: Array<number> = [];
-    while (value) {
-        result.unshift(value & 0xff);
-        value >>= 8;
-    }
-    return result;
-}
-
-function _encode(object: Array<any> | string | Uint8Array): Array<number> {
-    if (Array.isArray(object)) {
-        let payload: Array<number> = [];
-        object.forEach(function(child) {
-            payload = payload.concat(_encode(child));
-        });
-
-        if (payload.length <= 55) {
-            payload.unshift(0xc0 + payload.length)
-            return payload;
-        }
-
-        const length = arrayifyInteger(payload.length);
-        length.unshift(0xf7 + length.length);
-
-        return length.concat(payload);
-
-    }
-
-    const data: Array<number> = Array.prototype.slice.call(getBytes(object, "object"));
-
-    if (data.length === 1 && data[0] <= 0x7f) {
-        return data;
-
-    } else if (data.length <= 55) {
-        data.unshift(0x80 + data.length);
-        return data;
-    }
-
-    const length = arrayifyInteger(data.length);
-    length.unshift(0xb7 + length.length);
-
-    return length.concat(data);
-}
-
-const nibbles = "0123456789abcdef";
-
-/**
- *  Encodes %%object%% as an RLP-encoded [[DataHexString]].
- */
-export function encodeRlp(object: RlpStructuredDataish): string {
-    let result = "0x";
-    for (const v of _encode(object)) {
-        result += nibbles[v >> 4];
-        result += nibbles[v & 0xf];
-    }
-    return result;
-}
+//See: https://github.com/ethereum/wiki/wiki/RLP
+
+import { getBytes } from "./data.js";
+
+import type { RlpStructuredDataish } from "./rlp.js";
+
+
+function arrayifyInteger(value: number): Array<number> {
+    const result: Array<number> = [];
+    while (value) {
+        result.unshift(value & 0xff);
+        value >>= 8;
+    }
+    return result;
+}
+
+function _encode(object: Array<any> | string | Uint8Array): Array<number> {
+    if (Array.isArray(object)) {
+        let payload: Array<number> = [];
+        object.forEach(function(child) {
+            payload = payload.concat(_encode(child));
+        });
+
+        if (payload.length <= 55) {
+            payload.unshift(0xc0 + payload.length)
+            return payload;
+        }
+
+        const length = arrayifyInteger(payload.length);
+        length.unshift(0xf7 + length.length);
+
+        return length.concat(payload);
+
+    }
+
+    const data: Array<number> = Array.prototype.slice.call(getBytes(object, "object"));
+
+    if (data.length === 1 && data[0] <= 0x7f) {
+        return data;
+
+    } else if (data.length <= 55) {
+        data.unshift(0x80 + data.length);
+        return data;
+    }
+
+    const length = arrayifyInteger(data.length);
+    length.unshift(0xb7 + length.length);
+
+    return length.concat(data);
+}
+
+const nibbles = "0123456789abcdef";
+
+/**
+ *  Encodes %%object%% as an RLP-encoded [[DataHexString]].
+ */
+export function encodeRlp(object: RlpStructuredDataish): string {
+    let result = "0x";
+    for (const v of _encode(object)) {
+        result += nibbles[v >> 4];
+        result += nibbles[v & 0xf];
+    }
+    return result;
+}

package/src.ts/utils/rlp.ts

@@ -1,20 +1,20 @@
-/**
- *  The [[link-rlp]] (RLP) encoding is used throughout Ethereum
- *  to serialize nested structures of Arrays and data.
- *
- *  @_subsection api/utils:Recursive-Length Prefix  [about-rlp]
- */
-
-export { decodeRlp } from "./rlp-decode.js";
-export { encodeRlp } from "./rlp-encode.js";
-
-/**
- *  An RLP-encoded structure.
- */
-export type RlpStructuredData = string | Array<RlpStructuredData>;
-
-/**
- *  An RLP-encoded structure, which allows Uint8Array.
- */
-export type RlpStructuredDataish = string | Uint8Array | Array<RlpStructuredDataish>;
-
+/**
+ *  The [[link-rlp]] (RLP) encoding is used throughout Ethereum
+ *  to serialize nested structures of Arrays and data.
+ *
+ *  @_subsection api/utils:Recursive-Length Prefix  [about-rlp]
+ */
+
+export { decodeRlp } from "./rlp-decode.js";
+export { encodeRlp } from "./rlp-encode.js";
+
+/**
+ *  An RLP-encoded structure.
+ */
+export type RlpStructuredData = string | Array<RlpStructuredData>;
+
+/**
+ *  An RLP-encoded structure, which allows Uint8Array.
+ */
+export type RlpStructuredDataish = string | Uint8Array | Array<RlpStructuredDataish>;
+

package/src.ts/utils/units.ts

@@ -1,91 +1,91 @@
-/**
- *  Most interactions with Ethereum requires integer values, which use
- *  the smallest magnitude unit.
- *
- *  For example, imagine dealing with dollars and cents. Since dollars
- *  are divisible, non-integer values are possible, such as ``$10.77``.
- *  By using the smallest indivisible unit (i.e. cents), the value can
- *  be kept as the integer ``1077``.
- *
- *  When receiving decimal input from the user (as a decimal string),
- *  the value should be converted to an integer and when showing a user
- *  a value, the integer value should be converted to a decimal string.
- *
- *  This creates a clear distinction, between values to be used by code
- *  (integers) and values used for display logic to users (decimals).
- *
- *  The native unit in Ethereum, //ether// is divisible to 18 decimal places,
- *  where each individual unit is called a //wei//.
- *
- *  @_subsection api/utils:Unit Conversion  [about-units]
- */
-import { assertArgument } from "./errors.js";
-import { FixedNumber } from "./fixednumber.js";
-import { getNumber } from "./maths.js";
-
-import type { BigNumberish, Numeric } from "../utils/index.js";
-
-
-const names = [
-    "wei",
-    "kwei",
-    "mwei",
-    "gwei",
-    "szabo",
-    "finney",
-    "ether",
-];
-
-/**
- *  Converts %%value%% into a //decimal string//, assuming %%unit%% decimal
- *  places. The %%unit%% may be the number of decimal places or the name of
- *  a unit (e.g. ``"gwei"`` for 9 decimal places).
- *
- */
-export function formatUnits(value: BigNumberish, unit?: string | Numeric): string {
-    let decimals = 18;
-    if (typeof(unit) === "string") {
-        const index = names.indexOf(unit);
-        assertArgument(index >= 0, "invalid unit", "unit", unit);
-        decimals = 3 * index;
-    } else if (unit != null) {
-        decimals = getNumber(unit, "unit");
-    }
-
-    return FixedNumber.fromValue(value, decimals, { decimals, width: 512 }).toString();
-}
-
-/**
- *  Converts the //decimal string// %%value%% to a BigInt, assuming
- *  %%unit%% decimal places. The %%unit%% may the number of decimal places
- *  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
- */
-export function parseUnits(value: string, unit?: string | Numeric): bigint {
-    assertArgument(typeof(value) === "string", "value must be a string", "value", value);
-
-    let decimals = 18;
-    if (typeof(unit) === "string") {
-        const index = names.indexOf(unit);
-        assertArgument(index >= 0, "invalid unit", "unit", unit);
-        decimals = 3 * index;
-    } else if (unit != null) {
-        decimals = getNumber(unit, "unit");
-    }
-
-    return FixedNumber.fromString(value, { decimals, width: 512 }).value;
-}
-
-/**
- *  Converts %%value%% into a //decimal string// using 18 decimal places.
- */
-export function formatEther(wei: BigNumberish): string {
-    return formatUnits(wei, 18);
-}
-
-/**
- *  Converts the //decimal string// %%ether%% to a BigInt, using 18
- *  decimal places.
- */
-export function parseEther(ether: string): bigint {
-    return parseUnits(ether, 18);
-}
+/**
+ *  Most interactions with Ethereum requires integer values, which use
+ *  the smallest magnitude unit.
+ *
+ *  For example, imagine dealing with dollars and cents. Since dollars
+ *  are divisible, non-integer values are possible, such as ``$10.77``.
+ *  By using the smallest indivisible unit (i.e. cents), the value can
+ *  be kept as the integer ``1077``.
+ *
+ *  When receiving decimal input from the user (as a decimal string),
+ *  the value should be converted to an integer and when showing a user
+ *  a value, the integer value should be converted to a decimal string.
+ *
+ *  This creates a clear distinction, between values to be used by code
+ *  (integers) and values used for display logic to users (decimals).
+ *
+ *  The native unit in Ethereum, //ether// is divisible to 18 decimal places,
+ *  where each individual unit is called a //wei//.
+ *
+ *  @_subsection api/utils:Unit Conversion  [about-units]
+ */
+import { assertArgument } from "./errors.js";
+import { FixedNumber } from "./fixednumber.js";
+import { getNumber } from "./maths.js";
+
+import type { BigNumberish, Numeric } from "../utils/index.js";
+
+
+const names = [
+    "wei",
+    "kwei",
+    "mwei",
+    "gwei",
+    "szabo",
+    "finney",
+    "ether",
+];
+
+/**
+ *  Converts %%value%% into a //decimal string//, assuming %%unit%% decimal
+ *  places. The %%unit%% may be the number of decimal places or the name of
+ *  a unit (e.g. ``"gwei"`` for 9 decimal places).
+ *
+ */
+export function formatUnits(value: BigNumberish, unit?: string | Numeric): string {
+    let decimals = 18;
+    if (typeof(unit) === "string") {
+        const index = names.indexOf(unit);
+        assertArgument(index >= 0, "invalid unit", "unit", unit);
+        decimals = 3 * index;
+    } else if (unit != null) {
+        decimals = getNumber(unit, "unit");
+    }
+
+    return FixedNumber.fromValue(value, decimals, { decimals, width: 512 }).toString();
+}
+
+/**
+ *  Converts the //decimal string// %%value%% to a BigInt, assuming
+ *  %%unit%% decimal places. The %%unit%% may the number of decimal places
+ *  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
+ */
+export function parseUnits(value: string, unit?: string | Numeric): bigint {
+    assertArgument(typeof(value) === "string", "value must be a string", "value", value);
+
+    let decimals = 18;
+    if (typeof(unit) === "string") {
+        const index = names.indexOf(unit);
+        assertArgument(index >= 0, "invalid unit", "unit", unit);
+        decimals = 3 * index;
+    } else if (unit != null) {
+        decimals = getNumber(unit, "unit");
+    }
+
+    return FixedNumber.fromString(value, { decimals, width: 512 }).value;
+}
+
+/**
+ *  Converts %%value%% into a //decimal string// using 18 decimal places.
+ */
+export function formatEther(wei: BigNumberish): string {
+    return formatUnits(wei, 18);
+}
+
+/**
+ *  Converts the //decimal string// %%ether%% to a BigInt, using 18
+ *  decimal places.
+ */
+export function parseEther(ether: string): bigint {
+    return parseUnits(ether, 18);
+}