@leofcoin/chain 1.10.8 → 1.10.10

package/exports/browser/workers/machine-worker.js

@@ -30,6 +30,907 @@ class TransactionMessage extends FormatInterface {
     }
 }
 
+/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
+/**
+ *  The current version of Ethers.
+ */
+const version = "6.17.0";
+
+/**
+ *  Property helper functions.
+ *
+ *  @_subsection api/utils:Properties  [about-properties]
+ */
+/**
+ *  Assigns the %%values%% to %%target%% as read-only values.
+ *
+ *  It %%types%% is specified, the values are checked.
+ */
+function defineProperties(target, values, types) {
+    for (let key in values) {
+        let value = values[key];
+        Object.defineProperty(target, key, { enumerable: true, value, writable: false });
+    }
+}
+
+/**
+ *  All errors in ethers include properties to ensure they are both
+ *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).
+ *
+ *  The [[isError]] function can be used to check the error ``code`` and
+ *  provide a type guard for the properties present on that error interface.
+ *
+ *  @_section: api/utils/errors:Errors  [about-errors]
+ */
+function stringify(value, seen) {
+    if (value == null) {
+        return "null";
+    }
+    if (seen == null) {
+        seen = new Set();
+    }
+    if (typeof (value) === "object") {
+        if (seen.has(value)) {
+            return "[Circular]";
+        }
+        seen.add(value);
+    }
+    if (Array.isArray(value)) {
+        return "[ " + (value.map((v) => stringify(v, seen))).join(", ") + " ]";
+    }
+    if (value instanceof Uint8Array) {
+        const HEX = "0123456789abcdef";
+        let result = "0x";
+        for (let i = 0; i < value.length; i++) {
+            result += HEX[value[i] >> 4];
+            result += HEX[value[i] & 0xf];
+        }
+        return result;
+    }
+    if (typeof (value) === "object" && typeof (value.toJSON) === "function") {
+        return stringify(value.toJSON(), seen);
+    }
+    switch (typeof (value)) {
+        case "boolean":
+        case "number":
+        case "symbol":
+            return value.toString();
+        case "bigint":
+            return BigInt(value).toString();
+        case "string":
+            return JSON.stringify(value);
+        case "object": {
+            const keys = Object.keys(value);
+            keys.sort();
+            return "{ " + keys.map((k) => `${stringify(k, seen)}: ${stringify(value[k], seen)}`).join(", ") + " }";
+        }
+    }
+    return `[ COULD NOT SERIALIZE ]`;
+}
+/**
+ *  Returns a new Error configured to the format ethers emits errors, with
+ *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties
+ *  for the corresponding EthersError.
+ *
+ *  Each error in ethers includes the version of ethers, a
+ *  machine-readable [[ErrorCode]], and depending on %%code%%, additional
+ *  required properties. The error message will also include the %%message%%,
+ *  ethers version, %%code%% and all additional properties, serialized.
+ */
+function makeError(message, code, info) {
+    let shortMessage = message;
+    {
+        const details = [];
+        if (info) {
+            if ("message" in info || "code" in info || "name" in info) {
+                throw new Error(`value will overwrite populated values: ${stringify(info)}`);
+            }
+            for (const key in info) {
+                if (key === "shortMessage") {
+                    continue;
+                }
+                const value = (info[key]);
+                //                try {
+                details.push(key + "=" + stringify(value));
+                //                } catch (error: any) {
+                //                console.log("MMM", error.message);
+                //                    details.push(key + "=[could not serialize object]");
+                //                }
+            }
+        }
+        details.push(`code=${code}`);
+        details.push(`version=${version}`);
+        if (details.length) {
+            message += " (" + details.join(", ") + ")";
+        }
+    }
+    let error;
+    switch (code) {
+        case "INVALID_ARGUMENT":
+            error = new TypeError(message);
+            break;
+        case "NUMERIC_FAULT":
+        case "BUFFER_OVERRUN":
+            error = new RangeError(message);
+            break;
+        default:
+            error = new Error(message);
+    }
+    defineProperties(error, { code });
+    if (info) {
+        Object.assign(error, info);
+    }
+    if (error.shortMessage == null) {
+        defineProperties(error, { shortMessage });
+    }
+    return error;
+}
+/**
+ *  Throws an EthersError with %%message%%, %%code%% and additional error
+ *  %%info%% when %%check%% is falsish..
+ *
+ *  @see [[api:makeError]]
+ */
+function assert(check, message, code, info) {
+    if (!check) {
+        throw makeError(message, code, info);
+    }
+}
+/**
+ *  A simple helper to simply ensuring provided arguments match expected
+ *  constraints, throwing if not.
+ *
+ *  In TypeScript environments, the %%check%% has been asserted true, so
+ *  any further code does not need additional compile-time checks.
+ */
+function assertArgument(check, message, name, value) {
+    assert(check, message, "INVALID_ARGUMENT", { argument: name, value: value });
+}
+["NFD", "NFC", "NFKD", "NFKC"].reduce((accum, form) => {
+    try {
+        // General test for normalize
+        /* c8 ignore start */
+        if ("test".normalize(form) !== "test") {
+            throw new Error("bad");
+        }
+        ;
+        /* c8 ignore stop */
+        if (form === "NFD") {
+            const check = String.fromCharCode(0xe9).normalize("NFD");
+            const expected = String.fromCharCode(0x65, 0x0301);
+            /* c8 ignore start */
+            if (check !== expected) {
+                throw new Error("broken");
+            }
+            /* c8 ignore stop */
+        }
+        accum.push(form);
+    }
+    catch (error) { }
+    return accum;
+}, []);
+/**
+ *  Many classes use file-scoped values to guard the constructor,
+ *  making it effectively private. This facilitates that pattern
+ *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,
+ *  throwing if not, indicating the %%className%% if provided.
+ */
+function assertPrivate(givenGuard, guard, className) {
+    if (givenGuard !== guard) {
+        let method = className, operation = "new";
+        {
+            method += ".";
+            operation += " " + className;
+        }
+        assert(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", {
+            operation
+        });
+    }
+}
+
+/**
+ *  Some data helpers.
+ *
+ *
+ *  @_subsection api/utils:Data Helpers  [about-data]
+ */
+function _getBytes(value, name, copy) {
+    if (value instanceof Uint8Array) {
+        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);
+}
+/**
+ *  Get a typed Uint8Array for %%value%%. If already a Uint8Array
+ *  the original %%value%% is returned; if a copy is required use
+ *  [[getBytesCopy]].
+ *
+ *  @see: getBytesCopy
+ */
+function getBytes(value, name) {
+    return _getBytes(value, name);
+}
+
+/**
+ *  Some mathematic operations.
+ *
+ *  @_subsection: api/utils:Math Helpers  [about-maths]
+ */
+const BN_0$1 = BigInt(0);
+const BN_1$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.
+ */
+function fromTwos(_value, _width) {
+    const value = getUint(_value, "value");
+    const width = BigInt(getNumber(_width, "width"));
+    assert((value >> width) === BN_0$1, "overflow", "NUMERIC_FAULT", {
+        operation: "fromTwos", fault: "overflow", value: _value
+    });
+    // Top bit set; treat as a negative value
+    if (value >> (width - BN_1$1)) {
+        const mask = (BN_1$1 << width) - BN_1$1;
+        return -(((~value) & mask) + BN_1$1);
+    }
+    return value;
+}
+/**
+ *  Mask %%value%% with a bitmask of %%bits%% ones.
+ */
+function mask(_value, _bits) {
+    const value = getUint(_value, "value");
+    const bits = BigInt(getNumber(_bits, "bits"));
+    return value & ((BN_1$1 << bits) - BN_1$1);
+}
+/**
+ *  Gets a BigInt from %%value%%. If it is an invalid value for
+ *  a BigInt, then an ArgumentError will be thrown for %%name%%.
+ */
+function getBigInt(value, name) {
+    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) {
+                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.
+ */
+function getUint(value, name) {
+    const result = getBigInt(value, name);
+    assert(result >= BN_0$1, "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.
+ */
+function toBigInt(value) {
+    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%%.
+ */
+function getNumber(value, name) {
+    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) {
+                assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
+            }
+    }
+    assertArgument(false, "invalid numeric value", name || "value", value);
+}
+
+/**
+ *  The **FixedNumber** class permits using values with decimal places,
+ *  using fixed-pont math.
+ *
+ *  Fixed-point math is still based on integers under-the-hood, but uses an
+ *  internal offset to store fractional components below, and each operation
+ *  corrects for this after each operation.
+ *
+ *  @_section: api/utils/fixed-point-math:Fixed-Point Maths  [about-fixed-point-math]
+ */
+const BN_N1 = BigInt(-1);
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const BN_5 = BigInt(5);
+const _guard = {};
+// Constant to pull zeros from for multipliers
+let Zeros = "0000";
+while (Zeros.length < 80) {
+    Zeros += Zeros;
+}
+// Returns a string "1" followed by decimal "0"s
+function getTens(decimals) {
+    let result = Zeros;
+    while (result.length < decimals) {
+        result += result;
+    }
+    return BigInt("1" + result.substring(0, decimals));
+}
+function checkValue(val, format, safeOp) {
+    const width = BigInt(format.width);
+    if (format.signed) {
+        const limit = (BN_1 << (width - BN_1));
+        assert(safeOp == null || (val >= -limit && val < limit), "overflow", "NUMERIC_FAULT", {
+            operation: safeOp, fault: "overflow", value: val
+        });
+        if (val > BN_0) {
+            val = fromTwos(mask(val, width), width);
+        }
+        else {
+            val = -fromTwos(mask(-val, width), width);
+        }
+    }
+    else {
+        const limit = (BN_1 << width);
+        assert(safeOp == null || (val >= 0 && val < limit), "overflow", "NUMERIC_FAULT", {
+            operation: safeOp, fault: "overflow", value: val
+        });
+        val = (((val % limit) + limit) % limit) & (limit - BN_1);
+    }
+    return val;
+}
+function getFormat(value) {
+    if (typeof (value) === "number") {
+        value = `fixed128x${value}`;
+    }
+    let signed = true;
+    let width = 128;
+    let decimals = 18;
+    if (typeof (value) === "string") {
+        // Parse the format string
+        if (value === "fixed") ;
+        else if (value === "ufixed") {
+            signed = false;
+        }
+        else {
+            const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
+            assertArgument(match, "invalid fixed format", "format", value);
+            signed = (match[1] !== "u");
+            width = parseInt(match[2]);
+            decimals = parseInt(match[3]);
+        }
+    }
+    else if (value) {
+        // Extract the values from the object
+        const v = value;
+        const check = (key, type, defaultValue) => {
+            if (v[key] == null) {
+                return defaultValue;
+            }
+            assertArgument(typeof (v[key]) === type, "invalid fixed format (" + key + " not " + type + ")", "format." + key, v[key]);
+            return v[key];
+        };
+        signed = check("signed", "boolean", signed);
+        width = check("width", "number", width);
+        decimals = check("decimals", "number", decimals);
+    }
+    assertArgument((width % 8) === 0, "invalid FixedNumber width (not byte aligned)", "format.width", width);
+    assertArgument(decimals <= 80, "invalid FixedNumber decimals (too large)", "format.decimals", decimals);
+    const name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
+    return { signed, width, decimals, name };
+}
+function toString(val, decimals) {
+    let negative = "";
+    if (val < BN_0) {
+        negative = "-";
+        val *= BN_N1;
+    }
+    let str = val.toString();
+    // No decimal point for whole values
+    if (decimals === 0) {
+        return (negative + str);
+    }
+    // Pad out to the whole component (including a whole digit)
+    while (str.length <= decimals) {
+        str = Zeros + str;
+    }
+    // Insert the decimal point
+    const index = str.length - decimals;
+    str = str.substring(0, index) + "." + str.substring(index);
+    // Trim the whole component (leaving at least one 0)
+    while (str[0] === "0" && str[1] !== ".") {
+        str = str.substring(1);
+    }
+    // Trim the decimal component (leaving at least one 0)
+    while (str[str.length - 1] === "0" && str[str.length - 2] !== ".") {
+        str = str.substring(0, str.length - 1);
+    }
+    return (negative + str);
+}
+/**
+ *  A FixedNumber represents a value over its [[FixedFormat]]
+ *  arithmetic field.
+ *
+ *  A FixedNumber can be used to perform math, losslessly, on
+ *  values which have decmial places.
+ *
+ *  A FixedNumber has a fixed bit-width to store values in, and stores all
+ *  values internally by multiplying the value by 10 raised to the power of
+ *  %%decimals%%.
+ *
+ *  If operations are performed that cause a value to grow too high (close to
+ *  positive infinity) or too low (close to negative infinity), the value
+ *  is said to //overflow//.
+ *
+ *  For example, an 8-bit signed value, with 0 decimals may only be within
+ *  the range ``-128`` to ``127``; so ``-128 - 1`` will overflow and become
+ *  ``127``. Likewise, ``127 + 1`` will overflow and become ``-127``.
+ *
+ *  Many operation have a normal and //unsafe// variant. The normal variant
+ *  will throw a [[NumericFaultError]] on any overflow, while the //unsafe//
+ *  variant will silently allow overflow, corrupting its value value.
+ *
+ *  If operations are performed that cause a value to become too small
+ *  (close to zero), the value loses precison and is said to //underflow//.
+ *
+ *  For example, a value with 1 decimal place may store a number as small
+ *  as ``0.1``, but the value of ``0.1 / 2`` is ``0.05``, which cannot fit
+ *  into 1 decimal place, so underflow occurs which means precision is lost
+ *  and the value becomes ``0``.
+ *
+ *  Some operations have a normal and //signalling// variant. The normal
+ *  variant will silently ignore underflow, while the //signalling// variant
+ *  will thow a [[NumericFaultError]] on underflow.
+ */
+class FixedNumber {
+    /**
+     *  The specific fixed-point arithmetic field for this value.
+     */
+    format;
+    #format;
+    // The actual value (accounting for decimals)
+    #val;
+    // A base-10 value to multiple values by to maintain the magnitude
+    #tens;
+    /**
+     *  This is a property so console.log shows a human-meaningful value.
+     *
+     *  @private
+     */
+    _value;
+    // Use this when changing this file to get some typing info,
+    // but then switch to any to mask the internal type
+    //constructor(guard: any, value: bigint, format: _FixedFormat) {
+    /**
+     *  @private
+     */
+    constructor(guard, value, format) {
+        assertPrivate(guard, _guard, "FixedNumber");
+        this.#val = value;
+        this.#format = format;
+        const _value = toString(value, format.decimals);
+        defineProperties(this, { format: format.name, _value });
+        this.#tens = getTens(format.decimals);
+    }
+    /**
+     *  If true, negative values are permitted, otherwise only
+     *  positive values and zero are allowed.
+     */
+    get signed() { return this.#format.signed; }
+    /**
+     *  The number of bits available to store the value.
+     */
+    get width() { return this.#format.width; }
+    /**
+     *  The number of decimal places in the fixed-point arithment field.
+     */
+    get decimals() { return this.#format.decimals; }
+    /**
+     *  The value as an integer, based on the smallest unit the
+     *  [[decimals]] allow.
+     */
+    get value() { return this.#val; }
+    #checkFormat(other) {
+        assertArgument(this.format === other.format, "incompatible format; use fixedNumber.toFormat", "other", other);
+    }
+    #checkValue(val, safeOp) {
+        /*
+                const width = BigInt(this.width);
+                if (this.signed) {
+                    const limit = (BN_1 << (width - BN_1));
+                    assert(safeOp == null || (val >= -limit  && val < limit), "overflow", "NUMERIC_FAULT", {
+                        operation: <string>safeOp, fault: "overflow", value: val
+                    });
+        
+                    if (val > BN_0) {
+                        val = fromTwos(mask(val, width), width);
+                    } else {
+                        val = -fromTwos(mask(-val, width), width);
+                    }
+        
+                } else {
+                    const masked = mask(val, width);
+                    assert(safeOp == null || (val >= 0 && val === masked), "overflow", "NUMERIC_FAULT", {
+                        operation: <string>safeOp, fault: "overflow", value: val
+                    });
+                    val = masked;
+                }
+        */
+        val = checkValue(val, this.#format, safeOp);
+        return new FixedNumber(_guard, val, this.#format);
+    }
+    #add(o, safeOp) {
+        this.#checkFormat(o);
+        return this.#checkValue(this.#val + o.#val, safeOp);
+    }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% added
+     *  to %%other%%, ignoring overflow.
+     */
+    addUnsafe(other) { return this.#add(other); }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% added
+     *  to %%other%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs.
+     */
+    add(other) { return this.#add(other, "add"); }
+    #sub(o, safeOp) {
+        this.#checkFormat(o);
+        return this.#checkValue(this.#val - o.#val, safeOp);
+    }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
+     *  from %%this%%, ignoring overflow.
+     */
+    subUnsafe(other) { return this.#sub(other); }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
+     *  from %%this%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs.
+     */
+    sub(other) { return this.#sub(other, "sub"); }
+    #mul(o, safeOp) {
+        this.#checkFormat(o);
+        return this.#checkValue((this.#val * o.#val) / this.#tens, safeOp);
+    }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+     *  by %%other%%, ignoring overflow and underflow (precision loss).
+     */
+    mulUnsafe(other) { return this.#mul(other); }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+     *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs.
+     */
+    mul(other) { return this.#mul(other, "mul"); }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+     *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
+     *  occurs or if underflow (precision loss) occurs.
+     */
+    mulSignal(other) {
+        this.#checkFormat(other);
+        const value = this.#val * other.#val;
+        assert((value % this.#tens) === BN_0, "precision lost during signalling mul", "NUMERIC_FAULT", {
+            operation: "mulSignal", fault: "underflow", value: this
+        });
+        return this.#checkValue(value / this.#tens, "mulSignal");
+    }
+    #div(o, safeOp) {
+        assert(o.#val !== BN_0, "division by zero", "NUMERIC_FAULT", {
+            operation: "div", fault: "divide-by-zero", value: this
+        });
+        this.#checkFormat(o);
+        return this.#checkValue((this.#val * this.#tens) / o.#val, safeOp);
+    }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+     *  by %%other%%, ignoring underflow (precision loss). A
+     *  [[NumericFaultError]] is thrown if overflow occurs.
+     */
+    divUnsafe(other) { return this.#div(other); }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+     *  by %%other%%, ignoring underflow (precision loss). A
+     *  [[NumericFaultError]] is thrown if overflow occurs.
+     */
+    div(other) { return this.#div(other, "div"); }
+    /**
+     *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+     *  by %%other%%. A [[NumericFaultError]] is thrown if underflow
+     *  (precision loss) occurs.
+     */
+    divSignal(other) {
+        assert(other.#val !== BN_0, "division by zero", "NUMERIC_FAULT", {
+            operation: "div", fault: "divide-by-zero", value: this
+        });
+        this.#checkFormat(other);
+        const value = (this.#val * this.#tens);
+        assert((value % other.#val) === BN_0, "precision lost during signalling div", "NUMERIC_FAULT", {
+            operation: "divSignal", fault: "underflow", value: this
+        });
+        return this.#checkValue(value / other.#val, "divSignal");
+    }
+    /**
+     *  Returns a comparison result between %%this%% and %%other%%.
+     *
+     *  This is suitable for use in sorting, where ``-1`` implies %%this%%
+     *  is smaller, ``1`` implies %%this%% is larger and ``0`` implies
+     *  both are equal.
+     */
+    cmp(other) {
+        let a = this.value, b = other.value;
+        // Coerce a and b to the same magnitude
+        const delta = this.decimals - other.decimals;
+        if (delta > 0) {
+            b *= getTens(delta);
+        }
+        else if (delta < 0) {
+            a *= getTens(-delta);
+        }
+        // Comnpare
+        if (a < b) {
+            return -1;
+        }
+        if (a > b) {
+            return 1;
+        }
+        return 0;
+    }
+    /**
+     *  Returns true if %%other%% is equal to %%this%%.
+     */
+    eq(other) { return this.cmp(other) === 0; }
+    /**
+     *  Returns true if %%other%% is less than to %%this%%.
+     */
+    lt(other) { return this.cmp(other) < 0; }
+    /**
+     *  Returns true if %%other%% is less than or equal to %%this%%.
+     */
+    lte(other) { return this.cmp(other) <= 0; }
+    /**
+     *  Returns true if %%other%% is greater than to %%this%%.
+     */
+    gt(other) { return this.cmp(other) > 0; }
+    /**
+     *  Returns true if %%other%% is greater than or equal to %%this%%.
+     */
+    gte(other) { return this.cmp(other) >= 0; }
+    /**
+     *  Returns a new [[FixedNumber]] which is the largest **integer**
+     *  that is less than or equal to %%this%%.
+     *
+     *  The decimal component of the result will always be ``0``.
+     */
+    floor() {
+        let val = this.#val;
+        if (this.#val < BN_0) {
+            val -= this.#tens - BN_1;
+        }
+        val = (this.#val / this.#tens) * this.#tens;
+        return this.#checkValue(val, "floor");
+    }
+    /**
+     *  Returns a new [[FixedNumber]] which is the smallest **integer**
+     *  that is greater than or equal to %%this%%.
+     *
+     *  The decimal component of the result will always be ``0``.
+     */
+    ceiling() {
+        let val = this.#val;
+        if (this.#val > BN_0) {
+            val += this.#tens - BN_1;
+        }
+        val = (this.#val / this.#tens) * this.#tens;
+        return this.#checkValue(val, "ceiling");
+    }
+    /**
+     *  Returns a new [[FixedNumber]] with the decimal component
+     *  rounded up on ties at %%decimals%% places.
+     */
+    round(decimals) {
+        if (decimals == null) {
+            decimals = 0;
+        }
+        // Not enough precision to not already be rounded
+        if (decimals >= this.decimals) {
+            return this;
+        }
+        const delta = this.decimals - decimals;
+        const bump = BN_5 * getTens(delta - 1);
+        let value = this.value + bump;
+        const tens = getTens(delta);
+        value = (value / tens) * tens;
+        checkValue(value, this.#format, "round");
+        return new FixedNumber(_guard, value, this.#format);
+    }
+    /**
+     *  Returns true if %%this%% is equal to ``0``.
+     */
+    isZero() { return (this.#val === BN_0); }
+    /**
+     *  Returns true if %%this%% is less than ``0``.
+     */
+    isNegative() { return (this.#val < BN_0); }
+    /**
+     *  Returns the string representation of %%this%%.
+     */
+    toString() { return this._value; }
+    /**
+     *  Returns a float approximation.
+     *
+     *  Due to IEEE 754 precission (or lack thereof), this function
+     *  can only return an approximation and most values will contain
+     *  rounding errors.
+     */
+    toUnsafeFloat() { return parseFloat(this.toString()); }
+    /**
+     *  Return a new [[FixedNumber]] with the same value but has had
+     *  its field set to %%format%%.
+     *
+     *  This will throw if the value cannot fit into %%format%%.
+     */
+    toFormat(format) {
+        return FixedNumber.fromString(this.toString(), format);
+    }
+    /**
+     *  Creates a new [[FixedNumber]] for %%value%% divided by
+     *  %%decimal%% places with %%format%%.
+     *
+     *  This will throw a [[NumericFaultError]] if %%value%% (once adjusted
+     *  for %%decimals%%) cannot fit in %%format%%, either due to overflow
+     *  or underflow (precision loss).
+     */
+    static fromValue(_value, _decimals, _format) {
+        const decimals = (_decimals == null) ? 0 : getNumber(_decimals);
+        const format = getFormat(_format);
+        let value = getBigInt(_value, "value");
+        const delta = decimals - format.decimals;
+        if (delta > 0) {
+            const tens = getTens(delta);
+            assert((value % tens) === BN_0, "value loses precision for format", "NUMERIC_FAULT", {
+                operation: "fromValue", fault: "underflow", value: _value
+            });
+            value /= tens;
+        }
+        else if (delta < 0) {
+            value *= getTens(-delta);
+        }
+        checkValue(value, format, "fromValue");
+        return new FixedNumber(_guard, value, format);
+    }
+    /**
+     *  Creates a new [[FixedNumber]] for %%value%% with %%format%%.
+     *
+     *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
+     *  in %%format%%, either due to overflow or underflow (precision loss).
+     */
+    static fromString(_value, _format) {
+        const match = _value.match(/^(-?)([0-9]*)\.?([0-9]*)$/);
+        assertArgument(match && (match[2].length + match[3].length) > 0, "invalid FixedNumber string value", "value", _value);
+        const format = getFormat(_format);
+        let whole = (match[2] || "0"), decimal = (match[3] || "");
+        // Pad out the decimals
+        while (decimal.length < format.decimals) {
+            decimal += Zeros;
+        }
+        // Check precision is safe
+        assert(decimal.substring(format.decimals).match(/^0*$/), "too many decimals for format", "NUMERIC_FAULT", {
+            operation: "fromString", fault: "underflow", value: _value
+        });
+        // Remove extra padding
+        decimal = decimal.substring(0, format.decimals);
+        const value = BigInt(match[1] + whole + decimal);
+        checkValue(value, format, "fromString");
+        return new FixedNumber(_guard, value, format);
+    }
+    /**
+     *  Creates a new [[FixedNumber]] with the big-endian representation
+     *  %%value%% with %%format%%.
+     *
+     *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
+     *  in %%format%% due to overflow.
+     */
+    static fromBytes(_value, _format) {
+        let value = toBigInt(getBytes(_value, "value"));
+        const format = getFormat(_format);
+        if (format.signed) {
+            value = fromTwos(value, format.width);
+        }
+        checkValue(value, format, "fromBytes");
+        return new FixedNumber(_guard, value, format);
+    }
+}
+//const f1 = FixedNumber.fromString("12.56", "fixed16x2");
+//const f2 = FixedNumber.fromString("0.3", "fixed16x2");
+//console.log(f1.divSignal(f2));
+//const BUMP = FixedNumber.from("0.5");
+
+/**
+ *  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]
+ */
+/**
+ *  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).
+ *
+ */
+function formatUnits(value, unit) {
+    let decimals = 18;
+    return FixedNumber.fromValue(value, decimals, { decimals, width: 512 }).toString();
+}
+
 const byteFormats = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
 const formatBytes = (bytes, decimals = 2) => {
     if (bytes === 0)
@@ -74,6 +975,132 @@ var bytecodes = {
 	validators: validators
 };
 
+const TRANSACTION_FEE_BYTES = 1024n;
+const TRANSACTION_FEE_UNIT = 10n;
+const MAX_TRANSACTION_BYTES = 32 * 1024;
+const MAX_BLOCK_TRANSACTION_BYTES = 128 * 1024;
+const MAX_BLOCK_TRANSACTIONS = 256;
+(BigInt(MAX_TRANSACTION_BYTES) / TRANSACTION_FEE_BYTES) * TRANSACTION_FEE_UNIT;
+const FEE_BASIS_POINTS = 10000n;
+const FEE_PROTOCOL_VERSION = '1.10.9';
+const MONETARY_POLICY_PROTOCOL_VERSION = '1.10.10';
+const BLOCKS_PER_YEAR = 5256000n;
+const ANNUAL_ISSUANCE_BASIS_POINTS = 200n;
+const SUPPLY_FLOOR_BASIS_POINTS = 9500n;
+const MONETARY_FEE_BURN_BASIS_POINTS = 1000n;
+const parseProtocolVersion = (version) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : undefined;
+};
+const supportsTransactionFees = (version) => {
+    const actual = parseProtocolVersion(version);
+    const required = parseProtocolVersion(FEE_PROTOCOL_VERSION);
+    if (!actual)
+        return false;
+    for (let index = 0; index < required.length; index += 1) {
+        if (actual[index] !== required[index])
+            return actual[index] > required[index];
+    }
+    return true;
+};
+const supportsMonetaryPolicy = (version) => {
+    const actual = parseProtocolVersion(version);
+    const required = parseProtocolVersion(MONETARY_POLICY_PROTOCOL_VERSION);
+    if (!actual)
+        return false;
+    for (let index = 0; index < required.length; index += 1) {
+        if (actual[index] !== required[index])
+            return actual[index] > required[index];
+    }
+    return true;
+};
+const calculateMonetaryPolicy = (totalSupply, targetSupply) => {
+    if (totalSupply < 0n || targetSupply <= 0n)
+        throw new Error('invalid monetary policy supply');
+    const floorSupply = (targetSupply * SUPPLY_FLOOR_BASIS_POINTS) / FEE_BASIS_POINTS;
+    if (totalSupply < floorSupply) {
+        const annualIssuance = (targetSupply * ANNUAL_ISSUANCE_BASIS_POINTS) / FEE_BASIS_POINTS;
+        const scheduled = annualIssuance / BLOCKS_PER_YEAR || 1n;
+        return { subsidy: scheduled < floorSupply - totalSupply ? scheduled : floorSupply - totalSupply, burnBasisPoints: 0n, floorSupply };
+    }
+    return {
+        subsidy: 0n,
+        burnBasisPoints: totalSupply >= targetSupply ? MONETARY_FEE_BURN_BASIS_POINTS : 0n,
+        floorSupply
+    };
+};
+const distributeAmount = (amount, addresses, rotation = 0) => {
+    const canonical = [...new Set(addresses)].sort();
+    if (canonical.length === 0)
+        throw new Error('cannot distribute without validators');
+    const count = BigInt(canonical.length);
+    const base = amount / count;
+    const remainder = Number(amount % count);
+    const result = new Map(canonical.map((address) => [address, base]));
+    for (let index = 0; index < remainder; index += 1) {
+        const address = canonical[(rotation + index) % canonical.length];
+        result.set(address, result.get(address) + 1n);
+    }
+    return result;
+};
+const feeRotationIndex = (transactionHash, validatorCount) => {
+    let value = 0n;
+    for (const character of transactionHash)
+        value = (value * 31n + BigInt(character.charCodeAt(0))) % 4294967291n;
+    return Number(value % BigInt(validatorCount));
+};
+const distributeTransactionFee = (fee, transactionHash, validatorAddresses, burnBasisPoints = 1000n) => {
+    const canonicalValidators = [...new Set(validatorAddresses)].sort();
+    if (canonicalValidators.length === 0)
+        throw new Error('cannot distribute transaction fee without validators');
+    if (fee < 0n)
+        throw new Error('transaction fee cannot be negative');
+    if (burnBasisPoints < 0n || burnBasisPoints > FEE_BASIS_POINTS)
+        throw new Error('invalid fee burn rate');
+    const burned = (fee * burnBasisPoints) / FEE_BASIS_POINTS;
+    const validatorPool = fee - burned;
+    const count = BigInt(canonicalValidators.length);
+    const base = validatorPool / count;
+    const remainder = Number(validatorPool % count);
+    const start = feeRotationIndex(transactionHash, canonicalValidators.length);
+    const validatorFees = new Map(canonicalValidators.map((validator) => [validator, base]));
+    for (let index = 0; index < remainder; index += 1) {
+        const validator = canonicalValidators[(start + index) % canonicalValidators.length];
+        validatorFees.set(validator, validatorFees.get(validator) + 1n);
+    }
+    const payments = [...validatorFees.entries()]
+        .filter(([, amount]) => amount > 0n)
+        .map(([to, amount]) => ({ to, amount }));
+    return { burned, validatorFees, payments };
+};
+const calculateFee = async (transaction, format = false) => {
+    transaction = await new TransactionMessage(transaction);
+    const encodedBytes = BigInt(transaction.encoded.length);
+    const units = (encodedBytes + TRANSACTION_FEE_BYTES - 1n) / TRANSACTION_FEE_BYTES;
+    const fee = units * TRANSACTION_FEE_UNIT;
+    return format ? formatUnits(fee.toString()) : fee;
+};
+const validateTransactionResourceLimits = async (transaction) => {
+    const message = await new TransactionMessage(transaction);
+    const size = message.encoded.length;
+    if (size > MAX_TRANSACTION_BYTES) {
+        throw new Error(`transaction exceeds ${MAX_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+    }
+    return size;
+};
+const validateBlockResourceLimits = async (transactions) => {
+    if (transactions.length > MAX_BLOCK_TRANSACTIONS) {
+        throw new Error(`block exceeds ${MAX_BLOCK_TRANSACTIONS} transaction protocol limit`);
+    }
+    let size = 0;
+    for (const transaction of transactions)
+        size += await validateTransactionResourceLimits(transaction);
+    if (size > MAX_BLOCK_TRANSACTION_BYTES) {
+        throw new Error(`block transactions exceed ${MAX_BLOCK_TRANSACTION_BYTES} byte protocol limit: ${size}`);
+    }
+    return size;
+};
+
 class LittlePubSub {
     subscribers = new Map();
     verbose;
@@ -254,7 +1281,7 @@ const runTask = async (id, taskName, input) => {
         });
     }
 };
-const _executeTransaction = async (transaction) => {
+const _executeTransaction = async (transaction, validators, feesEnabled, burnBasisPoints) => {
     const hash = await new TransactionMessage(transaction).hash();
     if (latestTransactions.includes(hash)) {
         throw new Error(`double transaction found: ${hash}`);
@@ -264,6 +1291,11 @@ const _executeTransaction = async (transaction) => {
         const { from, to, method, params, nonce } = transaction;
         globalThis.msg = createMessage(from, to);
         globalThis.state = await createState();
+        if (feesEnabled) {
+            const fee = BigInt(await calculateFee(transaction));
+            const { payments, burned } = distributeTransactionFee(fee, hash, validators, burnBasisPoints);
+            await _.collectFee({ from, payments, burned });
+        }
         await _.execute({ contract: to, method, params });
         worker.postMessage({
             type: 'transactionLoaded',
@@ -303,9 +1335,11 @@ const _ = {
             });
         }
     },
-    execute: async ({ contract, method, params }) => {
+    execute: async ({ contract, method, params, sender }) => {
         try {
             let result;
+            if (sender)
+                globalThis.msg = createMessage(sender, contract);
             // don't execute the method on a proxy
             if (contracts[contract].fallback) {
                 result = await contracts[contract].fallback(method, params);
@@ -345,6 +1379,35 @@ const _ = {
         `);
         }
     },
+    collectFee: ({ from, payments, burned = 0n }) => {
+        burned = BigInt(burned);
+        const total = payments.reduce((sum, payment) => sum + BigInt(payment.amount), burned);
+        const balance = BigInt(contracts[nativeToken$2].balanceOf(from) || 0n);
+        if (balance < total)
+            throw new Error(`insufficient balance for transaction fee: need ${total}, got ${balance}`);
+        globalThis.msg = createMessage(from, nativeToken$2);
+        for (const payment of payments) {
+            const amount = BigInt(payment.amount);
+            if (amount > 0n)
+                contracts[nativeToken$2].transfer(from, payment.to, amount);
+        }
+        if (burned > 0n) {
+            globalThis.msg = createMessage(contracts[nativeToken$2].creator, nativeToken$2);
+            contracts[nativeToken$2].burn(from, burned);
+        }
+        return total;
+    },
+    settleRewards: ({ rewards }) => {
+        globalThis.msg = createMessage(contracts[nativeToken$2].creator, nativeToken$2);
+        let minted = 0n;
+        for (const [validator, rawAmount] of rewards) {
+            const amount = BigInt(rawAmount);
+            if (amount > 0n)
+                contracts[nativeToken$2].mint(validator, amount);
+            minted += amount;
+        }
+        return minted;
+    },
     init: async (message) => {
         let { peerid, fromState, state, info } = message;
         if (info)
@@ -447,16 +1510,29 @@ const _ = {
                                 }
                                 return message;
                             }));
-                            const priority = transactions
-                                .filter((transaction) => transaction.priority)
-                                ?.sort((a, b) => a.nonce - b.nonce);
-                            if (priority.length > 0)
-                                for (const transaction of priority) {
-                                    await _executeTransaction(transaction);
-                                }
-                            await Promise.all(transactions
-                                .filter((transaction) => !transaction.priority)
-                                .map(async (transaction) => _executeTransaction(transaction)));
+                            const validators = block.validators.map(({ address }) => address);
+                            transactions.sort((a, b) => {
+                                if (a.priority !== b.priority)
+                                    return a.priority ? -1 : 1;
+                                const left = BigInt(a.nonce);
+                                const right = BigInt(b.nonce);
+                                return left < right ? -1 : left > right ? 1 : 0;
+                            });
+                            const feesEnabled = supportsTransactionFees(block.protocolVersion);
+                            const monetaryPolicyEnabled = supportsMonetaryPolicy(block.protocolVersion);
+                            if (monetaryPolicyEnabled)
+                                await validateBlockResourceLimits(transactions);
+                            const policy = monetaryPolicyEnabled
+                                ? calculateMonetaryPolicy(BigInt(contracts[nativeToken$2].totalSupply), BigInt(contracts[nativeToken$2].targetSupply))
+                                : { subsidy: 0n, burnBasisPoints: 1000n };
+                            for (const transaction of transactions) {
+                                await _executeTransaction(transaction, validators, feesEnabled, policy.burnBasisPoints);
+                            }
+                            if (monetaryPolicyEnabled && policy.subsidy > 0n) {
+                                _.settleRewards({
+                                    rewards: [...distributeAmount(policy.subsidy, validators, Number(block.index) % validators.length)]
+                                });
+                            }
                             block.loaded = true;
                             worker.postMessage({
                                 type: 'debug',
@@ -521,6 +1597,12 @@ worker.onmessage(({ id, type, input }) => {
         case 'addLoadedBlock':
             runTask(id, 'addLoadedBlock', input);
             break;
+        case 'collectFee':
+            runTask(id, 'collectFee', input);
+            break;
+        case 'settleRewards':
+            runTask(id, 'settleRewards', input);
+            break;
         case 'contracts':
             respond(id, contracts);
             break;