@depay/widgets 6.9.2 → 6.10.0

package/dist/esm/index.bundle.js

@@ -10821,13 +10821,13 @@ const logger$J = new Logger$4(version$x);
 function isHexable$4(value) {
     return !!(value.toHexString);
 }
-function addSlice$3(array) {
+function addSlice$4(array) {
     if (array.slice) {
         return array;
     }
     array.slice = function () {
         const args = Array.prototype.slice.call(arguments);
-        return addSlice$3(new Uint8Array(Array.prototype.slice.apply(array, args)));
+        return addSlice$4(new Uint8Array(Array.prototype.slice.apply(array, args)));
     };
     return array;
 }
@@ -10858,7 +10858,7 @@ function isBytes$4(value) {
     }
     return true;
 }
-function arrayify$3(value, options) {
+function arrayify$4(value, options) {
     if (!options) {
         options = {};
     }
@@ -10872,7 +10872,7 @@ function arrayify$3(value, options) {
         if (result.length === 0) {
             result.push(0);
         }
-        return addSlice$3(new Uint8Array(result));
+        return addSlice$4(new Uint8Array(result));
     }
     if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
         value = "0x" + value;
@@ -10897,25 +10897,25 @@ function arrayify$3(value, options) {
         for (let i = 0; i < hex.length; i += 2) {
             result.push(parseInt(hex.substring(i, i + 2), 16));
         }
-        return addSlice$3(new Uint8Array(result));
+        return addSlice$4(new Uint8Array(result));
     }
     if (isBytes$4(value)) {
-        return addSlice$3(new Uint8Array(value));
+        return addSlice$4(new Uint8Array(value));
     }
     return logger$J.throwArgumentError("invalid arrayify value", "value", value);
 }
 function concat$2(items) {
-    const objects = items.map(item => arrayify$3(item));
+    const objects = items.map(item => arrayify$4(item));
     const length = objects.reduce((accum, item) => (accum + item.length), 0);
     const result = new Uint8Array(length);
     objects.reduce((offset, object) => {
         result.set(object, offset);
         return offset + object.length;
     }, 0);
-    return addSlice$3(result);
+    return addSlice$4(result);
 }
 function stripZeros$2(value) {
-    let result = arrayify$3(value);
+    let result = arrayify$4(value);
     if (result.length === 0) {
         return result;
     }
@@ -11033,7 +11033,7 @@ function hexConcat$2(items) {
     });
     return result;
 }
-function hexZeroPad$3(value, length) {
+function hexZeroPad$4(value, length) {
     if (typeof (value) !== "string") {
         value = hexlify$4(value);
     }
@@ -11055,7 +11055,7 @@ var BN$4 = bn$4.BN;
 const logger$I = new Logger$4(version$w);
 const _constructorGuard$9 = {};
 const MAX_SAFE$4 = 0x1fffffffffffff;
-function isBigNumberish$2(value) {
+function isBigNumberish$3(value) {
     return (value != null) && (BigNumber$4.isBigNumber(value) ||
         (typeof (value) === "number" && (value % 1) === 0) ||
         (typeof (value) === "string" && !!value.match(/^-?[0-9]+$/)) ||
@@ -11353,12 +11353,12 @@ function throwFault$5(message, fault, operation, value) {
     return logger$H.throwError(message, Logger$4.errors.NUMERIC_FAULT, params);
 }
 // Constant to pull zeros from for multipliers
-let zeros$2 = "0";
-while (zeros$2.length < 256) {
-    zeros$2 += zeros$2;
+let zeros$3 = "0";
+while (zeros$3.length < 256) {
+    zeros$3 += zeros$3;
 }
 // Returns a string "1" followed by decimal "0"s
-function getMultiplier$2(decimals) {
+function getMultiplier$3(decimals) {
     if (typeof (decimals) !== "number") {
         try {
             decimals = BigNumber$4.from(decimals).toNumber();
@@ -11366,15 +11366,15 @@ function getMultiplier$2(decimals) {
         catch (e) { }
     }
     if (typeof (decimals) === "number" && decimals >= 0 && decimals <= 256 && !(decimals % 1)) {
-        return ("1" + zeros$2.substring(0, decimals));
+        return ("1" + zeros$3.substring(0, decimals));
     }
     return logger$H.throwArgumentError("invalid decimal size", "decimals", decimals);
 }
-function formatFixed$2(value, decimals) {
+function formatFixed$3(value, decimals) {
     if (decimals == null) {
         decimals = 0;
     }
-    const multiplier = getMultiplier$2(decimals);
+    const multiplier = getMultiplier$3(decimals);
     // Make sure wei is a big number (convert as necessary)
     value = BigNumber$4.from(value);
     const negative = value.lt(Zero$6);
@@ -11399,11 +11399,11 @@ function formatFixed$2(value, decimals) {
     }
     return value;
 }
-function parseFixed$2(value, decimals) {
+function parseFixed$3(value, decimals) {
     if (decimals == null) {
         decimals = 0;
     }
-    const multiplier = getMultiplier$2(decimals);
+    const multiplier = getMultiplier$3(decimals);
     if (typeof (value) !== "string" || !value.match(/^-?[0-9.]+$/)) {
         logger$H.throwArgumentError("invalid decimal value", "value", value);
     }
@@ -11451,7 +11451,7 @@ function parseFixed$2(value, decimals) {
     }
     return wei;
 }
-class FixedFormat$2 {
+class FixedFormat$3 {
     constructor(constructorGuard, signed, width, decimals) {
         if (constructorGuard !== _constructorGuard$8) {
             logger$H.throwError("cannot use FixedFormat constructor; use FixedFormat.from", Logger$4.errors.UNSUPPORTED_OPERATION, {
@@ -11462,11 +11462,11 @@ class FixedFormat$2 {
         this.width = width;
         this.decimals = decimals;
         this.name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
-        this._multiplier = getMultiplier$2(decimals);
+        this._multiplier = getMultiplier$3(decimals);
         Object.freeze(this);
     }
     static from(value) {
-        if (value instanceof FixedFormat$2) {
+        if (value instanceof FixedFormat$3) {
             return value;
         }
         if (typeof (value) === "number") {
@@ -11510,12 +11510,12 @@ class FixedFormat$2 {
         if (decimals > 80) {
             logger$H.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals);
         }
-        return new FixedFormat$2(_constructorGuard$8, signed, width, decimals);
+        return new FixedFormat$3(_constructorGuard$8, signed, width, decimals);
     }
 }
-class FixedNumber$2 {
+class FixedNumber$3 {
     constructor(constructorGuard, hex, value, format) {
-        logger$H.checkNew(new.target, FixedNumber$2);
+        logger$H.checkNew(new.target, FixedNumber$3);
         if (constructorGuard !== _constructorGuard$8) {
             logger$H.throwError("cannot use FixedNumber constructor; use FixedNumber.from", Logger$4.errors.UNSUPPORTED_OPERATION, {
                 operation: "new FixedFormat"
@@ -11534,37 +11534,37 @@ class FixedNumber$2 {
     }
     addUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$2(this._value, this.format.decimals);
-        const b = parseFixed$2(other._value, other.format.decimals);
-        return FixedNumber$2.fromValue(a.add(b), this.format.decimals, this.format);
+        const a = parseFixed$3(this._value, this.format.decimals);
+        const b = parseFixed$3(other._value, other.format.decimals);
+        return FixedNumber$3.fromValue(a.add(b), this.format.decimals, this.format);
     }
     subUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$2(this._value, this.format.decimals);
-        const b = parseFixed$2(other._value, other.format.decimals);
-        return FixedNumber$2.fromValue(a.sub(b), this.format.decimals, this.format);
+        const a = parseFixed$3(this._value, this.format.decimals);
+        const b = parseFixed$3(other._value, other.format.decimals);
+        return FixedNumber$3.fromValue(a.sub(b), this.format.decimals, this.format);
     }
     mulUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$2(this._value, this.format.decimals);
-        const b = parseFixed$2(other._value, other.format.decimals);
-        return FixedNumber$2.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
+        const a = parseFixed$3(this._value, this.format.decimals);
+        const b = parseFixed$3(other._value, other.format.decimals);
+        return FixedNumber$3.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
     }
     divUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$2(this._value, this.format.decimals);
-        const b = parseFixed$2(other._value, other.format.decimals);
-        return FixedNumber$2.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
+        const a = parseFixed$3(this._value, this.format.decimals);
+        const b = parseFixed$3(other._value, other.format.decimals);
+        return FixedNumber$3.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
     }
     floor() {
         const comps = this.toString().split(".");
         if (comps.length === 1) {
             comps.push("0");
         }
-        let result = FixedNumber$2.from(comps[0], this.format);
+        let result = FixedNumber$3.from(comps[0], this.format);
         const hasFraction = !comps[1].match(/^(0*)$/);
         if (this.isNegative() && hasFraction) {
-            result = result.subUnsafe(ONE$2.toFormat(result.format));
+            result = result.subUnsafe(ONE$3.toFormat(result.format));
         }
         return result;
     }
@@ -11573,10 +11573,10 @@ class FixedNumber$2 {
         if (comps.length === 1) {
             comps.push("0");
         }
-        let result = FixedNumber$2.from(comps[0], this.format);
+        let result = FixedNumber$3.from(comps[0], this.format);
         const hasFraction = !comps[1].match(/^(0*)$/);
         if (!this.isNegative() && hasFraction) {
-            result = result.addUnsafe(ONE$2.toFormat(result.format));
+            result = result.addUnsafe(ONE$3.toFormat(result.format));
         }
         return result;
     }
@@ -11596,8 +11596,8 @@ class FixedNumber$2 {
         if (comps[1].length <= decimals) {
             return this;
         }
-        const factor = FixedNumber$2.from("1" + zeros$2.substring(0, decimals), this.format);
-        const bump = BUMP$2.toFormat(this.format);
+        const factor = FixedNumber$3.from("1" + zeros$3.substring(0, decimals), this.format);
+        const bump = BUMP$3.toFormat(this.format);
         return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor);
     }
     isZero() {
@@ -11615,15 +11615,15 @@ class FixedNumber$2 {
             logger$H.throwArgumentError("invalid byte width", "width", width);
         }
         const hex = BigNumber$4.from(this._hex).fromTwos(this.format.width).toTwos(width).toHexString();
-        return hexZeroPad$3(hex, width / 8);
+        return hexZeroPad$4(hex, width / 8);
     }
     toUnsafeFloat() { return parseFloat(this.toString()); }
     toFormat(format) {
-        return FixedNumber$2.fromString(this._value, format);
+        return FixedNumber$3.fromString(this._value, format);
     }
     static fromValue(value, decimals, format) {
         // If decimals looks more like a format, and there is no format, shift the parameters
-        if (format == null && decimals != null && !isBigNumberish$2(decimals)) {
+        if (format == null && decimals != null && !isBigNumberish$3(decimals)) {
             format = decimals;
             decimals = null;
         }
@@ -11633,14 +11633,14 @@ class FixedNumber$2 {
         if (format == null) {
             format = "fixed";
         }
-        return FixedNumber$2.fromString(formatFixed$2(value, decimals), FixedFormat$2.from(format));
+        return FixedNumber$3.fromString(formatFixed$3(value, decimals), FixedFormat$3.from(format));
     }
     static fromString(value, format) {
         if (format == null) {
             format = "fixed";
         }
-        const fixedFormat = FixedFormat$2.from(format);
-        const numeric = parseFixed$2(value, fixedFormat.decimals);
+        const fixedFormat = FixedFormat$3.from(format);
+        const numeric = parseFixed$3(value, fixedFormat.decimals);
         if (!fixedFormat.signed && numeric.lt(Zero$6)) {
             throwFault$5("unsigned value cannot be negative", "overflow", "value", value);
         }
@@ -11650,17 +11650,17 @@ class FixedNumber$2 {
         }
         else {
             hex = numeric.toHexString();
-            hex = hexZeroPad$3(hex, fixedFormat.width / 8);
+            hex = hexZeroPad$4(hex, fixedFormat.width / 8);
         }
-        const decimal = formatFixed$2(numeric, fixedFormat.decimals);
-        return new FixedNumber$2(_constructorGuard$8, hex, decimal, fixedFormat);
+        const decimal = formatFixed$3(numeric, fixedFormat.decimals);
+        return new FixedNumber$3(_constructorGuard$8, hex, decimal, fixedFormat);
     }
     static fromBytes(value, format) {
         if (format == null) {
             format = "fixed";
         }
-        const fixedFormat = FixedFormat$2.from(format);
-        if (arrayify$3(value).length > fixedFormat.width / 8) {
+        const fixedFormat = FixedFormat$3.from(format);
+        if (arrayify$4(value).length > fixedFormat.width / 8) {
             throw new Error("overflow");
         }
         let numeric = BigNumber$4.from(value);
@@ -11668,18 +11668,18 @@ class FixedNumber$2 {
             numeric = numeric.fromTwos(fixedFormat.width);
         }
         const hex = numeric.toTwos((fixedFormat.signed ? 0 : 1) + fixedFormat.width).toHexString();
-        const decimal = formatFixed$2(numeric, fixedFormat.decimals);
-        return new FixedNumber$2(_constructorGuard$8, hex, decimal, fixedFormat);
+        const decimal = formatFixed$3(numeric, fixedFormat.decimals);
+        return new FixedNumber$3(_constructorGuard$8, hex, decimal, fixedFormat);
     }
     static from(value, format) {
         if (typeof (value) === "string") {
-            return FixedNumber$2.fromString(value, format);
+            return FixedNumber$3.fromString(value, format);
         }
         if (isBytes$4(value)) {
-            return FixedNumber$2.fromBytes(value, format);
+            return FixedNumber$3.fromBytes(value, format);
         }
         try {
-            return FixedNumber$2.fromValue(value, 0, format);
+            return FixedNumber$3.fromValue(value, 0, format);
         }
         catch (error) {
             // Allow NUMERIC_FAULT to bubble up
@@ -11693,8 +11693,8 @@ class FixedNumber$2 {
         return !!(value && value._isFixedNumber);
     }
 }
-const ONE$2 = FixedNumber$2.from(1);
-const BUMP$2 = FixedNumber$2.from("0.5");
+const ONE$3 = FixedNumber$3.from(1);
+const BUMP$3 = FixedNumber$3.from("0.5");
 
 const version$v = "properties/5.5.0";
 
@@ -12716,7 +12716,7 @@ class Writer$1 {
     }
     // Arrayish items; padded on the right to wordSize
     writeBytes(value) {
-        let bytes = arrayify$3(value);
+        let bytes = arrayify$4(value);
         const paddingOffset = bytes.length % this.wordSize;
         if (paddingOffset) {
             bytes = concat$2([bytes, this._padding.slice(paddingOffset)]);
@@ -12724,7 +12724,7 @@ class Writer$1 {
         return this._writeData(bytes);
     }
     _getValue(value) {
-        let bytes = arrayify$3(BigNumber$4.from(value));
+        let bytes = arrayify$4(BigNumber$4.from(value));
         if (bytes.length > this.wordSize) {
             logger$E.throwError("value out-of-bounds", Logger$4.errors.BUFFER_OVERRUN, {
                 length: this.wordSize,
@@ -12751,7 +12751,7 @@ class Writer$1 {
 }
 class Reader$1 {
     constructor(data, wordSize, coerceFunc, allowLoose) {
-        defineReadOnly$2(this, "_data", arrayify$3(data));
+        defineReadOnly$2(this, "_data", arrayify$4(data));
         defineReadOnly$2(this, "wordSize", wordSize || 32);
         defineReadOnly$2(this, "_coerceFunc", coerceFunc);
         defineReadOnly$2(this, "allowLoose", allowLoose);
@@ -13449,7 +13449,7 @@ var sha3$4 = createCommonjsModule$4(function (module) {
 var sha3$5 = sha3$4;
 
 function keccak256$3(data) {
-    return '0x' + sha3$5.keccak_256(arrayify$3(data));
+    return '0x' + sha3$5.keccak_256(arrayify$4(data));
 }
 
 const version$t = "rlp/5.5.0";
@@ -13480,7 +13480,7 @@ function _encode$2(object) {
     if (!isBytesLike$2(object)) {
         logger$D.throwArgumentError("RLP object must be BytesLike", "object", object);
     }
-    const data = Array.prototype.slice.call(arrayify$3(object));
+    const data = Array.prototype.slice.call(arrayify$4(object));
     if (data.length === 1 && data[0] <= 0x7f) {
         return data;
     }
@@ -13509,7 +13509,7 @@ function getChecksumAddress$3(address) {
     for (let i = 0; i < 40; i++) {
         expanded[i] = chars[i].charCodeAt(0);
     }
-    const hashed = arrayify$3(keccak256$3(expanded));
+    const hashed = arrayify$4(keccak256$3(expanded));
     for (let i = 0; i < 40; i += 2) {
         if ((hashed[i >> 1] >> 4) >= 8) {
             chars[i] = chars[i].toUpperCase();
@@ -13596,7 +13596,7 @@ function getContractAddress$2(transaction) {
     catch (error) {
         logger$C.throwArgumentError("missing from address", "transaction", transaction);
     }
-    const nonce = stripZeros$2(arrayify$3(BigNumber$4.from(transaction.nonce).toHexString()));
+    const nonce = stripZeros$2(arrayify$4(BigNumber$4.from(transaction.nonce).toHexString()));
     return getAddress$3(hexDataSlice$2(keccak256$3(encode$4([from, nonce])), 12));
 }
 
@@ -13617,7 +13617,7 @@ class AddressCoder$1 extends Coder$1 {
         return writer.writeValue(value);
     }
     decode(reader) {
-        return getAddress$3(hexZeroPad$3(reader.readValue().toHexString(), 20));
+        return getAddress$3(hexZeroPad$4(reader.readValue().toHexString(), 20));
     }
 }
 
@@ -13865,7 +13865,7 @@ class DynamicBytesCoder$1 extends Coder$1 {
         return "0x";
     }
     encode(writer, value) {
-        value = arrayify$3(value);
+        value = arrayify$4(value);
         let length = writer.writeValue(value.length);
         length += writer.writeBytes(value);
         return length;
@@ -13894,7 +13894,7 @@ class FixedBytesCoder$1 extends Coder$1 {
         return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
     }
     encode(writer, value) {
-        let data = arrayify$3(value);
+        let data = arrayify$4(value);
         if (data.length !== this.size) {
             this._throwError("incorrect data length", value);
         }
@@ -14051,7 +14051,7 @@ function getUtf8CodePoints$2(bytes, onError) {
     if (onError == null) {
         onError = Utf8ErrorFuncs$2.error;
     }
-    bytes = arrayify$3(bytes);
+    bytes = arrayify$4(bytes);
     const result = [];
     let i = 0;
     // Invalid bytes are ignored
@@ -14165,7 +14165,7 @@ function toUtf8Bytes$2(str, form = UnicodeNormalizationForm$2.current) {
             result.push((c & 0x3f) | 0x80);
         }
     }
-    return arrayify$3(result);
+    return arrayify$4(result);
 }
 function _toUtf8String$2(codePoints) {
     return codePoints.map((codePoint) => {
@@ -14324,7 +14324,7 @@ class AbiCoder$1 {
     decode(types, data, loose) {
         const coders = types.map((type) => this._getCoder(ParamType$1.from(type)));
         const coder = new TupleCoder$1(coders, "_");
-        return coder.decode(this._getReader(arrayify$3(data), loose));
+        return coder.decode(this._getReader(arrayify$4(data), loose));
     }
 }
 const defaultAbiCoder$1 = new AbiCoder$1();
@@ -14582,7 +14582,7 @@ class Interface$1 {
         if (typeof (fragment) === "string") {
             fragment = this.getError(fragment);
         }
-        const bytes = arrayify$3(data);
+        const bytes = arrayify$4(data);
         if (hexlify$4(bytes.slice(0, 4)) !== this.getSighash(fragment)) {
             logger$y.throwArgumentError(`data signature does not match error ${fragment.name}.`, "data", hexlify$4(bytes));
         }
@@ -14602,7 +14602,7 @@ class Interface$1 {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
-        const bytes = arrayify$3(data);
+        const bytes = arrayify$4(data);
         if (hexlify$4(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) {
             logger$y.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, "data", hexlify$4(bytes));
         }
@@ -14623,7 +14623,7 @@ class Interface$1 {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
-        let bytes = arrayify$3(data);
+        let bytes = arrayify$4(data);
         let reason = null;
         let errorArgs = null;
         let errorName = null;
@@ -14698,7 +14698,7 @@ class Interface$1 {
             if (param.type === "address") {
                 this._abiCoder.encode(["address"], [value]);
             }
-            return hexZeroPad$3(hexlify$4(value), 32);
+            return hexZeroPad$4(hexlify$4(value), 32);
         };
         values.forEach((value, index) => {
             let param = eventFragment.inputs[index];
@@ -15461,7 +15461,7 @@ function populateTransaction$1(contract, fragment, args) {
             // is always a non-nil to address, we can ignore G_create, but may wish to add
             // similar logic to the ContractFactory.
             let intrinsic = 21000;
-            const bytes = arrayify$3(data);
+            const bytes = arrayify$4(data);
             for (let i = 0; i < bytes.length; i++) {
                 intrinsic += 4;
                 if (bytes[i]) {
@@ -16196,7 +16196,7 @@ class Contract$1 extends BaseContract$1 {
 const version$m = "units/5.5.0";
 
 const logger$t = new Logger$4(version$m);
-const names$2 = [
+const names$3 = [
     "wei",
     "kwei",
     "mwei",
@@ -16207,24 +16207,24 @@ const names$2 = [
 ];
 function formatUnits(value, unitName) {
     if (typeof (unitName) === "string") {
-        const index = names$2.indexOf(unitName);
+        const index = names$3.indexOf(unitName);
         if (index !== -1) {
             unitName = 3 * index;
         }
     }
-    return formatFixed$2(value, (unitName != null) ? unitName : 18);
+    return formatFixed$3(value, (unitName != null) ? unitName : 18);
 }
-function parseUnits$2(value, unitName) {
+function parseUnits$3(value, unitName) {
     if (typeof (value) !== "string") {
         logger$t.throwArgumentError("value must be a string", "value", value);
     }
     if (typeof (unitName) === "string") {
-        const index = names$2.indexOf(unitName);
+        const index = names$3.indexOf(unitName);
         if (index !== -1) {
             unitName = 3 * index;
         }
     }
-    return parseFixed$2(value, (unitName != null) ? unitName : 18);
+    return parseFixed$3(value, (unitName != null) ? unitName : 18);
 }
 
 function _optionalChain$7(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }let getWindow = () => {
@@ -16778,13 +16778,13 @@ const logger$f$1 = new Logger$3(version$d$1);
 function isHexable$3(value) {
     return !!(value.toHexString);
 }
-function addSlice$2(array) {
+function addSlice$3(array) {
     if (array.slice) {
         return array;
     }
     array.slice = function () {
         const args = Array.prototype.slice.call(arguments);
-        return addSlice$2(new Uint8Array(Array.prototype.slice.apply(array, args)));
+        return addSlice$3(new Uint8Array(Array.prototype.slice.apply(array, args)));
     };
     return array;
 }
@@ -16812,7 +16812,7 @@ function isBytes$3(value) {
     }
     return true;
 }
-function arrayify$2(value, options) {
+function arrayify$3(value, options) {
     if (!options) {
         options = {};
     }
@@ -16826,7 +16826,7 @@ function arrayify$2(value, options) {
         if (result.length === 0) {
             result.push(0);
         }
-        return addSlice$2(new Uint8Array(result));
+        return addSlice$3(new Uint8Array(result));
     }
     if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
         value = "0x" + value;
@@ -16851,25 +16851,25 @@ function arrayify$2(value, options) {
         for (let i = 0; i < hex.length; i += 2) {
             result.push(parseInt(hex.substring(i, i + 2), 16));
         }
-        return addSlice$2(new Uint8Array(result));
+        return addSlice$3(new Uint8Array(result));
     }
     if (isBytes$3(value)) {
-        return addSlice$2(new Uint8Array(value));
+        return addSlice$3(new Uint8Array(value));
     }
     return logger$f$1.throwArgumentError("invalid arrayify value", "value", value);
 }
 function concat$1(items) {
-    const objects = items.map(item => arrayify$2(item));
+    const objects = items.map(item => arrayify$3(item));
     const length = objects.reduce((accum, item) => (accum + item.length), 0);
     const result = new Uint8Array(length);
     objects.reduce((offset, object) => {
         result.set(object, offset);
         return offset + object.length;
     }, 0);
-    return addSlice$2(result);
+    return addSlice$3(result);
 }
 function stripZeros$1(value) {
-    let result = arrayify$2(value);
+    let result = arrayify$3(value);
     if (result.length === 0) {
         return result;
     }
@@ -16885,13 +16885,13 @@ function stripZeros$1(value) {
     return result;
 }
 function zeroPad$1(value, length) {
-    value = arrayify$2(value);
+    value = arrayify$3(value);
     if (value.length > length) {
         logger$f$1.throwArgumentError("value out of range", "value", arguments[0]);
     }
     const result = new Uint8Array(length);
     result.set(value, length - value.length);
-    return addSlice$2(result);
+    return addSlice$3(result);
 }
 function isHexString$3(value, length) {
     if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
@@ -17017,7 +17017,7 @@ function hexStripZeros$1(value) {
     }
     return "0x" + value.substring(offset);
 }
-function hexZeroPad$2(value, length) {
+function hexZeroPad$3(value, length) {
     if (typeof (value) !== "string") {
         value = hexlify$3(value);
     }
@@ -17041,7 +17041,7 @@ function splitSignature$1(signature) {
         v: 0
     };
     if (isBytesLike$1(signature)) {
-        const bytes = arrayify$2(signature);
+        const bytes = arrayify$3(signature);
         if (bytes.length !== 65) {
             logger$f$1.throwArgumentError("invalid signature string; must be 65 bytes", "signature", signature);
         }
@@ -17075,7 +17075,7 @@ function splitSignature$1(signature) {
         // If the _vs is available, use it to populate missing s, v and recoveryParam
         // and verify non-missing s, v and recoveryParam
         if (result._vs != null) {
-            const vs = zeroPad$1(arrayify$2(result._vs), 32);
+            const vs = zeroPad$1(arrayify$3(result._vs), 32);
             result._vs = hexlify$3(vs);
             // Set or check the recid
             const recoveryParam = ((vs[0] >= 128) ? 1 : 0);
@@ -17119,15 +17119,15 @@ function splitSignature$1(signature) {
             logger$f$1.throwArgumentError("signature missing or invalid r", "signature", signature);
         }
         else {
-            result.r = hexZeroPad$2(result.r, 32);
+            result.r = hexZeroPad$3(result.r, 32);
         }
         if (result.s == null || !isHexString$3(result.s)) {
             logger$f$1.throwArgumentError("signature missing or invalid s", "signature", signature);
         }
         else {
-            result.s = hexZeroPad$2(result.s, 32);
+            result.s = hexZeroPad$3(result.s, 32);
         }
-        const vs = arrayify$2(result.s);
+        const vs = arrayify$3(result.s);
         if (vs[0] >= 128) {
             logger$f$1.throwArgumentError("signature s out of range", "signature", signature);
         }
@@ -17139,7 +17139,7 @@ function splitSignature$1(signature) {
             if (!isHexString$3(result._vs)) {
                 logger$f$1.throwArgumentError("signature invalid _vs", "signature", signature);
             }
-            result._vs = hexZeroPad$2(result._vs, 32);
+            result._vs = hexZeroPad$3(result._vs, 32);
         }
         // Set or check the _vs
         if (result._vs == null) {
@@ -17153,7 +17153,7 @@ function splitSignature$1(signature) {
 }
 
 function encode$2$1(data) {
-    data = arrayify$2(data);
+    data = arrayify$3(data);
     let textData = "";
     for (let i = 0; i < data.length; i++) {
         textData += String.fromCharCode(data[i]);
@@ -20620,14 +20620,14 @@ const version$c$1 = "bignumber/5.4.1";
 
 var BN$3 = bn$3.BN;
 const logger$e$1 = new Logger$3(version$c$1);
-const _constructorGuard$1$2 = {};
+const _constructorGuard$1$3 = {};
 const MAX_SAFE$3 = 0x1fffffffffffff;
 // Only warn about passing 10 into radix once
 let _warnedToStringRadix$3 = false;
 class BigNumber$3 {
     constructor(constructorGuard, hex) {
         logger$e$1.checkNew(new.target, BigNumber$3);
-        if (constructorGuard !== _constructorGuard$1$2) {
+        if (constructorGuard !== _constructorGuard$1$3) {
             logger$e$1.throwError("cannot call constructor directly; use BigNumber.from", Logger$3.errors.UNSUPPORTED_OPERATION, {
                 operation: "new (BigNumber)"
             });
@@ -20786,10 +20786,10 @@ class BigNumber$3 {
         }
         if (typeof (value) === "string") {
             if (value.match(/^-?0x[0-9a-f]+$/i)) {
-                return new BigNumber$3(_constructorGuard$1$2, toHex$1$2(value));
+                return new BigNumber$3(_constructorGuard$1$3, toHex$1$2(value));
             }
             if (value.match(/^-?[0-9]+$/)) {
-                return new BigNumber$3(_constructorGuard$1$2, toHex$1$2(new BN$3(value)));
+                return new BigNumber$3(_constructorGuard$1$3, toHex$1$2(new BN$3(value)));
             }
             return logger$e$1.throwArgumentError("invalid BigNumber string", "value", value);
         }
@@ -20900,7 +20900,7 @@ function _base36To16$2(value) {
     return (new BN$3(value, 36)).toString(16);
 }
 
-const Zero$1$1 = ( /*#__PURE__*/BigNumber$3.from(0));
+const Zero$1$2 = ( /*#__PURE__*/BigNumber$3.from(0));
 
 const HashZero$1 = "0x0000000000000000000000000000000000000000000000000000000000000000";
 
@@ -20988,7 +20988,7 @@ function getUtf8CodePoints$1(bytes, onError) {
     if (onError == null) {
         onError = Utf8ErrorFuncs$1.error;
     }
-    bytes = arrayify$2(bytes);
+    bytes = arrayify$3(bytes);
     const result = [];
     let i = 0;
     // Invalid bytes are ignored
@@ -21102,7 +21102,7 @@ function toUtf8Bytes$1(str, form = UnicodeNormalizationForm$1.current) {
             result.push((c & 0x3f) | 0x80);
         }
     }
-    return arrayify$2(result);
+    return arrayify$3(result);
 }
 function _toUtf8String$1(codePoints) {
     return codePoints.map((codePoint) => {
@@ -21349,7 +21349,7 @@ function getUrl$1(href, options) {
             headers: headers,
             statusCode: response.status,
             statusMessage: response.statusText,
-            body: arrayify$2(new Uint8Array(body)),
+            body: arrayify$3(new Uint8Array(body)),
         };
     });
 }
@@ -22028,7 +22028,7 @@ class BaseX$1 {
         }
     }
     encode(value) {
-        let source = arrayify$2(value);
+        let source = arrayify$3(value);
         if (source.length === 0) {
             return "";
         }
@@ -22085,7 +22085,7 @@ class BaseX$1 {
         for (let k = 0; value[k] === this._leader && k < value.length - 1; ++k) {
             bytes.push(0);
         }
-        return arrayify$2(new Uint8Array(bytes.reverse()));
+        return arrayify$3(new Uint8Array(bytes.reverse()));
     }
 }
 new BaseX$1("abcdefghijklmnopqrstuvwxyz234567");
@@ -22574,7 +22574,7 @@ var sha3$3 = createCommonjsModule$1$2(function (module) {
 var sha3$1$2 = sha3$3;
 
 function keccak256$2(data) {
-    return '0x' + sha3$1$2.keccak_256(arrayify$2(data));
+    return '0x' + sha3$1$2.keccak_256(arrayify$3(data));
 }
 
 function id$1(text) {
@@ -22641,7 +22641,7 @@ function _encode$1(object) {
     if (!isBytesLike$1(object)) {
         logger$8$1.throwArgumentError("RLP object must be BytesLike", "object", object);
     }
-    const data = Array.prototype.slice.call(arrayify$2(object));
+    const data = Array.prototype.slice.call(arrayify$3(object));
     if (data.length === 1 && data[0] <= 0x7f) {
         return data;
     }
@@ -22715,7 +22715,7 @@ function _decode$1(data, offset) {
     return { consumed: 1, result: hexlify$3(data[offset]) };
 }
 function decode$1$1(data) {
-    const bytes = arrayify$2(data);
+    const bytes = arrayify$3(data);
     const decoded = _decode$1(bytes, 0);
     if (decoded.consumed !== bytes.length) {
         logger$8$1.throwArgumentError("invalid rlp data", "data", data);
@@ -22736,7 +22736,7 @@ function getChecksumAddress$2(address) {
     for (let i = 0; i < 40; i++) {
         expanded[i] = chars[i].charCodeAt(0);
     }
-    const hashed = arrayify$2(keccak256$2(expanded));
+    const hashed = arrayify$3(keccak256$2(expanded));
     for (let i = 0; i < 40; i += 2) {
         if ((hashed[i >> 1] >> 4) >= 8) {
             chars[i] = chars[i].toUpperCase();
@@ -22823,7 +22823,7 @@ function getContractAddress$1(transaction) {
     catch (error) {
         logger$7$1.throwArgumentError("missing from address", "transaction", transaction);
     }
-    const nonce = stripZeros$1(arrayify$2(BigNumber$3.from(transaction.nonce).toHexString()));
+    const nonce = stripZeros$1(arrayify$3(BigNumber$3.from(transaction.nonce).toHexString()));
     return getAddress$2(hexDataSlice$1(keccak256$2(encode$1$1([from, nonce])), 12));
 }
 
@@ -22844,15 +22844,15 @@ const Zero$4 = BigNumber$3.from(0);
 const One$2 = BigNumber$3.from(1);
 const MaxUint256$2 = BigNumber$3.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 function hexPadRight$1(value) {
-    const bytes = arrayify$2(value);
+    const bytes = arrayify$3(value);
     const padOffset = bytes.length % 32;
     if (padOffset) {
         return hexConcat$1([bytes, padding$1.slice(padOffset)]);
     }
     return hexlify$3(bytes);
 }
-const hexTrue$1 = hexZeroPad$2(One$2.toHexString(), 32);
-const hexFalse$1 = hexZeroPad$2(Zero$4.toHexString(), 32);
+const hexTrue$1 = hexZeroPad$3(One$2.toHexString(), 32);
+const hexFalse$1 = hexZeroPad$3(Zero$4.toHexString(), 32);
 const domainFieldTypes$1 = {
     name: "string",
     version: "string",
@@ -22890,7 +22890,7 @@ const domainChecks$1 = {
     },
     salt: function (value) {
         try {
-            const bytes = arrayify$2(value);
+            const bytes = arrayify$3(value);
             if (bytes.length !== 32) {
                 throw new Error("bad length");
             }
@@ -22917,7 +22917,7 @@ function getBaseEncoder$1(type) {
                 if (v.lt(boundsLower) || v.gt(boundsUpper)) {
                     logger$6$1.throwArgumentError(`value out-of-bounds for ${type}`, "value", value);
                 }
-                return hexZeroPad$2(v.toTwos(256).toHexString(), 32);
+                return hexZeroPad$3(v.toTwos(256).toHexString(), 32);
             };
         }
     }
@@ -22930,7 +22930,7 @@ function getBaseEncoder$1(type) {
                 logger$6$1.throwArgumentError("invalid bytes width", "type", type);
             }
             return function (value) {
-                const bytes = arrayify$2(value);
+                const bytes = arrayify$3(value);
                 if (bytes.length !== width) {
                     logger$6$1.throwArgumentError(`invalid length for ${type}`, "value", value);
                 }
@@ -22940,7 +22940,7 @@ function getBaseEncoder$1(type) {
     }
     switch (type) {
         case "address": return function (value) {
-            return hexZeroPad$2(getAddress$2(value), 32);
+            return hexZeroPad$3(getAddress$2(value), 32);
         };
         case "bool": return function (value) {
             return ((!value) ? hexFalse$1 : hexTrue$1);
@@ -23237,7 +23237,7 @@ class TypedDataEncoder$1 {
             message: encoder.visit(value, (type, value) => {
                 // bytes
                 if (type.match(/^bytes(\d*)/)) {
-                    return hexlify$3(arrayify$2(value));
+                    return hexlify$3(arrayify$3(value));
                 }
                 // uint or int
                 if (type.match(/^u?int/)) {
@@ -24542,7 +24542,7 @@ const version$4$2 = "sha2/5.4.0";
 
 new Logger$3(version$4$2);
 function sha256$2(data) {
-    return "0x" + (hash$1.sha256().update(arrayify$2(data)).digest("hex"));
+    return "0x" + (hash$1.sha256().update(arrayify$3(data)).digest("hex"));
 }
 
 var ALPHABET$1 = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
@@ -24727,7 +24727,7 @@ var bech32$1 = {
   fromWords: fromWords$1
 };
 
-const version$3$2 = "providers/5.4.5";
+const version$3$3 = "providers/5.4.5";
 
 function createCommonjsModule$3(fn, basedir, module) {
 	return module = {
@@ -27169,33 +27169,33 @@ class SigningKey$1 {
     constructor(privateKey) {
         defineReadOnly$1(this, "curve", "secp256k1");
         defineReadOnly$1(this, "privateKey", hexlify$3(privateKey));
-        const keyPair = getCurve$1().keyFromPrivate(arrayify$2(this.privateKey));
+        const keyPair = getCurve$1().keyFromPrivate(arrayify$3(this.privateKey));
         defineReadOnly$1(this, "publicKey", "0x" + keyPair.getPublic(false, "hex"));
         defineReadOnly$1(this, "compressedPublicKey", "0x" + keyPair.getPublic(true, "hex"));
         defineReadOnly$1(this, "_isSigningKey", true);
     }
     _addPoint(other) {
-        const p0 = getCurve$1().keyFromPublic(arrayify$2(this.publicKey));
-        const p1 = getCurve$1().keyFromPublic(arrayify$2(other));
+        const p0 = getCurve$1().keyFromPublic(arrayify$3(this.publicKey));
+        const p1 = getCurve$1().keyFromPublic(arrayify$3(other));
         return "0x" + p0.pub.add(p1.pub).encodeCompressed("hex");
     }
     signDigest(digest) {
-        const keyPair = getCurve$1().keyFromPrivate(arrayify$2(this.privateKey));
-        const digestBytes = arrayify$2(digest);
+        const keyPair = getCurve$1().keyFromPrivate(arrayify$3(this.privateKey));
+        const digestBytes = arrayify$3(digest);
         if (digestBytes.length !== 32) {
             logger$5$2.throwArgumentError("bad digest length", "digest", digest);
         }
         const signature = keyPair.sign(digestBytes, { canonical: true });
         return splitSignature$1({
             recoveryParam: signature.recoveryParam,
-            r: hexZeroPad$2("0x" + signature.r.toString(16), 32),
-            s: hexZeroPad$2("0x" + signature.s.toString(16), 32),
+            r: hexZeroPad$3("0x" + signature.r.toString(16), 32),
+            s: hexZeroPad$3("0x" + signature.s.toString(16), 32),
         });
     }
     computeSharedSecret(otherKey) {
-        const keyPair = getCurve$1().keyFromPrivate(arrayify$2(this.privateKey));
-        const otherKeyPair = getCurve$1().keyFromPublic(arrayify$2(computePublicKey$1(otherKey)));
-        return hexZeroPad$2("0x" + keyPair.derive(otherKeyPair.getPublic()).toString(16), 32);
+        const keyPair = getCurve$1().keyFromPrivate(arrayify$3(this.privateKey));
+        const otherKeyPair = getCurve$1().keyFromPublic(arrayify$3(computePublicKey$1(otherKey)));
+        return hexZeroPad$3("0x" + keyPair.derive(otherKeyPair.getPublic()).toString(16), 32);
     }
     static isSigningKey(value) {
         return !!(value && value._isSigningKey);
@@ -27203,11 +27203,11 @@ class SigningKey$1 {
 }
 function recoverPublicKey$1(digest, signature) {
     const sig = splitSignature$1(signature);
-    const rs = { r: arrayify$2(sig.r), s: arrayify$2(sig.s) };
-    return "0x" + getCurve$1().recoverPubKey(arrayify$2(digest), rs, sig.recoveryParam).encode("hex", false);
+    const rs = { r: arrayify$3(sig.r), s: arrayify$3(sig.s) };
+    return "0x" + getCurve$1().recoverPubKey(arrayify$3(digest), rs, sig.recoveryParam).encode("hex", false);
 }
 function computePublicKey$1(key, compressed) {
-    const bytes = arrayify$2(key);
+    const bytes = arrayify$3(key);
     if (bytes.length === 32) {
         const signingKey = new SigningKey$1(bytes);
         if (compressed) {
@@ -27248,7 +27248,7 @@ function handleAddress$1(value) {
 }
 function handleNumber$1(value) {
     if (value === "0x") {
-        return Zero$1$1;
+        return Zero$1$2;
     }
     return BigNumber$3.from(value);
 }
@@ -27257,7 +27257,7 @@ function computeAddress$1(key) {
     return getAddress$2(hexDataSlice$1(keccak256$2(hexDataSlice$1(publicKey, 1)), 12));
 }
 function recoverAddress$1(digest, signature) {
-    return computeAddress$1(recoverPublicKey$1(arrayify$2(digest), signature));
+    return computeAddress$1(recoverPublicKey$1(arrayify$3(digest), signature));
 }
 function formatNumber$1(value, name) {
     const result = stripZeros$1(BigNumber$3.from(value).toHexString());
@@ -27364,8 +27364,8 @@ function _parseEipSignature$1(tx, fields, serialize) {
     catch (error) {
         logger$4$2.throwArgumentError("invalid v for transaction type: 1", "v", fields[0]);
     }
-    tx.r = hexZeroPad$2(fields[1], 32);
-    tx.s = hexZeroPad$2(fields[2], 32);
+    tx.r = hexZeroPad$3(fields[1], 32);
+    tx.s = hexZeroPad$3(fields[2], 32);
     try {
         const digest = keccak256$2(serialize(tx));
         tx.from = recoverAddress$1(digest, { r: tx.r, s: tx.s, recoveryParam: tx.v });
@@ -27452,8 +27452,8 @@ function _parse$1(rawTransaction) {
         console.log(error);
         return tx;
     }
-    tx.r = hexZeroPad$2(transaction[7], 32);
-    tx.s = hexZeroPad$2(transaction[8], 32);
+    tx.r = hexZeroPad$3(transaction[7], 32);
+    tx.s = hexZeroPad$3(transaction[8], 32);
     if (BigNumber$3.from(tx.r).isZero() && BigNumber$3.from(tx.s).isZero()) {
         // EIP-155 unsigned transaction
         tx.chainId = tx.v;
@@ -27486,7 +27486,7 @@ function _parse$1(rawTransaction) {
     return tx;
 }
 function parse$1(rawTransaction) {
-    const payload = arrayify$2(rawTransaction);
+    const payload = arrayify$3(rawTransaction);
     // Legacy and EIP-155 Transactions
     if (payload[0] > 0x7f) {
         return _parse$1(payload);
@@ -27504,10 +27504,10 @@ function parse$1(rawTransaction) {
     });
 }
 
-const logger$3$2 = new Logger$3(version$3$2);
+const logger$3$3 = new Logger$3(version$3$3);
 class Formatter$1 {
     constructor() {
-        logger$3$2.checkNew(new.target, Formatter$1);
+        logger$3$3.checkNew(new.target, Formatter$1);
         this.formats = this.getDefaultFormats();
     }
     getDefaultFormats() {
@@ -27670,7 +27670,7 @@ class Formatter$1 {
                 return value.toLowerCase();
             }
         }
-        return logger$3$2.throwArgumentError("invalid hash", "value", value);
+        return logger$3$3.throwArgumentError("invalid hash", "value", value);
     }
     data(value, strict) {
         const result = this.hex(value, strict);
@@ -27714,7 +27714,7 @@ class Formatter$1 {
     hash(value, strict) {
         const result = this.hex(value, strict);
         if (hexDataLength$1(result) !== 32) {
-            return logger$3$2.throwArgumentError("invalid hash", "value", value);
+            return logger$3$3.throwArgumentError("invalid hash", "value", value);
         }
         return result;
     }
@@ -27734,7 +27734,7 @@ class Formatter$1 {
         if (!isHexString$3(value)) {
             throw new Error("invalid uint256");
         }
-        return hexZeroPad$2(value, 32);
+        return hexZeroPad$3(value, 32);
     }
     _block(value, format) {
         if (value.author != null && value.miner == null) {
@@ -27824,18 +27824,18 @@ class Formatter$1 {
                 if (value === 0 || value === 1) {
                     // Make sure if both are specified, they match
                     if (result.status != null && (result.status !== value)) {
-                        logger$3$2.throwArgumentError("alt-root-status/status mismatch", "value", { root: result.root, status: result.status });
+                        logger$3$3.throwArgumentError("alt-root-status/status mismatch", "value", { root: result.root, status: result.status });
                     }
                     result.status = value;
                     delete result.root;
                 }
                 else {
-                    logger$3$2.throwArgumentError("invalid alt-root-status", "value.root", result.root);
+                    logger$3$3.throwArgumentError("invalid alt-root-status", "value.root", result.root);
                 }
             }
             else if (result.root.length !== 66) {
                 // Must be a valid bytes32
-                logger$3$2.throwArgumentError("invalid root hash", "value.root", result.root);
+                logger$3$3.throwArgumentError("invalid root hash", "value.root", result.root);
             }
         }
         if (result.status != null) {
@@ -27917,7 +27917,7 @@ var __awaiter$2$1 = function (thisArg, _arguments, P, generator) {
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const logger$2$2 = new Logger$3(version$3$2);
+const logger$2$3 = new Logger$3(version$3$3);
 //////////////////////////////
 // Event Serializeing
 function checkTopic$1(topic) {
@@ -27925,7 +27925,7 @@ function checkTopic$1(topic) {
         return "null";
     }
     if (hexDataLength$1(topic) !== 32) {
-        logger$2$2.throwArgumentError("invalid topic", "topic", topic);
+        logger$2$3.throwArgumentError("invalid topic", "topic", topic);
     }
     return topic.toLowerCase();
 }
@@ -27980,7 +27980,7 @@ function getEventTag$2(eventName) {
         return "filter:*:" + serializeTopics$1(eventName);
     }
     else if (ForkEvent$1.isForkEvent(eventName)) {
-        logger$2$2.warn("not implemented");
+        logger$2$3.warn("not implemented");
         throw new Error("not implemented");
     }
     else if (eventName && typeof (eventName) === "object") {
@@ -28068,7 +28068,7 @@ const coinInfos$1 = {
     "700": { symbol: "xdai", ilk: "eth" },
 };
 function bytes32ify$1(value) {
-    return hexZeroPad$2(BigNumber$3.from(value).toHexString(), 32);
+    return hexZeroPad$3(BigNumber$3.from(value).toHexString(), 32);
 }
 // Compute the Base58Check encoded data (checksum is first 4 bytes of sha256d)
 function base58Encode$1(data) {
@@ -28107,14 +28107,14 @@ class Resolver$1 {
     _getAddress(coinType, hexBytes) {
         const coinInfo = coinInfos$1[String(coinType)];
         if (coinInfo == null) {
-            logger$2$2.throwError(`unsupported coin type: ${coinType}`, Logger$3.errors.UNSUPPORTED_OPERATION, {
+            logger$2$3.throwError(`unsupported coin type: ${coinType}`, Logger$3.errors.UNSUPPORTED_OPERATION, {
                 operation: `getAddress(${coinType})`
             });
         }
         if (coinInfo.ilk === "eth") {
             return this.provider.formatter.address(hexBytes);
         }
-        const bytes = arrayify$2(hexBytes);
+        const bytes = arrayify$3(hexBytes);
         // P2PKH: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
         if (coinInfo.p2pkh != null) {
             const p2pkh = hexBytes.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);
@@ -28192,7 +28192,7 @@ class Resolver$1 {
             // Compute the address
             const address = this._getAddress(coinType, hexBytes);
             if (address == null) {
-                logger$2$2.throwError(`invalid or unsupported coin data`, Logger$3.errors.UNSUPPORTED_OPERATION, {
+                logger$2$3.throwError(`invalid or unsupported coin data`, Logger$3.errors.UNSUPPORTED_OPERATION, {
                     operation: `getAddress(${coinType})`,
                     coinType: coinType,
                     data: hexBytes
@@ -28224,7 +28224,7 @@ class Resolver$1 {
                     return "bzz:/\/" + swarm[1];
                 }
             }
-            return logger$2$2.throwError(`invalid or unsupported content hash data`, Logger$3.errors.UNSUPPORTED_OPERATION, {
+            return logger$2$3.throwError(`invalid or unsupported content hash data`, Logger$3.errors.UNSUPPORTED_OPERATION, {
                 operation: "getContentHash()",
                 data: hexBytes
             });
@@ -28239,7 +28239,7 @@ class Resolver$1 {
             keyBytes = concat$1([bytes32ify$1(64), bytes32ify$1(keyBytes.length), keyBytes]);
             // Pad to word-size (32 bytes)
             if ((keyBytes.length % 32) !== 0) {
-                keyBytes = concat$1([keyBytes, hexZeroPad$2("0x", 32 - (key.length % 32))]);
+                keyBytes = concat$1([keyBytes, hexZeroPad$3("0x", 32 - (key.length % 32))]);
             }
             const hexBytes = yield this._fetchBytes("0x59d1d43c", hexlify$3(keyBytes));
             if (hexBytes == null || hexBytes === "0x") {
@@ -28262,7 +28262,7 @@ class BaseProvider$1 extends Provider$1 {
      *
      */
     constructor(network) {
-        logger$2$2.checkNew(new.target, Provider$1);
+        logger$2$3.checkNew(new.target, Provider$1);
         super();
         // Events being listened to
         this._events = [];
@@ -28289,7 +28289,7 @@ class BaseProvider$1 extends Provider$1 {
                 this.emit("network", knownNetwork, null);
             }
             else {
-                logger$2$2.throwArgumentError("invalid network", "network", network);
+                logger$2$3.throwArgumentError("invalid network", "network", network);
             }
         }
         this._maxInternalBlockNumber = -1024;
@@ -28314,7 +28314,7 @@ class BaseProvider$1 extends Provider$1 {
                 // This should never happen; every Provider sub-class should have
                 // suggested a network by here (or have thrown).
                 if (!network) {
-                    logger$2$2.throwError("no network detected", Logger$3.errors.UNKNOWN_ERROR, {});
+                    logger$2$3.throwError("no network detected", Logger$3.errors.UNKNOWN_ERROR, {});
                 }
                 // Possible this call stacked so do not call defineReadOnly again
                 if (this._network == null) {
@@ -28446,8 +28446,8 @@ class BaseProvider$1 extends Provider$1 {
                 this._emitted.block = blockNumber - 1;
             }
             if (Math.abs((this._emitted.block) - blockNumber) > 1000) {
-                logger$2$2.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
-                this.emit("error", logger$2$2.makeError("network block skew detected", Logger$3.errors.NETWORK_ERROR, {
+                logger$2$3.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
+                this.emit("error", logger$2$3.makeError("network block skew detected", Logger$3.errors.NETWORK_ERROR, {
                     blockNumber: blockNumber,
                     event: "blockSkew",
                     previousBlockNumber: this._emitted.block
@@ -28544,7 +28544,7 @@ class BaseProvider$1 extends Provider$1 {
     // can change, such as when connected to a JSON-RPC backend
     detectNetwork() {
         return __awaiter$2$1(this, void 0, void 0, function* () {
-            return logger$2$2.throwError("provider does not support network detection", Logger$3.errors.UNSUPPORTED_OPERATION, {
+            return logger$2$3.throwError("provider does not support network detection", Logger$3.errors.UNSUPPORTED_OPERATION, {
                 operation: "provider.detectNetwork"
             });
         });
@@ -28576,7 +28576,7 @@ class BaseProvider$1 extends Provider$1 {
                     yield stall$1(0);
                     return this._network;
                 }
-                const error = logger$2$2.makeError("underlying network changed", Logger$3.errors.NETWORK_ERROR, {
+                const error = logger$2$3.makeError("underlying network changed", Logger$3.errors.NETWORK_ERROR, {
                     event: "changed",
                     network: network,
                     detectedNetwork: currentNetwork
@@ -28763,7 +28763,7 @@ class BaseProvider$1 extends Provider$1 {
                                                 reason = "cancelled";
                                             }
                                             // Explain why we were replaced
-                                            reject(logger$2$2.makeError("transaction was replaced", Logger$3.errors.TRANSACTION_REPLACED, {
+                                            reject(logger$2$3.makeError("transaction was replaced", Logger$3.errors.TRANSACTION_REPLACED, {
                                                 cancelled: (reason === "replaced" || reason === "cancelled"),
                                                 reason,
                                                 replacement: this._wrapTransaction(tx),
@@ -28800,7 +28800,7 @@ class BaseProvider$1 extends Provider$1 {
                         if (alreadyDone()) {
                             return;
                         }
-                        reject(logger$2$2.makeError("timeout exceeded", Logger$3.errors.TIMEOUT, { timeout: timeout }));
+                        reject(logger$2$3.makeError("timeout exceeded", Logger$3.errors.TIMEOUT, { timeout: timeout }));
                     }, timeout);
                     if (timer.unref) {
                         timer.unref();
@@ -28823,7 +28823,7 @@ class BaseProvider$1 extends Provider$1 {
                 return BigNumber$3.from(result);
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "getGasPrice",
                     result, error
                 });
@@ -28842,7 +28842,7 @@ class BaseProvider$1 extends Provider$1 {
                 return BigNumber$3.from(result);
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "getBalance",
                     params, result, error
                 });
@@ -28861,7 +28861,7 @@ class BaseProvider$1 extends Provider$1 {
                 return BigNumber$3.from(result).toNumber();
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "getTransactionCount",
                     params, result, error
                 });
@@ -28880,7 +28880,7 @@ class BaseProvider$1 extends Provider$1 {
                 return hexlify$3(result);
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "getCode",
                     params, result, error
                 });
@@ -28900,7 +28900,7 @@ class BaseProvider$1 extends Provider$1 {
                 return hexlify$3(result);
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "getStorageAt",
                     params, result, error
                 });
@@ -28915,7 +28915,7 @@ class BaseProvider$1 extends Provider$1 {
         const result = tx;
         // Check the hash we expect is the same as the hash the server reported
         if (hash != null && tx.hash !== hash) {
-            logger$2$2.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger$3.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
+            logger$2$3.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger$3.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
         }
         result.wait = (confirms, timeout) => __awaiter$2$1(this, void 0, void 0, function* () {
             if (confirms == null) {
@@ -28943,7 +28943,7 @@ class BaseProvider$1 extends Provider$1 {
             // No longer pending, allow the polling loop to garbage collect this
             this._emitted["t:" + tx.hash] = receipt.blockNumber;
             if (receipt.status === 0) {
-                logger$2$2.throwError("transaction failed", Logger$3.errors.CALL_EXCEPTION, {
+                logger$2$3.throwError("transaction failed", Logger$3.errors.CALL_EXCEPTION, {
                     transactionHash: tx.hash,
                     transaction: tx,
                     receipt: receipt
@@ -29041,7 +29041,7 @@ class BaseProvider$1 extends Provider$1 {
                 return hexlify$3(result);
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "call",
                     params, result, error
                 });
@@ -29059,7 +29059,7 @@ class BaseProvider$1 extends Provider$1 {
                 return BigNumber$3.from(result);
             }
             catch (error) {
-                return logger$2$2.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
+                return logger$2$3.throwError("bad result from backend", Logger$3.errors.SERVER_ERROR, {
                     method: "estimateGas",
                     params, result, error
                 });
@@ -29070,7 +29070,7 @@ class BaseProvider$1 extends Provider$1 {
         return __awaiter$2$1(this, void 0, void 0, function* () {
             const address = yield this.resolveName(addressOrName);
             if (address == null) {
-                logger$2$2.throwError("ENS name not configured", Logger$3.errors.UNSUPPORTED_OPERATION, {
+                logger$2$3.throwError("ENS name not configured", Logger$3.errors.UNSUPPORTED_OPERATION, {
                     operation: `resolveName(${JSON.stringify(addressOrName)})`
                 });
             }
@@ -29097,7 +29097,7 @@ class BaseProvider$1 extends Provider$1 {
                     }
                 }
                 catch (error) {
-                    logger$2$2.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
+                    logger$2$3.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
                 }
             }
             return poll$1(() => __awaiter$2$1(this, void 0, void 0, function* () {
@@ -29243,7 +29243,7 @@ class BaseProvider$1 extends Provider$1 {
             blockTag = yield blockTag;
             if (typeof (blockTag) === "number" && blockTag < 0) {
                 if (blockTag % 1) {
-                    logger$2$2.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
+                    logger$2$3.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
                 }
                 let blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                 blockNumber += blockTag;
@@ -29278,7 +29278,7 @@ class BaseProvider$1 extends Provider$1 {
             const network = yield this.getNetwork();
             // No ENS...
             if (!network.ensAddress) {
-                logger$2$2.throwError("network does not support ENS", Logger$3.errors.UNSUPPORTED_OPERATION, { operation: "ENS", network: network.name });
+                logger$2$3.throwError("network does not support ENS", Logger$3.errors.UNSUPPORTED_OPERATION, { operation: "ENS", network: network.name });
             }
             // keccak256("resolver(bytes32)")
             const transaction = {
@@ -29310,7 +29310,7 @@ class BaseProvider$1 extends Provider$1 {
                 }
             }
             if (typeof (name) !== "string") {
-                logger$2$2.throwArgumentError("invalid ENS name", "name", name);
+                logger$2$3.throwArgumentError("invalid ENS name", "name", name);
             }
             // Get the addr from the resovler
             const resolver = yield this.getResolver(name);
@@ -29330,7 +29330,7 @@ class BaseProvider$1 extends Provider$1 {
                 return null;
             }
             // keccak("name(bytes32)")
-            let bytes = arrayify$2(yield this.call({
+            let bytes = arrayify$3(yield this.call({
                 to: resolverAddress,
                 data: ("0x691f3431" + namehash$1(reverseName).substring(2))
             }));
@@ -29360,7 +29360,7 @@ class BaseProvider$1 extends Provider$1 {
         });
     }
     perform(method, params) {
-        return logger$2$2.throwError(method + " not implemented", Logger$3.errors.NOT_IMPLEMENTED, { operation: method });
+        return logger$2$3.throwError(method + " not implemented", Logger$3.errors.NOT_IMPLEMENTED, { operation: method });
     }
     _startEvent(event) {
         this.polling = (this._events.filter((e) => e.pollable()).length > 0);
@@ -29742,7 +29742,7 @@ var __awaiter$9 = function (thisArg, _arguments, P, generator) {
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const logger$s = new Logger$3(version$3$2);
+const logger$s = new Logger$3(version$3$3);
 const errorGas$1 = ["call", "estimateGas"];
 function checkError$1(method, error, params) {
     // Undo the "convenience" some nodes are attempting to prevent backwards
@@ -30373,7 +30373,7 @@ class JsonRpcBatchProvider extends JsonRpcProvider$1 {
     }
 }
 
-new Logger$3(version$3$2);
+new Logger$3(version$3$3);
 
 const BATCH_INTERVAL = 10;
 
@@ -34424,13 +34424,13 @@ const logger$q = new Logger$2(version$i);
 function isHexable$2(value) {
     return !!(value.toHexString);
 }
-function addSlice$1(array) {
+function addSlice$2(array) {
     if (array.slice) {
         return array;
     }
     array.slice = function () {
         const args = Array.prototype.slice.call(arguments);
-        return addSlice$1(new Uint8Array(Array.prototype.slice.apply(array, args)));
+        return addSlice$2(new Uint8Array(Array.prototype.slice.apply(array, args)));
     };
     return array;
 }
@@ -34458,7 +34458,7 @@ function isBytes$2(value) {
     }
     return true;
 }
-function arrayify$1(value, options) {
+function arrayify$2(value, options) {
     if (!options) {
         options = {};
     }
@@ -34472,7 +34472,7 @@ function arrayify$1(value, options) {
         if (result.length === 0) {
             result.push(0);
         }
-        return addSlice$1(new Uint8Array(result));
+        return addSlice$2(new Uint8Array(result));
     }
     if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
         value = "0x" + value;
@@ -34497,25 +34497,25 @@ function arrayify$1(value, options) {
         for (let i = 0; i < hex.length; i += 2) {
             result.push(parseInt(hex.substring(i, i + 2), 16));
         }
-        return addSlice$1(new Uint8Array(result));
+        return addSlice$2(new Uint8Array(result));
     }
     if (isBytes$2(value)) {
-        return addSlice$1(new Uint8Array(value));
+        return addSlice$2(new Uint8Array(value));
     }
     return logger$q.throwArgumentError("invalid arrayify value", "value", value);
 }
 function concat(items) {
-    const objects = items.map(item => arrayify$1(item));
+    const objects = items.map(item => arrayify$2(item));
     const length = objects.reduce((accum, item) => (accum + item.length), 0);
     const result = new Uint8Array(length);
     objects.reduce((offset, object) => {
         result.set(object, offset);
         return offset + object.length;
     }, 0);
-    return addSlice$1(result);
+    return addSlice$2(result);
 }
 function stripZeros(value) {
-    let result = arrayify$1(value);
+    let result = arrayify$2(value);
     if (result.length === 0) {
         return result;
     }
@@ -34531,13 +34531,13 @@ function stripZeros(value) {
     return result;
 }
 function zeroPad(value, length) {
-    value = arrayify$1(value);
+    value = arrayify$2(value);
     if (value.length > length) {
         logger$q.throwArgumentError("value out of range", "value", arguments[0]);
     }
     const result = new Uint8Array(length);
     result.set(value, length - value.length);
-    return addSlice$1(result);
+    return addSlice$2(result);
 }
 function isHexString$2(value, length) {
     if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
@@ -34663,7 +34663,7 @@ function hexStripZeros(value) {
     }
     return "0x" + value.substring(offset);
 }
-function hexZeroPad$1(value, length) {
+function hexZeroPad$2(value, length) {
     if (typeof (value) !== "string") {
         value = hexlify$2(value);
     }
@@ -34687,7 +34687,7 @@ function splitSignature(signature) {
         v: 0
     };
     if (isBytesLike(signature)) {
-        const bytes = arrayify$1(signature);
+        const bytes = arrayify$2(signature);
         if (bytes.length !== 65) {
             logger$q.throwArgumentError("invalid signature string; must be 65 bytes", "signature", signature);
         }
@@ -34721,7 +34721,7 @@ function splitSignature(signature) {
         // If the _vs is available, use it to populate missing s, v and recoveryParam
         // and verify non-missing s, v and recoveryParam
         if (result._vs != null) {
-            const vs = zeroPad(arrayify$1(result._vs), 32);
+            const vs = zeroPad(arrayify$2(result._vs), 32);
             result._vs = hexlify$2(vs);
             // Set or check the recid
             const recoveryParam = ((vs[0] >= 128) ? 1 : 0);
@@ -34765,15 +34765,15 @@ function splitSignature(signature) {
             logger$q.throwArgumentError("signature missing or invalid r", "signature", signature);
         }
         else {
-            result.r = hexZeroPad$1(result.r, 32);
+            result.r = hexZeroPad$2(result.r, 32);
         }
         if (result.s == null || !isHexString$2(result.s)) {
             logger$q.throwArgumentError("signature missing or invalid s", "signature", signature);
         }
         else {
-            result.s = hexZeroPad$1(result.s, 32);
+            result.s = hexZeroPad$2(result.s, 32);
         }
-        const vs = arrayify$1(result.s);
+        const vs = arrayify$2(result.s);
         if (vs[0] >= 128) {
             logger$q.throwArgumentError("signature s out of range", "signature", signature);
         }
@@ -34785,7 +34785,7 @@ function splitSignature(signature) {
             if (!isHexString$2(result._vs)) {
                 logger$q.throwArgumentError("signature invalid _vs", "signature", signature);
             }
-            result._vs = hexZeroPad$1(result._vs, 32);
+            result._vs = hexZeroPad$2(result._vs, 32);
         }
         // Set or check the _vs
         if (result._vs == null) {
@@ -34804,7 +34804,7 @@ var BN$1$1 = bn$2.BN;
 const logger$p = new Logger$2(version$h);
 const _constructorGuard$4 = {};
 const MAX_SAFE$1$1 = 0x1fffffffffffff;
-function isBigNumberish$1(value) {
+function isBigNumberish$2(value) {
     return (value != null) && (BigNumber$1$1.isBigNumber(value) ||
         (typeof (value) === "number" && (value % 1) === 0) ||
         (typeof (value) === "string" && !!value.match(/^-?[0-9]+$/)) ||
@@ -35094,7 +35094,7 @@ const logger$o = new Logger$2(version$h);
 const _constructorGuard$3 = {};
 const Zero$2 = BigNumber$1$1.from(0);
 const NegativeOne$2 = BigNumber$1$1.from(-1);
-function throwFault$1$1(message, fault, operation, value) {
+function throwFault$1$2(message, fault, operation, value) {
     const params = { fault: fault, operation: operation };
     if (value !== undefined) {
         params.value = value;
@@ -35102,12 +35102,12 @@ function throwFault$1$1(message, fault, operation, value) {
     return logger$o.throwError(message, Logger$2.errors.NUMERIC_FAULT, params);
 }
 // Constant to pull zeros from for multipliers
-let zeros$1 = "0";
-while (zeros$1.length < 256) {
-    zeros$1 += zeros$1;
+let zeros$2 = "0";
+while (zeros$2.length < 256) {
+    zeros$2 += zeros$2;
 }
 // Returns a string "1" followed by decimal "0"s
-function getMultiplier$1(decimals) {
+function getMultiplier$2(decimals) {
     if (typeof (decimals) !== "number") {
         try {
             decimals = BigNumber$1$1.from(decimals).toNumber();
@@ -35115,15 +35115,15 @@ function getMultiplier$1(decimals) {
         catch (e) { }
     }
     if (typeof (decimals) === "number" && decimals >= 0 && decimals <= 256 && !(decimals % 1)) {
-        return ("1" + zeros$1.substring(0, decimals));
+        return ("1" + zeros$2.substring(0, decimals));
     }
     return logger$o.throwArgumentError("invalid decimal size", "decimals", decimals);
 }
-function formatFixed$1(value, decimals) {
+function formatFixed$2(value, decimals) {
     if (decimals == null) {
         decimals = 0;
     }
-    const multiplier = getMultiplier$1(decimals);
+    const multiplier = getMultiplier$2(decimals);
     // Make sure wei is a big number (convert as necessary)
     value = BigNumber$1$1.from(value);
     const negative = value.lt(Zero$2);
@@ -35148,11 +35148,11 @@ function formatFixed$1(value, decimals) {
     }
     return value;
 }
-function parseFixed$1(value, decimals) {
+function parseFixed$2(value, decimals) {
     if (decimals == null) {
         decimals = 0;
     }
-    const multiplier = getMultiplier$1(decimals);
+    const multiplier = getMultiplier$2(decimals);
     if (typeof (value) !== "string" || !value.match(/^-?[0-9.,]+$/)) {
         logger$o.throwArgumentError("invalid decimal value", "value", value);
     }
@@ -35180,7 +35180,7 @@ function parseFixed$1(value, decimals) {
     {
         const sigFraction = fraction.replace(/^([0-9]*?)(0*)$/, (all, sig, zeros) => (sig));
         if (sigFraction.length > multiplier.length - 1) {
-            throwFault$1$1("fractional component exceeds decimals", "underflow", "parseFixed");
+            throwFault$1$2("fractional component exceeds decimals", "underflow", "parseFixed");
         }
     }
     // Fully pad the string with zeros to get to wei
@@ -35195,7 +35195,7 @@ function parseFixed$1(value, decimals) {
     }
     return wei;
 }
-class FixedFormat$1 {
+class FixedFormat$2 {
     constructor(constructorGuard, signed, width, decimals) {
         if (constructorGuard !== _constructorGuard$3) {
             logger$o.throwError("cannot use FixedFormat constructor; use FixedFormat.from", Logger$2.errors.UNSUPPORTED_OPERATION, {
@@ -35206,11 +35206,11 @@ class FixedFormat$1 {
         this.width = width;
         this.decimals = decimals;
         this.name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
-        this._multiplier = getMultiplier$1(decimals);
+        this._multiplier = getMultiplier$2(decimals);
         Object.freeze(this);
     }
     static from(value) {
-        if (value instanceof FixedFormat$1) {
+        if (value instanceof FixedFormat$2) {
             return value;
         }
         if (typeof (value) === "number") {
@@ -35254,12 +35254,12 @@ class FixedFormat$1 {
         if (decimals > 80) {
             logger$o.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals);
         }
-        return new FixedFormat$1(_constructorGuard$3, signed, width, decimals);
+        return new FixedFormat$2(_constructorGuard$3, signed, width, decimals);
     }
 }
-class FixedNumber$1 {
+class FixedNumber$2 {
     constructor(constructorGuard, hex, value, format) {
-        logger$o.checkNew(new.target, FixedNumber$1);
+        logger$o.checkNew(new.target, FixedNumber$2);
         if (constructorGuard !== _constructorGuard$3) {
             logger$o.throwError("cannot use FixedNumber constructor; use FixedNumber.from", Logger$2.errors.UNSUPPORTED_OPERATION, {
                 operation: "new FixedFormat"
@@ -35278,37 +35278,37 @@ class FixedNumber$1 {
     }
     addUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$1(this._value, this.format.decimals);
-        const b = parseFixed$1(other._value, other.format.decimals);
-        return FixedNumber$1.fromValue(a.add(b), this.format.decimals, this.format);
+        const a = parseFixed$2(this._value, this.format.decimals);
+        const b = parseFixed$2(other._value, other.format.decimals);
+        return FixedNumber$2.fromValue(a.add(b), this.format.decimals, this.format);
     }
     subUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$1(this._value, this.format.decimals);
-        const b = parseFixed$1(other._value, other.format.decimals);
-        return FixedNumber$1.fromValue(a.sub(b), this.format.decimals, this.format);
+        const a = parseFixed$2(this._value, this.format.decimals);
+        const b = parseFixed$2(other._value, other.format.decimals);
+        return FixedNumber$2.fromValue(a.sub(b), this.format.decimals, this.format);
     }
     mulUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$1(this._value, this.format.decimals);
-        const b = parseFixed$1(other._value, other.format.decimals);
-        return FixedNumber$1.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
+        const a = parseFixed$2(this._value, this.format.decimals);
+        const b = parseFixed$2(other._value, other.format.decimals);
+        return FixedNumber$2.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
     }
     divUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed$1(this._value, this.format.decimals);
-        const b = parseFixed$1(other._value, other.format.decimals);
-        return FixedNumber$1.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
+        const a = parseFixed$2(this._value, this.format.decimals);
+        const b = parseFixed$2(other._value, other.format.decimals);
+        return FixedNumber$2.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
     }
     floor() {
         const comps = this.toString().split(".");
         if (comps.length === 1) {
             comps.push("0");
         }
-        let result = FixedNumber$1.from(comps[0], this.format);
+        let result = FixedNumber$2.from(comps[0], this.format);
         const hasFraction = !comps[1].match(/^(0*)$/);
         if (this.isNegative() && hasFraction) {
-            result = result.subUnsafe(ONE$1.toFormat(result.format));
+            result = result.subUnsafe(ONE$2.toFormat(result.format));
         }
         return result;
     }
@@ -35317,10 +35317,10 @@ class FixedNumber$1 {
         if (comps.length === 1) {
             comps.push("0");
         }
-        let result = FixedNumber$1.from(comps[0], this.format);
+        let result = FixedNumber$2.from(comps[0], this.format);
         const hasFraction = !comps[1].match(/^(0*)$/);
         if (!this.isNegative() && hasFraction) {
-            result = result.addUnsafe(ONE$1.toFormat(result.format));
+            result = result.addUnsafe(ONE$2.toFormat(result.format));
         }
         return result;
     }
@@ -35340,8 +35340,8 @@ class FixedNumber$1 {
         if (comps[1].length <= decimals) {
             return this;
         }
-        const factor = FixedNumber$1.from("1" + zeros$1.substring(0, decimals), this.format);
-        const bump = BUMP$1.toFormat(this.format);
+        const factor = FixedNumber$2.from("1" + zeros$2.substring(0, decimals), this.format);
+        const bump = BUMP$2.toFormat(this.format);
         return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor);
     }
     isZero() {
@@ -35359,15 +35359,15 @@ class FixedNumber$1 {
             logger$o.throwArgumentError("invalid byte width", "width", width);
         }
         const hex = BigNumber$1$1.from(this._hex).fromTwos(this.format.width).toTwos(width).toHexString();
-        return hexZeroPad$1(hex, width / 8);
+        return hexZeroPad$2(hex, width / 8);
     }
     toUnsafeFloat() { return parseFloat(this.toString()); }
     toFormat(format) {
-        return FixedNumber$1.fromString(this._value, format);
+        return FixedNumber$2.fromString(this._value, format);
     }
     static fromValue(value, decimals, format) {
         // If decimals looks more like a format, and there is no format, shift the parameters
-        if (format == null && decimals != null && !isBigNumberish$1(decimals)) {
+        if (format == null && decimals != null && !isBigNumberish$2(decimals)) {
             format = decimals;
             decimals = null;
         }
@@ -35377,16 +35377,16 @@ class FixedNumber$1 {
         if (format == null) {
             format = "fixed";
         }
-        return FixedNumber$1.fromString(formatFixed$1(value, decimals), FixedFormat$1.from(format));
+        return FixedNumber$2.fromString(formatFixed$2(value, decimals), FixedFormat$2.from(format));
     }
     static fromString(value, format) {
         if (format == null) {
             format = "fixed";
         }
-        const fixedFormat = FixedFormat$1.from(format);
-        const numeric = parseFixed$1(value, fixedFormat.decimals);
+        const fixedFormat = FixedFormat$2.from(format);
+        const numeric = parseFixed$2(value, fixedFormat.decimals);
         if (!fixedFormat.signed && numeric.lt(Zero$2)) {
-            throwFault$1$1("unsigned value cannot be negative", "overflow", "value", value);
+            throwFault$1$2("unsigned value cannot be negative", "overflow", "value", value);
         }
         let hex = null;
         if (fixedFormat.signed) {
@@ -35394,17 +35394,17 @@ class FixedNumber$1 {
         }
         else {
             hex = numeric.toHexString();
-            hex = hexZeroPad$1(hex, fixedFormat.width / 8);
+            hex = hexZeroPad$2(hex, fixedFormat.width / 8);
         }
-        const decimal = formatFixed$1(numeric, fixedFormat.decimals);
-        return new FixedNumber$1(_constructorGuard$3, hex, decimal, fixedFormat);
+        const decimal = formatFixed$2(numeric, fixedFormat.decimals);
+        return new FixedNumber$2(_constructorGuard$3, hex, decimal, fixedFormat);
     }
     static fromBytes(value, format) {
         if (format == null) {
             format = "fixed";
         }
-        const fixedFormat = FixedFormat$1.from(format);
-        if (arrayify$1(value).length > fixedFormat.width / 8) {
+        const fixedFormat = FixedFormat$2.from(format);
+        if (arrayify$2(value).length > fixedFormat.width / 8) {
             throw new Error("overflow");
         }
         let numeric = BigNumber$1$1.from(value);
@@ -35412,18 +35412,18 @@ class FixedNumber$1 {
             numeric = numeric.fromTwos(fixedFormat.width);
         }
         const hex = numeric.toTwos((fixedFormat.signed ? 0 : 1) + fixedFormat.width).toHexString();
-        const decimal = formatFixed$1(numeric, fixedFormat.decimals);
-        return new FixedNumber$1(_constructorGuard$3, hex, decimal, fixedFormat);
+        const decimal = formatFixed$2(numeric, fixedFormat.decimals);
+        return new FixedNumber$2(_constructorGuard$3, hex, decimal, fixedFormat);
     }
     static from(value, format) {
         if (typeof (value) === "string") {
-            return FixedNumber$1.fromString(value, format);
+            return FixedNumber$2.fromString(value, format);
         }
         if (isBytes$2(value)) {
-            return FixedNumber$1.fromBytes(value, format);
+            return FixedNumber$2.fromBytes(value, format);
         }
         try {
-            return FixedNumber$1.fromValue(value, 0, format);
+            return FixedNumber$2.fromValue(value, 0, format);
         }
         catch (error) {
             // Allow NUMERIC_FAULT to bubble up
@@ -35437,8 +35437,8 @@ class FixedNumber$1 {
         return !!(value && value._isFixedNumber);
     }
 }
-const ONE$1 = FixedNumber$1.from(1);
-const BUMP$1 = FixedNumber$1.from("0.5");
+const ONE$2 = FixedNumber$2.from(1);
+const BUMP$2 = FixedNumber$2.from("0.5");
 
 const version$g = "properties/5.4.1";
 
@@ -36470,7 +36470,7 @@ class Writer {
     }
     // Arrayish items; padded on the right to wordSize
     writeBytes(value) {
-        let bytes = arrayify$1(value);
+        let bytes = arrayify$2(value);
         const paddingOffset = bytes.length % this.wordSize;
         if (paddingOffset) {
             bytes = concat([bytes, this._padding.slice(paddingOffset)]);
@@ -36478,7 +36478,7 @@ class Writer {
         return this._writeData(bytes);
     }
     _getValue(value) {
-        let bytes = arrayify$1(BigNumber$1$1.from(value));
+        let bytes = arrayify$2(BigNumber$1$1.from(value));
         if (bytes.length > this.wordSize) {
             logger$l.throwError("value out-of-bounds", Logger$2.errors.BUFFER_OVERRUN, {
                 length: this.wordSize,
@@ -36505,7 +36505,7 @@ class Writer {
 }
 class Reader {
     constructor(data, wordSize, coerceFunc, allowLoose) {
-        defineReadOnly(this, "_data", arrayify$1(data));
+        defineReadOnly(this, "_data", arrayify$2(data));
         defineReadOnly(this, "wordSize", wordSize || 32);
         defineReadOnly(this, "_coerceFunc", coerceFunc);
         defineReadOnly(this, "allowLoose", allowLoose);
@@ -37037,7 +37037,7 @@ var sha3$2 = createCommonjsModule$1$1(function (module) {
 var sha3$1$1 = sha3$2;
 
 function keccak256$1(data) {
-    return '0x' + sha3$1$1.keccak_256(arrayify$1(data));
+    return '0x' + sha3$1$1.keccak_256(arrayify$2(data));
 }
 
 const version$e = "rlp/5.4.0";
@@ -37075,7 +37075,7 @@ function _encode(object) {
     if (!isBytesLike(object)) {
         logger$k.throwArgumentError("RLP object must be BytesLike", "object", object);
     }
-    const data = Array.prototype.slice.call(arrayify$1(object));
+    const data = Array.prototype.slice.call(arrayify$2(object));
     if (data.length === 1 && data[0] <= 0x7f) {
         return data;
     }
@@ -37149,7 +37149,7 @@ function _decode(data, offset) {
     return { consumed: 1, result: hexlify$2(data[offset]) };
 }
 function decode$1(data) {
-    const bytes = arrayify$1(data);
+    const bytes = arrayify$2(data);
     const decoded = _decode(bytes, 0);
     if (decoded.consumed !== bytes.length) {
         logger$k.throwArgumentError("invalid rlp data", "data", data);
@@ -37170,7 +37170,7 @@ function getChecksumAddress$1(address) {
     for (let i = 0; i < 40; i++) {
         expanded[i] = chars[i].charCodeAt(0);
     }
-    const hashed = arrayify$1(keccak256$1(expanded));
+    const hashed = arrayify$2(keccak256$1(expanded));
     for (let i = 0; i < 40; i += 2) {
         if ((hashed[i >> 1] >> 4) >= 8) {
             chars[i] = chars[i].toUpperCase();
@@ -37257,7 +37257,7 @@ function getContractAddress(transaction) {
     catch (error) {
         logger$j.throwArgumentError("missing from address", "transaction", transaction);
     }
-    const nonce = stripZeros(arrayify$1(BigNumber$1$1.from(transaction.nonce).toHexString()));
+    const nonce = stripZeros(arrayify$2(BigNumber$1$1.from(transaction.nonce).toHexString()));
     return getAddress$1(hexDataSlice(keccak256$1(encode$2([from, nonce])), 12));
 }
 
@@ -37278,7 +37278,7 @@ class AddressCoder extends Coder {
         return writer.writeValue(value);
     }
     decode(reader) {
-        return getAddress$1(hexZeroPad$1(reader.readValue().toHexString(), 20));
+        return getAddress$1(hexZeroPad$2(reader.readValue().toHexString(), 20));
     }
 }
 
@@ -37526,7 +37526,7 @@ class DynamicBytesCoder extends Coder {
         return "0x";
     }
     encode(writer, value) {
-        value = arrayify$1(value);
+        value = arrayify$2(value);
         let length = writer.writeValue(value.length);
         length += writer.writeBytes(value);
         return length;
@@ -37555,7 +37555,7 @@ class FixedBytesCoder extends Coder {
         return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
     }
     encode(writer, value) {
-        let data = arrayify$1(value);
+        let data = arrayify$2(value);
         if (data.length !== this.size) {
             this._throwError("incorrect data length", value);
         }
@@ -37587,8 +37587,8 @@ class NullCoder extends Coder {
 
 const AddressZero = "0x0000000000000000000000000000000000000000";
 
-const NegativeOne$1 = ( /*#__PURE__*/BigNumber$1$1.from(-1));
-const Zero$1 = ( /*#__PURE__*/BigNumber$1$1.from(0));
+const NegativeOne$1$1 = ( /*#__PURE__*/BigNumber$1$1.from(-1));
+const Zero$1$1 = ( /*#__PURE__*/BigNumber$1$1.from(0));
 const One$1 = ( /*#__PURE__*/BigNumber$1$1.from(1));
 const MaxUint256$1 = ( /*#__PURE__*/BigNumber$1$1.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
 
@@ -37610,11 +37610,11 @@ class NumberCoder extends Coder {
         let maxUintValue = MaxUint256$1.mask(writer.wordSize * 8);
         if (this.signed) {
             let bounds = maxUintValue.mask(this.size * 8 - 1);
-            if (v.gt(bounds) || v.lt(bounds.add(One$1).mul(NegativeOne$1))) {
+            if (v.gt(bounds) || v.lt(bounds.add(One$1).mul(NegativeOne$1$1))) {
                 this._throwError("value out-of-bounds", value);
             }
         }
-        else if (v.lt(Zero$1) || v.gt(maxUintValue.mask(this.size * 8))) {
+        else if (v.lt(Zero$1$1) || v.gt(maxUintValue.mask(this.size * 8))) {
             this._throwError("value out-of-bounds", value);
         }
         v = v.toTwos(this.size * 8).mask(this.size * 8);
@@ -37716,7 +37716,7 @@ function getUtf8CodePoints(bytes, onError) {
     if (onError == null) {
         onError = Utf8ErrorFuncs.error;
     }
-    bytes = arrayify$1(bytes);
+    bytes = arrayify$2(bytes);
     const result = [];
     let i = 0;
     // Invalid bytes are ignored
@@ -37830,7 +37830,7 @@ function toUtf8Bytes(str, form = UnicodeNormalizationForm.current) {
             result.push((c & 0x3f) | 0x80);
         }
     }
-    return arrayify$1(result);
+    return arrayify$2(result);
 }
 function _toUtf8String(codePoints) {
     return codePoints.map((codePoint) => {
@@ -38178,7 +38178,7 @@ class AbiCoder {
     decode(types, data, loose) {
         const coders = types.map((type) => this._getCoder(ParamType.from(type)));
         const coder = new TupleCoder(coders, "_");
-        return coder.decode(this._getReader(arrayify$1(data), loose));
+        return coder.decode(this._getReader(arrayify$2(data), loose));
     }
 }
 const defaultAbiCoder = new AbiCoder();
@@ -38229,15 +38229,15 @@ const Zero$3 = BigNumber$1$1.from(0);
 const One = BigNumber$1$1.from(1);
 const MaxUint256 = BigNumber$1$1.from("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 function hexPadRight(value) {
-    const bytes = arrayify$1(value);
+    const bytes = arrayify$2(value);
     const padOffset = bytes.length % 32;
     if (padOffset) {
         return hexConcat([bytes, padding.slice(padOffset)]);
     }
     return hexlify$2(bytes);
 }
-const hexTrue = hexZeroPad$1(One.toHexString(), 32);
-const hexFalse = hexZeroPad$1(Zero$3.toHexString(), 32);
+const hexTrue = hexZeroPad$2(One.toHexString(), 32);
+const hexFalse = hexZeroPad$2(Zero$3.toHexString(), 32);
 const domainFieldTypes = {
     name: "string",
     version: "string",
@@ -38275,7 +38275,7 @@ const domainChecks = {
     },
     salt: function (value) {
         try {
-            const bytes = arrayify$1(value);
+            const bytes = arrayify$2(value);
             if (bytes.length !== 32) {
                 throw new Error("bad length");
             }
@@ -38302,7 +38302,7 @@ function getBaseEncoder(type) {
                 if (v.lt(boundsLower) || v.gt(boundsUpper)) {
                     logger$e.throwArgumentError(`value out-of-bounds for ${type}`, "value", value);
                 }
-                return hexZeroPad$1(v.toTwos(256).toHexString(), 32);
+                return hexZeroPad$2(v.toTwos(256).toHexString(), 32);
             };
         }
     }
@@ -38315,7 +38315,7 @@ function getBaseEncoder(type) {
                 logger$e.throwArgumentError("invalid bytes width", "type", type);
             }
             return function (value) {
-                const bytes = arrayify$1(value);
+                const bytes = arrayify$2(value);
                 if (bytes.length !== width) {
                     logger$e.throwArgumentError(`invalid length for ${type}`, "value", value);
                 }
@@ -38325,7 +38325,7 @@ function getBaseEncoder(type) {
     }
     switch (type) {
         case "address": return function (value) {
-            return hexZeroPad$1(getAddress$1(value), 32);
+            return hexZeroPad$2(getAddress$1(value), 32);
         };
         case "bool": return function (value) {
             return ((!value) ? hexFalse : hexTrue);
@@ -38622,7 +38622,7 @@ class TypedDataEncoder {
             message: encoder.visit(value, (type, value) => {
                 // bytes
                 if (type.match(/^bytes(\d*)/)) {
-                    return hexlify$2(arrayify$1(value));
+                    return hexlify$2(arrayify$2(value));
                 }
                 // uint or int
                 if (type.match(/^u?int/)) {
@@ -38894,7 +38894,7 @@ class Interface {
         if (typeof (fragment) === "string") {
             fragment = this.getError(fragment);
         }
-        const bytes = arrayify$1(data);
+        const bytes = arrayify$2(data);
         if (hexlify$2(bytes.slice(0, 4)) !== this.getSighash(fragment)) {
             logger$d.throwArgumentError(`data signature does not match error ${fragment.name}.`, "data", hexlify$2(bytes));
         }
@@ -38914,7 +38914,7 @@ class Interface {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
-        const bytes = arrayify$1(data);
+        const bytes = arrayify$2(data);
         if (hexlify$2(bytes.slice(0, 4)) !== this.getSighash(functionFragment)) {
             logger$d.throwArgumentError(`data signature does not match function ${functionFragment.name}.`, "data", hexlify$2(bytes));
         }
@@ -38935,7 +38935,7 @@ class Interface {
         if (typeof (functionFragment) === "string") {
             functionFragment = this.getFunction(functionFragment);
         }
-        let bytes = arrayify$1(data);
+        let bytes = arrayify$2(data);
         let reason = null;
         let errorArgs = null;
         let errorName = null;
@@ -39010,7 +39010,7 @@ class Interface {
             if (param.type === "address") {
                 this._abiCoder.encode(["address"], [value]);
             }
-            return hexZeroPad$1(hexlify$2(value), 32);
+            return hexZeroPad$2(hexlify$2(value), 32);
         };
         values.forEach((value, index) => {
             let param = eventFragment.inputs[index];
@@ -43311,33 +43311,33 @@ class SigningKey {
     constructor(privateKey) {
         defineReadOnly(this, "curve", "secp256k1");
         defineReadOnly(this, "privateKey", hexlify$2(privateKey));
-        const keyPair = getCurve().keyFromPrivate(arrayify$1(this.privateKey));
+        const keyPair = getCurve().keyFromPrivate(arrayify$2(this.privateKey));
         defineReadOnly(this, "publicKey", "0x" + keyPair.getPublic(false, "hex"));
         defineReadOnly(this, "compressedPublicKey", "0x" + keyPair.getPublic(true, "hex"));
         defineReadOnly(this, "_isSigningKey", true);
     }
     _addPoint(other) {
-        const p0 = getCurve().keyFromPublic(arrayify$1(this.publicKey));
-        const p1 = getCurve().keyFromPublic(arrayify$1(other));
+        const p0 = getCurve().keyFromPublic(arrayify$2(this.publicKey));
+        const p1 = getCurve().keyFromPublic(arrayify$2(other));
         return "0x" + p0.pub.add(p1.pub).encodeCompressed("hex");
     }
     signDigest(digest) {
-        const keyPair = getCurve().keyFromPrivate(arrayify$1(this.privateKey));
-        const digestBytes = arrayify$1(digest);
+        const keyPair = getCurve().keyFromPrivate(arrayify$2(this.privateKey));
+        const digestBytes = arrayify$2(digest);
         if (digestBytes.length !== 32) {
             logger$a.throwArgumentError("bad digest length", "digest", digest);
         }
         const signature = keyPair.sign(digestBytes, { canonical: true });
         return splitSignature({
             recoveryParam: signature.recoveryParam,
-            r: hexZeroPad$1("0x" + signature.r.toString(16), 32),
-            s: hexZeroPad$1("0x" + signature.s.toString(16), 32),
+            r: hexZeroPad$2("0x" + signature.r.toString(16), 32),
+            s: hexZeroPad$2("0x" + signature.s.toString(16), 32),
         });
     }
     computeSharedSecret(otherKey) {
-        const keyPair = getCurve().keyFromPrivate(arrayify$1(this.privateKey));
-        const otherKeyPair = getCurve().keyFromPublic(arrayify$1(computePublicKey(otherKey)));
-        return hexZeroPad$1("0x" + keyPair.derive(otherKeyPair.getPublic()).toString(16), 32);
+        const keyPair = getCurve().keyFromPrivate(arrayify$2(this.privateKey));
+        const otherKeyPair = getCurve().keyFromPublic(arrayify$2(computePublicKey(otherKey)));
+        return hexZeroPad$2("0x" + keyPair.derive(otherKeyPair.getPublic()).toString(16), 32);
     }
     static isSigningKey(value) {
         return !!(value && value._isSigningKey);
@@ -43345,11 +43345,11 @@ class SigningKey {
 }
 function recoverPublicKey(digest, signature) {
     const sig = splitSignature(signature);
-    const rs = { r: arrayify$1(sig.r), s: arrayify$1(sig.s) };
-    return "0x" + getCurve().recoverPubKey(arrayify$1(digest), rs, sig.recoveryParam).encode("hex", false);
+    const rs = { r: arrayify$2(sig.r), s: arrayify$2(sig.s) };
+    return "0x" + getCurve().recoverPubKey(arrayify$2(digest), rs, sig.recoveryParam).encode("hex", false);
 }
 function computePublicKey(key, compressed) {
-    const bytes = arrayify$1(key);
+    const bytes = arrayify$2(key);
     if (bytes.length === 32) {
         const signingKey = new SigningKey(bytes);
         if (compressed) {
@@ -43390,7 +43390,7 @@ function handleAddress(value) {
 }
 function handleNumber(value) {
     if (value === "0x") {
-        return Zero$1;
+        return Zero$1$1;
     }
     return BigNumber$1$1.from(value);
 }
@@ -43399,7 +43399,7 @@ function computeAddress(key) {
     return getAddress$1(hexDataSlice(keccak256$1(hexDataSlice(publicKey, 1)), 12));
 }
 function recoverAddress(digest, signature) {
-    return computeAddress(recoverPublicKey(arrayify$1(digest), signature));
+    return computeAddress(recoverPublicKey(arrayify$2(digest), signature));
 }
 function formatNumber(value, name) {
     const result = stripZeros(BigNumber$1$1.from(value).toHexString());
@@ -43506,8 +43506,8 @@ function _parseEipSignature(tx, fields, serialize) {
     catch (error) {
         logger$9.throwArgumentError("invalid v for transaction type: 1", "v", fields[0]);
     }
-    tx.r = hexZeroPad$1(fields[1], 32);
-    tx.s = hexZeroPad$1(fields[2], 32);
+    tx.r = hexZeroPad$2(fields[1], 32);
+    tx.s = hexZeroPad$2(fields[2], 32);
     try {
         const digest = keccak256$1(serialize(tx));
         tx.from = recoverAddress(digest, { r: tx.r, s: tx.s, recoveryParam: tx.v });
@@ -43594,8 +43594,8 @@ function _parse(rawTransaction) {
         console.log(error);
         return tx;
     }
-    tx.r = hexZeroPad$1(transaction[7], 32);
-    tx.s = hexZeroPad$1(transaction[8], 32);
+    tx.r = hexZeroPad$2(transaction[7], 32);
+    tx.s = hexZeroPad$2(transaction[8], 32);
     if (BigNumber$1$1.from(tx.r).isZero() && BigNumber$1$1.from(tx.s).isZero()) {
         // EIP-155 unsigned transaction
         tx.chainId = tx.v;
@@ -43628,7 +43628,7 @@ function _parse(rawTransaction) {
     return tx;
 }
 function parse(rawTransaction) {
-    const payload = arrayify$1(rawTransaction);
+    const payload = arrayify$2(rawTransaction);
     // Legacy and EIP-155 Transactions
     if (payload[0] > 0x7f) {
         return _parse(payload);
@@ -43785,7 +43785,7 @@ function populateTransaction(contract, fragment, args) {
             // is always a non-nil to address, we can ignore G_create, but may wish to add
             // similar logic to the ContractFactory.
             let intrinsic = 21000;
-            const bytes = arrayify$1(data);
+            const bytes = arrayify$2(data);
             for (let i = 0; i < bytes.length; i++) {
                 intrinsic += 4;
                 if (bytes[i]) {
@@ -44512,14 +44512,14 @@ const version$5$1 = "bignumber/5.4.2";
 
 var BN$2 = bn$2.BN;
 const logger$7 = new Logger$2(version$5$1);
-const _constructorGuard$1$1 = {};
+const _constructorGuard$1$2 = {};
 const MAX_SAFE$2 = 0x1fffffffffffff;
 // Only warn about passing 10 into radix once
 let _warnedToStringRadix$2 = false;
 class BigNumber$2 {
     constructor(constructorGuard, hex) {
         logger$7.checkNew(new.target, BigNumber$2);
-        if (constructorGuard !== _constructorGuard$1$1) {
+        if (constructorGuard !== _constructorGuard$1$2) {
             logger$7.throwError("cannot call constructor directly; use BigNumber.from", Logger$2.errors.UNSUPPORTED_OPERATION, {
                 operation: "new (BigNumber)"
             });
@@ -44678,10 +44678,10 @@ class BigNumber$2 {
         }
         if (typeof (value) === "string") {
             if (value.match(/^-?0x[0-9a-f]+$/i)) {
-                return new BigNumber$2(_constructorGuard$1$1, toHex$3(value));
+                return new BigNumber$2(_constructorGuard$1$2, toHex$3(value));
             }
             if (value.match(/^-?[0-9]+$/)) {
-                return new BigNumber$2(_constructorGuard$1$1, toHex$3(new BN$2(value)));
+                return new BigNumber$2(_constructorGuard$1$2, toHex$3(new BN$2(value)));
             }
             return logger$7.throwArgumentError("invalid BigNumber string", "value", value);
         }
@@ -44839,7 +44839,7 @@ class BaseX {
         }
     }
     encode(value) {
-        let source = arrayify$1(value);
+        let source = arrayify$2(value);
         if (source.length === 0) {
             return "";
         }
@@ -44896,7 +44896,7 @@ class BaseX {
         for (let k = 0; value[k] === this._leader && k < value.length - 1; ++k) {
             bytes.push(0);
         }
-        return arrayify$1(new Uint8Array(bytes.reverse()));
+        return arrayify$2(new Uint8Array(bytes.reverse()));
     }
 }
 new BaseX("abcdefghijklmnopqrstuvwxyz234567");
@@ -44908,12 +44908,12 @@ const version$4$1 = "sha2/5.4.0";
 
 new Logger$2(version$4$1);
 function sha256(data) {
-    return "0x" + (hash.sha256().update(arrayify$1(data)).digest("hex"));
+    return "0x" + (hash.sha256().update(arrayify$2(data)).digest("hex"));
 }
 
-const version$3$1 = "networks/5.4.2";
+const version$3$2 = "networks/5.4.2";
 
-const logger$6 = new Logger$2(version$3$1);
+const logger$6 = new Logger$2(version$3$2);
 function isRenetworkable(value) {
     return (value && typeof (value.renetwork) === "function");
 }
@@ -45127,7 +45127,7 @@ function getNetwork(network) {
 }
 
 function encode$1(data) {
-    data = arrayify$1(data);
+    data = arrayify$2(data);
     let textData = "";
     for (let i = 0; i < data.length; i++) {
         textData += String.fromCharCode(data[i]);
@@ -45178,7 +45178,7 @@ function getUrl(href, options) {
             headers: headers,
             statusCode: response.status,
             statusMessage: response.statusText,
-            body: arrayify$1(new Uint8Array(body)),
+            body: arrayify$2(new Uint8Array(body)),
         };
     });
 }
@@ -45944,7 +45944,7 @@ class Formatter {
         if (!isHexString$2(value)) {
             throw new Error("invalid uint256");
         }
-        return hexZeroPad$1(value, 32);
+        return hexZeroPad$2(value, 32);
     }
     _block(value, format) {
         if (value.author != null && value.miner == null) {
@@ -46127,7 +46127,7 @@ var __awaiter$1 = function (thisArg, _arguments, P, generator) {
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const logger$3$1 = new Logger$2(version$1$2);
+const logger$3$2 = new Logger$2(version$1$2);
 //////////////////////////////
 // Event Serializeing
 function checkTopic(topic) {
@@ -46135,7 +46135,7 @@ function checkTopic(topic) {
         return "null";
     }
     if (hexDataLength(topic) !== 32) {
-        logger$3$1.throwArgumentError("invalid topic", "topic", topic);
+        logger$3$2.throwArgumentError("invalid topic", "topic", topic);
     }
     return topic.toLowerCase();
 }
@@ -46190,7 +46190,7 @@ function getEventTag(eventName) {
         return "filter:*:" + serializeTopics(eventName);
     }
     else if (ForkEvent.isForkEvent(eventName)) {
-        logger$3$1.warn("not implemented");
+        logger$3$2.warn("not implemented");
         throw new Error("not implemented");
     }
     else if (eventName && typeof (eventName) === "object") {
@@ -46278,7 +46278,7 @@ const coinInfos = {
     "700": { symbol: "xdai", ilk: "eth" },
 };
 function bytes32ify(value) {
-    return hexZeroPad$1(BigNumber$1$1.from(value).toHexString(), 32);
+    return hexZeroPad$2(BigNumber$1$1.from(value).toHexString(), 32);
 }
 // Compute the Base58Check encoded data (checksum is first 4 bytes of sha256d)
 function base58Encode(data) {
@@ -46317,14 +46317,14 @@ class Resolver {
     _getAddress(coinType, hexBytes) {
         const coinInfo = coinInfos[String(coinType)];
         if (coinInfo == null) {
-            logger$3$1.throwError(`unsupported coin type: ${coinType}`, Logger$2.errors.UNSUPPORTED_OPERATION, {
+            logger$3$2.throwError(`unsupported coin type: ${coinType}`, Logger$2.errors.UNSUPPORTED_OPERATION, {
                 operation: `getAddress(${coinType})`
             });
         }
         if (coinInfo.ilk === "eth") {
             return this.provider.formatter.address(hexBytes);
         }
-        const bytes = arrayify$1(hexBytes);
+        const bytes = arrayify$2(hexBytes);
         // P2PKH: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG
         if (coinInfo.p2pkh != null) {
             const p2pkh = hexBytes.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/);
@@ -46402,7 +46402,7 @@ class Resolver {
             // Compute the address
             const address = this._getAddress(coinType, hexBytes);
             if (address == null) {
-                logger$3$1.throwError(`invalid or unsupported coin data`, Logger$2.errors.UNSUPPORTED_OPERATION, {
+                logger$3$2.throwError(`invalid or unsupported coin data`, Logger$2.errors.UNSUPPORTED_OPERATION, {
                     operation: `getAddress(${coinType})`,
                     coinType: coinType,
                     data: hexBytes
@@ -46434,7 +46434,7 @@ class Resolver {
                     return "bzz:/\/" + swarm[1];
                 }
             }
-            return logger$3$1.throwError(`invalid or unsupported content hash data`, Logger$2.errors.UNSUPPORTED_OPERATION, {
+            return logger$3$2.throwError(`invalid or unsupported content hash data`, Logger$2.errors.UNSUPPORTED_OPERATION, {
                 operation: "getContentHash()",
                 data: hexBytes
             });
@@ -46449,7 +46449,7 @@ class Resolver {
             keyBytes = concat([bytes32ify(64), bytes32ify(keyBytes.length), keyBytes]);
             // Pad to word-size (32 bytes)
             if ((keyBytes.length % 32) !== 0) {
-                keyBytes = concat([keyBytes, hexZeroPad$1("0x", 32 - (key.length % 32))]);
+                keyBytes = concat([keyBytes, hexZeroPad$2("0x", 32 - (key.length % 32))]);
             }
             const hexBytes = yield this._fetchBytes("0x59d1d43c", hexlify$2(keyBytes));
             if (hexBytes == null || hexBytes === "0x") {
@@ -46472,7 +46472,7 @@ class BaseProvider extends Provider {
      *
      */
     constructor(network) {
-        logger$3$1.checkNew(new.target, Provider);
+        logger$3$2.checkNew(new.target, Provider);
         super();
         // Events being listened to
         this._events = [];
@@ -46499,7 +46499,7 @@ class BaseProvider extends Provider {
                 this.emit("network", knownNetwork, null);
             }
             else {
-                logger$3$1.throwArgumentError("invalid network", "network", network);
+                logger$3$2.throwArgumentError("invalid network", "network", network);
             }
         }
         this._maxInternalBlockNumber = -1024;
@@ -46524,7 +46524,7 @@ class BaseProvider extends Provider {
                 // This should never happen; every Provider sub-class should have
                 // suggested a network by here (or have thrown).
                 if (!network) {
-                    logger$3$1.throwError("no network detected", Logger$2.errors.UNKNOWN_ERROR, {});
+                    logger$3$2.throwError("no network detected", Logger$2.errors.UNKNOWN_ERROR, {});
                 }
                 // Possible this call stacked so do not call defineReadOnly again
                 if (this._network == null) {
@@ -46656,8 +46656,8 @@ class BaseProvider extends Provider {
                 this._emitted.block = blockNumber - 1;
             }
             if (Math.abs((this._emitted.block) - blockNumber) > 1000) {
-                logger$3$1.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
-                this.emit("error", logger$3$1.makeError("network block skew detected", Logger$2.errors.NETWORK_ERROR, {
+                logger$3$2.warn(`network block skew detected; skipping block events (emitted=${this._emitted.block} blockNumber${blockNumber})`);
+                this.emit("error", logger$3$2.makeError("network block skew detected", Logger$2.errors.NETWORK_ERROR, {
                     blockNumber: blockNumber,
                     event: "blockSkew",
                     previousBlockNumber: this._emitted.block
@@ -46754,7 +46754,7 @@ class BaseProvider extends Provider {
     // can change, such as when connected to a JSON-RPC backend
     detectNetwork() {
         return __awaiter$1(this, void 0, void 0, function* () {
-            return logger$3$1.throwError("provider does not support network detection", Logger$2.errors.UNSUPPORTED_OPERATION, {
+            return logger$3$2.throwError("provider does not support network detection", Logger$2.errors.UNSUPPORTED_OPERATION, {
                 operation: "provider.detectNetwork"
             });
         });
@@ -46786,7 +46786,7 @@ class BaseProvider extends Provider {
                     yield stall(0);
                     return this._network;
                 }
-                const error = logger$3$1.makeError("underlying network changed", Logger$2.errors.NETWORK_ERROR, {
+                const error = logger$3$2.makeError("underlying network changed", Logger$2.errors.NETWORK_ERROR, {
                     event: "changed",
                     network: network,
                     detectedNetwork: currentNetwork
@@ -46973,7 +46973,7 @@ class BaseProvider extends Provider {
                                                 reason = "cancelled";
                                             }
                                             // Explain why we were replaced
-                                            reject(logger$3$1.makeError("transaction was replaced", Logger$2.errors.TRANSACTION_REPLACED, {
+                                            reject(logger$3$2.makeError("transaction was replaced", Logger$2.errors.TRANSACTION_REPLACED, {
                                                 cancelled: (reason === "replaced" || reason === "cancelled"),
                                                 reason,
                                                 replacement: this._wrapTransaction(tx),
@@ -47010,7 +47010,7 @@ class BaseProvider extends Provider {
                         if (alreadyDone()) {
                             return;
                         }
-                        reject(logger$3$1.makeError("timeout exceeded", Logger$2.errors.TIMEOUT, { timeout: timeout }));
+                        reject(logger$3$2.makeError("timeout exceeded", Logger$2.errors.TIMEOUT, { timeout: timeout }));
                     }, timeout);
                     if (timer.unref) {
                         timer.unref();
@@ -47033,7 +47033,7 @@ class BaseProvider extends Provider {
                 return BigNumber$1$1.from(result);
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "getGasPrice",
                     result, error
                 });
@@ -47052,7 +47052,7 @@ class BaseProvider extends Provider {
                 return BigNumber$1$1.from(result);
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "getBalance",
                     params, result, error
                 });
@@ -47071,7 +47071,7 @@ class BaseProvider extends Provider {
                 return BigNumber$1$1.from(result).toNumber();
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "getTransactionCount",
                     params, result, error
                 });
@@ -47090,7 +47090,7 @@ class BaseProvider extends Provider {
                 return hexlify$2(result);
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "getCode",
                     params, result, error
                 });
@@ -47110,7 +47110,7 @@ class BaseProvider extends Provider {
                 return hexlify$2(result);
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "getStorageAt",
                     params, result, error
                 });
@@ -47125,7 +47125,7 @@ class BaseProvider extends Provider {
         const result = tx;
         // Check the hash we expect is the same as the hash the server reported
         if (hash != null && tx.hash !== hash) {
-            logger$3$1.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger$2.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
+            logger$3$2.throwError("Transaction hash mismatch from Provider.sendTransaction.", Logger$2.errors.UNKNOWN_ERROR, { expectedHash: tx.hash, returnedHash: hash });
         }
         result.wait = (confirms, timeout) => __awaiter$1(this, void 0, void 0, function* () {
             if (confirms == null) {
@@ -47153,7 +47153,7 @@ class BaseProvider extends Provider {
             // No longer pending, allow the polling loop to garbage collect this
             this._emitted["t:" + tx.hash] = receipt.blockNumber;
             if (receipt.status === 0) {
-                logger$3$1.throwError("transaction failed", Logger$2.errors.CALL_EXCEPTION, {
+                logger$3$2.throwError("transaction failed", Logger$2.errors.CALL_EXCEPTION, {
                     transactionHash: tx.hash,
                     transaction: tx,
                     receipt: receipt
@@ -47251,7 +47251,7 @@ class BaseProvider extends Provider {
                 return hexlify$2(result);
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "call",
                     params, result, error
                 });
@@ -47269,7 +47269,7 @@ class BaseProvider extends Provider {
                 return BigNumber$1$1.from(result);
             }
             catch (error) {
-                return logger$3$1.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
+                return logger$3$2.throwError("bad result from backend", Logger$2.errors.SERVER_ERROR, {
                     method: "estimateGas",
                     params, result, error
                 });
@@ -47280,7 +47280,7 @@ class BaseProvider extends Provider {
         return __awaiter$1(this, void 0, void 0, function* () {
             const address = yield this.resolveName(addressOrName);
             if (address == null) {
-                logger$3$1.throwError("ENS name not configured", Logger$2.errors.UNSUPPORTED_OPERATION, {
+                logger$3$2.throwError("ENS name not configured", Logger$2.errors.UNSUPPORTED_OPERATION, {
                     operation: `resolveName(${JSON.stringify(addressOrName)})`
                 });
             }
@@ -47307,7 +47307,7 @@ class BaseProvider extends Provider {
                     }
                 }
                 catch (error) {
-                    logger$3$1.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
+                    logger$3$2.throwArgumentError("invalid block hash or block tag", "blockHashOrBlockTag", blockHashOrBlockTag);
                 }
             }
             return poll(() => __awaiter$1(this, void 0, void 0, function* () {
@@ -47453,7 +47453,7 @@ class BaseProvider extends Provider {
             blockTag = yield blockTag;
             if (typeof (blockTag) === "number" && blockTag < 0) {
                 if (blockTag % 1) {
-                    logger$3$1.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
+                    logger$3$2.throwArgumentError("invalid BlockTag", "blockTag", blockTag);
                 }
                 let blockNumber = yield this._getInternalBlockNumber(100 + 2 * this.pollingInterval);
                 blockNumber += blockTag;
@@ -47488,7 +47488,7 @@ class BaseProvider extends Provider {
             const network = yield this.getNetwork();
             // No ENS...
             if (!network.ensAddress) {
-                logger$3$1.throwError("network does not support ENS", Logger$2.errors.UNSUPPORTED_OPERATION, { operation: "ENS", network: network.name });
+                logger$3$2.throwError("network does not support ENS", Logger$2.errors.UNSUPPORTED_OPERATION, { operation: "ENS", network: network.name });
             }
             // keccak256("resolver(bytes32)")
             const transaction = {
@@ -47520,7 +47520,7 @@ class BaseProvider extends Provider {
                 }
             }
             if (typeof (name) !== "string") {
-                logger$3$1.throwArgumentError("invalid ENS name", "name", name);
+                logger$3$2.throwArgumentError("invalid ENS name", "name", name);
             }
             // Get the addr from the resovler
             const resolver = yield this.getResolver(name);
@@ -47540,7 +47540,7 @@ class BaseProvider extends Provider {
                 return null;
             }
             // keccak("name(bytes32)")
-            let bytes = arrayify$1(yield this.call({
+            let bytes = arrayify$2(yield this.call({
                 to: resolverAddress,
                 data: ("0x691f3431" + namehash(reverseName).substring(2))
             }));
@@ -47570,7 +47570,7 @@ class BaseProvider extends Provider {
         });
     }
     perform(method, params) {
-        return logger$3$1.throwError(method + " not implemented", Logger$2.errors.NOT_IMPLEMENTED, { operation: method });
+        return logger$3$2.throwError(method + " not implemented", Logger$2.errors.NOT_IMPLEMENTED, { operation: method });
     }
     _startEvent(event) {
         this.polling = (this._events.filter((e) => e.pollable()).length > 0);
@@ -47680,7 +47680,7 @@ var __awaiter = function (thisArg, _arguments, P, generator) {
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-const logger$2$1 = new Logger$2(version$1$2);
+const logger$2$2 = new Logger$2(version$1$2);
 const errorGas = ["call", "estimateGas"];
 function checkError(method, error, params) {
     // Undo the "convenience" some nodes are attempting to prevent backwards
@@ -47690,7 +47690,7 @@ function checkError(method, error, params) {
         if (e && e.message.match("reverted") && isHexString$2(e.data)) {
             return e.data;
         }
-        logger$2$1.throwError("missing revert data in call exception", Logger$2.errors.CALL_EXCEPTION, {
+        logger$2$2.throwError("missing revert data in call exception", Logger$2.errors.CALL_EXCEPTION, {
             error, data: "0x"
         });
     }
@@ -47708,30 +47708,30 @@ function checkError(method, error, params) {
     const transaction = params.transaction || params.signedTransaction;
     // "insufficient funds for gas * price + value + cost(data)"
     if (message.match(/insufficient funds|base fee exceeds gas limit/)) {
-        logger$2$1.throwError("insufficient funds for intrinsic transaction cost", Logger$2.errors.INSUFFICIENT_FUNDS, {
+        logger$2$2.throwError("insufficient funds for intrinsic transaction cost", Logger$2.errors.INSUFFICIENT_FUNDS, {
             error, method, transaction
         });
     }
     // "nonce too low"
     if (message.match(/nonce too low/)) {
-        logger$2$1.throwError("nonce has already been used", Logger$2.errors.NONCE_EXPIRED, {
+        logger$2$2.throwError("nonce has already been used", Logger$2.errors.NONCE_EXPIRED, {
             error, method, transaction
         });
     }
     // "replacement transaction underpriced"
     if (message.match(/replacement transaction underpriced/)) {
-        logger$2$1.throwError("replacement fee too low", Logger$2.errors.REPLACEMENT_UNDERPRICED, {
+        logger$2$2.throwError("replacement fee too low", Logger$2.errors.REPLACEMENT_UNDERPRICED, {
             error, method, transaction
         });
     }
     // "replacement transaction underpriced"
     if (message.match(/only replay-protected/)) {
-        logger$2$1.throwError("legacy pre-eip-155 transactions not supported", Logger$2.errors.UNSUPPORTED_OPERATION, {
+        logger$2$2.throwError("legacy pre-eip-155 transactions not supported", Logger$2.errors.UNSUPPORTED_OPERATION, {
             error, method, transaction
         });
     }
     if (errorGas.indexOf(method) >= 0 && message.match(/gas required exceeds allowance|always failing transaction|execution reverted/)) {
-        logger$2$1.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger$2.errors.UNPREDICTABLE_GAS_LIMIT, {
+        logger$2$2.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger$2.errors.UNPREDICTABLE_GAS_LIMIT, {
             error, method, transaction
         });
     }
@@ -47761,7 +47761,7 @@ function getLowerCase(value) {
 const _constructorGuard$5 = {};
 class JsonRpcSigner extends Signer {
     constructor(constructorGuard, provider, addressOrIndex) {
-        logger$2$1.checkNew(new.target, JsonRpcSigner);
+        logger$2$2.checkNew(new.target, JsonRpcSigner);
         super();
         if (constructorGuard !== _constructorGuard$5) {
             throw new Error("do not call the JsonRpcSigner constructor directly; use provider.getSigner");
@@ -47779,11 +47779,11 @@ class JsonRpcSigner extends Signer {
             defineReadOnly(this, "_address", null);
         }
         else {
-            logger$2$1.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
+            logger$2$2.throwArgumentError("invalid address or index", "addressOrIndex", addressOrIndex);
         }
     }
     connect(provider) {
-        return logger$2$1.throwError("cannot alter JSON-RPC Signer connection", Logger$2.errors.UNSUPPORTED_OPERATION, {
+        return logger$2$2.throwError("cannot alter JSON-RPC Signer connection", Logger$2.errors.UNSUPPORTED_OPERATION, {
             operation: "connect"
         });
     }
@@ -47796,7 +47796,7 @@ class JsonRpcSigner extends Signer {
         }
         return this.provider.send("eth_accounts", []).then((accounts) => {
             if (accounts.length <= this._index) {
-                logger$2$1.throwError("unknown account #" + this._index, Logger$2.errors.UNSUPPORTED_OPERATION, {
+                logger$2$2.throwError("unknown account #" + this._index, Logger$2.errors.UNSUPPORTED_OPERATION, {
                     operation: "getAddress"
                 });
             }
@@ -47826,7 +47826,7 @@ class JsonRpcSigner extends Signer {
                 }
                 const address = yield this.provider.resolveName(to);
                 if (address == null) {
-                    logger$2$1.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
+                    logger$2$2.throwArgumentError("provided ENS name resolves to null", "tx.to", to);
                 }
                 return address;
             }));
@@ -47837,7 +47837,7 @@ class JsonRpcSigner extends Signer {
         }).then(({ tx, sender }) => {
             if (tx.from != null) {
                 if (tx.from.toLowerCase() !== sender) {
-                    logger$2$1.throwArgumentError("from address mismatch", "transaction", transaction);
+                    logger$2$2.throwArgumentError("from address mismatch", "transaction", transaction);
                 }
             }
             else {
@@ -47852,7 +47852,7 @@ class JsonRpcSigner extends Signer {
         });
     }
     signTransaction(transaction) {
-        return logger$2$1.throwError("signing transactions is unsupported", Logger$2.errors.UNSUPPORTED_OPERATION, {
+        return logger$2$2.throwError("signing transactions is unsupported", Logger$2.errors.UNSUPPORTED_OPERATION, {
             operation: "signTransaction"
         });
     }
@@ -47934,7 +47934,7 @@ const allowedTransactionKeys = {
 };
 class JsonRpcProvider extends BaseProvider {
     constructor(url, network) {
-        logger$2$1.checkNew(new.target, JsonRpcProvider);
+        logger$2$2.checkNew(new.target, JsonRpcProvider);
         let networkOrReady = network;
         // The network is unknown, query the JSON-RPC for it
         if (networkOrReady == null) {
@@ -48001,14 +48001,14 @@ class JsonRpcProvider extends BaseProvider {
                     return getNetwork(BigNumber$1$1.from(chainId).toNumber());
                 }
                 catch (error) {
-                    return logger$2$1.throwError("could not detect network", Logger$2.errors.NETWORK_ERROR, {
+                    return logger$2$2.throwError("could not detect network", Logger$2.errors.NETWORK_ERROR, {
                         chainId: chainId,
                         event: "invalidNetwork",
                         serverError: error
                     });
                 }
             }
-            return logger$2$1.throwError("could not detect network", Logger$2.errors.NETWORK_ERROR, {
+            return logger$2$2.throwError("could not detect network", Logger$2.errors.NETWORK_ERROR, {
                 event: "noNetwork"
             });
         });
@@ -48133,7 +48133,7 @@ class JsonRpcProvider extends BaseProvider {
             }
             const args = this.prepareRequest(method, params);
             if (args == null) {
-                logger$2$1.throwError(method + " not implemented", Logger$2.errors.NOT_IMPLEMENTED, { operation: method });
+                logger$2$2.throwError(method + " not implemented", Logger$2.errors.NOT_IMPLEMENTED, { operation: method });
             }
             try {
                 return yield this.send(args[0], args[1]);
@@ -48382,7 +48382,7 @@ class Web3Provider extends JsonRpcProvider {
 const version$k = "units/5.4.0";
 
 const logger$r = new Logger$2(version$k);
-const names$1 = [
+const names$2 = [
     "wei",
     "kwei",
     "mwei",
@@ -48391,17 +48391,17 @@ const names$1 = [
     "finney",
     "ether",
 ];
-function parseUnits$1(value, unitName) {
+function parseUnits$2(value, unitName) {
     if (typeof (value) !== "string") {
         logger$r.throwArgumentError("value must be a string", "value", value);
     }
     if (typeof (unitName) === "string") {
-        const index = names$1.indexOf(unitName);
+        const index = names$2.indexOf(unitName);
         if (index !== -1) {
             unitName = 3 * index;
         }
     }
-    return parseFixed$1(value, (unitName != null) ? unitName : 18);
+    return parseFixed$2(value, (unitName != null) ? unitName : 18);
 }
 
 function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
@@ -48432,7 +48432,7 @@ class Transaction {
 
   static bigNumberify(value, blockchain) {
     if (typeof value === 'number') {
-      return parseUnits$1(value.toString(), CONSTANTS$2[blockchain].DECIMALS)
+      return parseUnits$2(value.toString(), CONSTANTS$2[blockchain].DECIMALS)
     } else if (value && value.toString) {
       return BigNumber$2.from(value.toString())
     } else {
@@ -55408,7 +55408,7 @@ class Token {
 
   async BigNumber(amount) {
     let decimals = await this.decimals();
-    return parseUnits$2(
+    return parseUnits$3(
       Token.safeAmount({ amount: parseFloat(amount), decimals }).toString(),
       decimals
     )
@@ -59415,20 +59415,20 @@ class Logger$1 {
 Logger$1.errors = ErrorCode$1;
 Logger$1.levels = LogLevel$1;
 
-const version$3 = "bytes/5.4.0";
+const version$3$1 = "bytes/5.4.0";
 
-const logger$4 = new Logger$1(version$3);
+const logger$4 = new Logger$1(version$3$1);
 ///////////////////////////////
 function isHexable$1(value) {
     return !!(value.toHexString);
 }
-function addSlice(array) {
+function addSlice$1(array) {
     if (array.slice) {
         return array;
     }
     array.slice = function () {
         const args = Array.prototype.slice.call(arguments);
-        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
+        return addSlice$1(new Uint8Array(Array.prototype.slice.apply(array, args)));
     };
     return array;
 }
@@ -59453,7 +59453,7 @@ function isBytes$1(value) {
     }
     return true;
 }
-function arrayify(value, options) {
+function arrayify$1(value, options) {
     if (!options) {
         options = {};
     }
@@ -59467,7 +59467,7 @@ function arrayify(value, options) {
         if (result.length === 0) {
             result.push(0);
         }
-        return addSlice(new Uint8Array(result));
+        return addSlice$1(new Uint8Array(result));
     }
     if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
         value = "0x" + value;
@@ -59492,10 +59492,10 @@ function arrayify(value, options) {
         for (let i = 0; i < hex.length; i += 2) {
             result.push(parseInt(hex.substring(i, i + 2), 16));
         }
-        return addSlice(new Uint8Array(result));
+        return addSlice$1(new Uint8Array(result));
     }
     if (isBytes$1(value)) {
-        return addSlice(new Uint8Array(value));
+        return addSlice$1(new Uint8Array(value));
     }
     return logger$4.throwArgumentError("invalid arrayify value", "value", value);
 }
@@ -59565,7 +59565,7 @@ function hexlify$1(value, options) {
     }
     return logger$4.throwArgumentError("invalid hexlify value", "value", value);
 }
-function hexZeroPad(value, length) {
+function hexZeroPad$1(value, length) {
     if (typeof (value) !== "string") {
         value = hexlify$1(value);
     }
@@ -59584,10 +59584,10 @@ function hexZeroPad(value, length) {
 const version$2$1 = "bignumber/5.4.1";
 
 var BN$1 = bn$1.BN;
-const logger$3 = new Logger$1(version$2$1);
-const _constructorGuard$1 = {};
+const logger$3$1 = new Logger$1(version$2$1);
+const _constructorGuard$1$1 = {};
 const MAX_SAFE$1 = 0x1fffffffffffff;
-function isBigNumberish(value) {
+function isBigNumberish$1(value) {
     return (value != null) && (BigNumber$1.isBigNumber(value) ||
         (typeof (value) === "number" && (value % 1) === 0) ||
         (typeof (value) === "string" && !!value.match(/^-?[0-9]+$/)) ||
@@ -59599,9 +59599,9 @@ function isBigNumberish(value) {
 let _warnedToStringRadix$1 = false;
 class BigNumber$1 {
     constructor(constructorGuard, hex) {
-        logger$3.checkNew(new.target, BigNumber$1);
-        if (constructorGuard !== _constructorGuard$1) {
-            logger$3.throwError("cannot call constructor directly; use BigNumber.from", Logger$1.errors.UNSUPPORTED_OPERATION, {
+        logger$3$1.checkNew(new.target, BigNumber$1);
+        if (constructorGuard !== _constructorGuard$1$1) {
+            logger$3$1.throwError("cannot call constructor directly; use BigNumber.from", Logger$1.errors.UNSUPPORTED_OPERATION, {
                 operation: "new (BigNumber)"
             });
         }
@@ -59630,7 +59630,7 @@ class BigNumber$1 {
     div(other) {
         const o = BigNumber$1.from(other);
         if (o.isZero()) {
-            throwFault$1("division by zero", "div");
+            throwFault$1$1("division by zero", "div");
         }
         return toBigNumber$1(toBN$1(this).div(toBN$1(other)));
     }
@@ -59640,53 +59640,53 @@ class BigNumber$1 {
     mod(other) {
         const value = toBN$1(other);
         if (value.isNeg()) {
-            throwFault$1("cannot modulo negative values", "mod");
+            throwFault$1$1("cannot modulo negative values", "mod");
         }
         return toBigNumber$1(toBN$1(this).umod(value));
     }
     pow(other) {
         const value = toBN$1(other);
         if (value.isNeg()) {
-            throwFault$1("cannot raise to negative values", "pow");
+            throwFault$1$1("cannot raise to negative values", "pow");
         }
         return toBigNumber$1(toBN$1(this).pow(value));
     }
     and(other) {
         const value = toBN$1(other);
         if (this.isNegative() || value.isNeg()) {
-            throwFault$1("cannot 'and' negative values", "and");
+            throwFault$1$1("cannot 'and' negative values", "and");
         }
         return toBigNumber$1(toBN$1(this).and(value));
     }
     or(other) {
         const value = toBN$1(other);
         if (this.isNegative() || value.isNeg()) {
-            throwFault$1("cannot 'or' negative values", "or");
+            throwFault$1$1("cannot 'or' negative values", "or");
         }
         return toBigNumber$1(toBN$1(this).or(value));
     }
     xor(other) {
         const value = toBN$1(other);
         if (this.isNegative() || value.isNeg()) {
-            throwFault$1("cannot 'xor' negative values", "xor");
+            throwFault$1$1("cannot 'xor' negative values", "xor");
         }
         return toBigNumber$1(toBN$1(this).xor(value));
     }
     mask(value) {
         if (this.isNegative() || value < 0) {
-            throwFault$1("cannot mask negative values", "mask");
+            throwFault$1$1("cannot mask negative values", "mask");
         }
         return toBigNumber$1(toBN$1(this).maskn(value));
     }
     shl(value) {
         if (this.isNegative() || value < 0) {
-            throwFault$1("cannot shift negative values", "shl");
+            throwFault$1$1("cannot shift negative values", "shl");
         }
         return toBigNumber$1(toBN$1(this).shln(value));
     }
     shr(value) {
         if (this.isNegative() || value < 0) {
-            throwFault$1("cannot shift negative values", "shr");
+            throwFault$1$1("cannot shift negative values", "shr");
         }
         return toBigNumber$1(toBN$1(this).shrn(value));
     }
@@ -59716,7 +59716,7 @@ class BigNumber$1 {
             return toBN$1(this).toNumber();
         }
         catch (error) {
-            throwFault$1("overflow", "toNumber", this.toString());
+            throwFault$1$1("overflow", "toNumber", this.toString());
         }
         return null;
     }
@@ -59725,7 +59725,7 @@ class BigNumber$1 {
             return BigInt(this.toString());
         }
         catch (e) { }
-        return logger$3.throwError("this platform does not support BigInt", Logger$1.errors.UNSUPPORTED_OPERATION, {
+        return logger$3$1.throwError("this platform does not support BigInt", Logger$1.errors.UNSUPPORTED_OPERATION, {
             value: this.toString()
         });
     }
@@ -59735,14 +59735,14 @@ class BigNumber$1 {
             if (arguments[0] === 10) {
                 if (!_warnedToStringRadix$1) {
                     _warnedToStringRadix$1 = true;
-                    logger$3.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
+                    logger$3$1.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
                 }
             }
             else if (arguments[0] === 16) {
-                logger$3.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger$1.errors.UNEXPECTED_ARGUMENT, {});
+                logger$3$1.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger$1.errors.UNEXPECTED_ARGUMENT, {});
             }
             else {
-                logger$3.throwError("BigNumber.toString does not accept parameters", Logger$1.errors.UNEXPECTED_ARGUMENT, {});
+                logger$3$1.throwError("BigNumber.toString does not accept parameters", Logger$1.errors.UNEXPECTED_ARGUMENT, {});
             }
         }
         return toBN$1(this).toString(10);
@@ -59759,19 +59759,19 @@ class BigNumber$1 {
         }
         if (typeof (value) === "string") {
             if (value.match(/^-?0x[0-9a-f]+$/i)) {
-                return new BigNumber$1(_constructorGuard$1, toHex$1(value));
+                return new BigNumber$1(_constructorGuard$1$1, toHex$1(value));
             }
             if (value.match(/^-?[0-9]+$/)) {
-                return new BigNumber$1(_constructorGuard$1, toHex$1(new BN$1(value)));
+                return new BigNumber$1(_constructorGuard$1$1, toHex$1(new BN$1(value)));
             }
-            return logger$3.throwArgumentError("invalid BigNumber string", "value", value);
+            return logger$3$1.throwArgumentError("invalid BigNumber string", "value", value);
         }
         if (typeof (value) === "number") {
             if (value % 1) {
-                throwFault$1("underflow", "BigNumber.from", value);
+                throwFault$1$1("underflow", "BigNumber.from", value);
             }
             if (value >= MAX_SAFE$1 || value <= -MAX_SAFE$1) {
-                throwFault$1("overflow", "BigNumber.from", value);
+                throwFault$1$1("overflow", "BigNumber.from", value);
             }
             return BigNumber$1.from(String(value));
         }
@@ -59804,7 +59804,7 @@ class BigNumber$1 {
                 }
             }
         }
-        return logger$3.throwArgumentError("invalid BigNumber value", "value", value);
+        return logger$3$1.throwArgumentError("invalid BigNumber value", "value", value);
     }
     static isBigNumber(value) {
         return !!(value && value._isBigNumber);
@@ -59822,7 +59822,7 @@ function toHex$1(value) {
         value = value.substring(1);
         // Cannot have mulitple negative signs (e.g. "--0x04")
         if (value[0] === "-") {
-            logger$3.throwArgumentError("invalid hex", "value", value);
+            logger$3$1.throwArgumentError("invalid hex", "value", value);
         }
         // Call toHex on the positive component
         value = toHex$1(value);
@@ -59861,36 +59861,36 @@ function toBN$1(value) {
     }
     return new BN$1(hex.substring(2), 16);
 }
-function throwFault$1(fault, operation, value) {
+function throwFault$1$1(fault, operation, value) {
     const params = { fault: fault, operation: operation };
     if (value != null) {
         params.value = value;
     }
-    return logger$3.throwError(fault, Logger$1.errors.NUMERIC_FAULT, params);
+    return logger$3$1.throwError(fault, Logger$1.errors.NUMERIC_FAULT, params);
 }
 // value should have no prefix
 function _base36To16(value) {
     return (new BN$1(value, 36)).toString(16);
 }
 
-const logger$2 = new Logger$1(version$2$1);
+const logger$2$1 = new Logger$1(version$2$1);
 const _constructorGuard$2 = {};
-const Zero = BigNumber$1.from(0);
-const NegativeOne = BigNumber$1.from(-1);
+const Zero$1 = BigNumber$1.from(0);
+const NegativeOne$1 = BigNumber$1.from(-1);
 function throwFault$2(message, fault, operation, value) {
     const params = { fault: fault, operation: operation };
     if (value !== undefined) {
         params.value = value;
     }
-    return logger$2.throwError(message, Logger$1.errors.NUMERIC_FAULT, params);
+    return logger$2$1.throwError(message, Logger$1.errors.NUMERIC_FAULT, params);
 }
 // Constant to pull zeros from for multipliers
-let zeros = "0";
-while (zeros.length < 256) {
-    zeros += zeros;
+let zeros$1 = "0";
+while (zeros$1.length < 256) {
+    zeros$1 += zeros$1;
 }
 // Returns a string "1" followed by decimal "0"s
-function getMultiplier(decimals) {
+function getMultiplier$1(decimals) {
     if (typeof (decimals) !== "number") {
         try {
             decimals = BigNumber$1.from(decimals).toNumber();
@@ -59898,20 +59898,20 @@ function getMultiplier(decimals) {
         catch (e) { }
     }
     if (typeof (decimals) === "number" && decimals >= 0 && decimals <= 256 && !(decimals % 1)) {
-        return ("1" + zeros.substring(0, decimals));
+        return ("1" + zeros$1.substring(0, decimals));
     }
-    return logger$2.throwArgumentError("invalid decimal size", "decimals", decimals);
+    return logger$2$1.throwArgumentError("invalid decimal size", "decimals", decimals);
 }
-function formatFixed(value, decimals) {
+function formatFixed$1(value, decimals) {
     if (decimals == null) {
         decimals = 0;
     }
-    const multiplier = getMultiplier(decimals);
+    const multiplier = getMultiplier$1(decimals);
     // Make sure wei is a big number (convert as necessary)
     value = BigNumber$1.from(value);
-    const negative = value.lt(Zero);
+    const negative = value.lt(Zero$1);
     if (negative) {
-        value = value.mul(NegativeOne);
+        value = value.mul(NegativeOne$1);
     }
     let fraction = value.mod(multiplier).toString();
     while (fraction.length < multiplier.length - 1) {
@@ -59931,13 +59931,13 @@ function formatFixed(value, decimals) {
     }
     return value;
 }
-function parseFixed(value, decimals) {
+function parseFixed$1(value, decimals) {
     if (decimals == null) {
         decimals = 0;
     }
-    const multiplier = getMultiplier(decimals);
+    const multiplier = getMultiplier$1(decimals);
     if (typeof (value) !== "string" || !value.match(/^-?[0-9.,]+$/)) {
-        logger$2.throwArgumentError("invalid decimal value", "value", value);
+        logger$2$1.throwArgumentError("invalid decimal value", "value", value);
     }
     // Is it negative?
     const negative = (value.substring(0, 1) === "-");
@@ -59945,12 +59945,12 @@ function parseFixed(value, decimals) {
         value = value.substring(1);
     }
     if (value === ".") {
-        logger$2.throwArgumentError("missing value", "value", value);
+        logger$2$1.throwArgumentError("missing value", "value", value);
     }
     // Split it into a whole and fractional part
     const comps = value.split(".");
     if (comps.length > 2) {
-        logger$2.throwArgumentError("too many decimal points", "value", value);
+        logger$2$1.throwArgumentError("too many decimal points", "value", value);
     }
     let whole = comps[0], fraction = comps[1];
     if (!whole) {
@@ -59974,14 +59974,14 @@ function parseFixed(value, decimals) {
     const fractionValue = BigNumber$1.from(fraction);
     let wei = (wholeValue.mul(multiplier)).add(fractionValue);
     if (negative) {
-        wei = wei.mul(NegativeOne);
+        wei = wei.mul(NegativeOne$1);
     }
     return wei;
 }
-class FixedFormat {
+class FixedFormat$1 {
     constructor(constructorGuard, signed, width, decimals) {
         if (constructorGuard !== _constructorGuard$2) {
-            logger$2.throwError("cannot use FixedFormat constructor; use FixedFormat.from", Logger$1.errors.UNSUPPORTED_OPERATION, {
+            logger$2$1.throwError("cannot use FixedFormat constructor; use FixedFormat.from", Logger$1.errors.UNSUPPORTED_OPERATION, {
                 operation: "new FixedFormat"
             });
         }
@@ -59989,11 +59989,11 @@ class FixedFormat {
         this.width = width;
         this.decimals = decimals;
         this.name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
-        this._multiplier = getMultiplier(decimals);
+        this._multiplier = getMultiplier$1(decimals);
         Object.freeze(this);
     }
     static from(value) {
-        if (value instanceof FixedFormat) {
+        if (value instanceof FixedFormat$1) {
             return value;
         }
         if (typeof (value) === "number") {
@@ -60010,7 +60010,7 @@ class FixedFormat {
             else {
                 const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
                 if (!match) {
-                    logger$2.throwArgumentError("invalid fixed format", "format", value);
+                    logger$2$1.throwArgumentError("invalid fixed format", "format", value);
                 }
                 signed = (match[1] !== "u");
                 width = parseInt(match[2]);
@@ -60023,7 +60023,7 @@ class FixedFormat {
                     return defaultValue;
                 }
                 if (typeof (value[key]) !== type) {
-                    logger$2.throwArgumentError("invalid fixed format (" + key + " not " + type + ")", "format." + key, value[key]);
+                    logger$2$1.throwArgumentError("invalid fixed format (" + key + " not " + type + ")", "format." + key, value[key]);
                 }
                 return value[key];
             };
@@ -60032,19 +60032,19 @@ class FixedFormat {
             decimals = check("decimals", "number", decimals);
         }
         if (width % 8) {
-            logger$2.throwArgumentError("invalid fixed format width (not byte aligned)", "format.width", width);
+            logger$2$1.throwArgumentError("invalid fixed format width (not byte aligned)", "format.width", width);
         }
         if (decimals > 80) {
-            logger$2.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals);
+            logger$2$1.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals);
         }
-        return new FixedFormat(_constructorGuard$2, signed, width, decimals);
+        return new FixedFormat$1(_constructorGuard$2, signed, width, decimals);
     }
 }
-class FixedNumber {
+class FixedNumber$1 {
     constructor(constructorGuard, hex, value, format) {
-        logger$2.checkNew(new.target, FixedNumber);
+        logger$2$1.checkNew(new.target, FixedNumber$1);
         if (constructorGuard !== _constructorGuard$2) {
-            logger$2.throwError("cannot use FixedNumber constructor; use FixedNumber.from", Logger$1.errors.UNSUPPORTED_OPERATION, {
+            logger$2$1.throwError("cannot use FixedNumber constructor; use FixedNumber.from", Logger$1.errors.UNSUPPORTED_OPERATION, {
                 operation: "new FixedFormat"
             });
         }
@@ -60056,42 +60056,42 @@ class FixedNumber {
     }
     _checkFormat(other) {
         if (this.format.name !== other.format.name) {
-            logger$2.throwArgumentError("incompatible format; use fixedNumber.toFormat", "other", other);
+            logger$2$1.throwArgumentError("incompatible format; use fixedNumber.toFormat", "other", other);
         }
     }
     addUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed(this._value, this.format.decimals);
-        const b = parseFixed(other._value, other.format.decimals);
-        return FixedNumber.fromValue(a.add(b), this.format.decimals, this.format);
+        const a = parseFixed$1(this._value, this.format.decimals);
+        const b = parseFixed$1(other._value, other.format.decimals);
+        return FixedNumber$1.fromValue(a.add(b), this.format.decimals, this.format);
     }
     subUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed(this._value, this.format.decimals);
-        const b = parseFixed(other._value, other.format.decimals);
-        return FixedNumber.fromValue(a.sub(b), this.format.decimals, this.format);
+        const a = parseFixed$1(this._value, this.format.decimals);
+        const b = parseFixed$1(other._value, other.format.decimals);
+        return FixedNumber$1.fromValue(a.sub(b), this.format.decimals, this.format);
     }
     mulUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed(this._value, this.format.decimals);
-        const b = parseFixed(other._value, other.format.decimals);
-        return FixedNumber.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
+        const a = parseFixed$1(this._value, this.format.decimals);
+        const b = parseFixed$1(other._value, other.format.decimals);
+        return FixedNumber$1.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
     }
     divUnsafe(other) {
         this._checkFormat(other);
-        const a = parseFixed(this._value, this.format.decimals);
-        const b = parseFixed(other._value, other.format.decimals);
-        return FixedNumber.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
+        const a = parseFixed$1(this._value, this.format.decimals);
+        const b = parseFixed$1(other._value, other.format.decimals);
+        return FixedNumber$1.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
     }
     floor() {
         const comps = this.toString().split(".");
         if (comps.length === 1) {
             comps.push("0");
         }
-        let result = FixedNumber.from(comps[0], this.format);
+        let result = FixedNumber$1.from(comps[0], this.format);
         const hasFraction = !comps[1].match(/^(0*)$/);
         if (this.isNegative() && hasFraction) {
-            result = result.subUnsafe(ONE.toFormat(result.format));
+            result = result.subUnsafe(ONE$1.toFormat(result.format));
         }
         return result;
     }
@@ -60100,10 +60100,10 @@ class FixedNumber {
         if (comps.length === 1) {
             comps.push("0");
         }
-        let result = FixedNumber.from(comps[0], this.format);
+        let result = FixedNumber$1.from(comps[0], this.format);
         const hasFraction = !comps[1].match(/^(0*)$/);
         if (!this.isNegative() && hasFraction) {
-            result = result.addUnsafe(ONE.toFormat(result.format));
+            result = result.addUnsafe(ONE$1.toFormat(result.format));
         }
         return result;
     }
@@ -60118,13 +60118,13 @@ class FixedNumber {
             comps.push("0");
         }
         if (decimals < 0 || decimals > 80 || (decimals % 1)) {
-            logger$2.throwArgumentError("invalid decimal count", "decimals", decimals);
+            logger$2$1.throwArgumentError("invalid decimal count", "decimals", decimals);
         }
         if (comps[1].length <= decimals) {
             return this;
         }
-        const factor = FixedNumber.from("1" + zeros.substring(0, decimals), this.format);
-        const bump = BUMP.toFormat(this.format);
+        const factor = FixedNumber$1.from("1" + zeros$1.substring(0, decimals), this.format);
+        const bump = BUMP$1.toFormat(this.format);
         return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor);
     }
     isZero() {
@@ -60139,18 +60139,18 @@ class FixedNumber {
             return this._hex;
         }
         if (width % 8) {
-            logger$2.throwArgumentError("invalid byte width", "width", width);
+            logger$2$1.throwArgumentError("invalid byte width", "width", width);
         }
         const hex = BigNumber$1.from(this._hex).fromTwos(this.format.width).toTwos(width).toHexString();
-        return hexZeroPad(hex, width / 8);
+        return hexZeroPad$1(hex, width / 8);
     }
     toUnsafeFloat() { return parseFloat(this.toString()); }
     toFormat(format) {
-        return FixedNumber.fromString(this._value, format);
+        return FixedNumber$1.fromString(this._value, format);
     }
     static fromValue(value, decimals, format) {
         // If decimals looks more like a format, and there is no format, shift the parameters
-        if (format == null && decimals != null && !isBigNumberish(decimals)) {
+        if (format == null && decimals != null && !isBigNumberish$1(decimals)) {
             format = decimals;
             decimals = null;
         }
@@ -60160,15 +60160,15 @@ class FixedNumber {
         if (format == null) {
             format = "fixed";
         }
-        return FixedNumber.fromString(formatFixed(value, decimals), FixedFormat.from(format));
+        return FixedNumber$1.fromString(formatFixed$1(value, decimals), FixedFormat$1.from(format));
     }
     static fromString(value, format) {
         if (format == null) {
             format = "fixed";
         }
-        const fixedFormat = FixedFormat.from(format);
-        const numeric = parseFixed(value, fixedFormat.decimals);
-        if (!fixedFormat.signed && numeric.lt(Zero)) {
+        const fixedFormat = FixedFormat$1.from(format);
+        const numeric = parseFixed$1(value, fixedFormat.decimals);
+        if (!fixedFormat.signed && numeric.lt(Zero$1)) {
             throwFault$2("unsigned value cannot be negative", "overflow", "value", value);
         }
         let hex = null;
@@ -60177,17 +60177,17 @@ class FixedNumber {
         }
         else {
             hex = numeric.toHexString();
-            hex = hexZeroPad(hex, fixedFormat.width / 8);
+            hex = hexZeroPad$1(hex, fixedFormat.width / 8);
         }
-        const decimal = formatFixed(numeric, fixedFormat.decimals);
-        return new FixedNumber(_constructorGuard$2, hex, decimal, fixedFormat);
+        const decimal = formatFixed$1(numeric, fixedFormat.decimals);
+        return new FixedNumber$1(_constructorGuard$2, hex, decimal, fixedFormat);
     }
     static fromBytes(value, format) {
         if (format == null) {
             format = "fixed";
         }
-        const fixedFormat = FixedFormat.from(format);
-        if (arrayify(value).length > fixedFormat.width / 8) {
+        const fixedFormat = FixedFormat$1.from(format);
+        if (arrayify$1(value).length > fixedFormat.width / 8) {
             throw new Error("overflow");
         }
         let numeric = BigNumber$1.from(value);
@@ -60195,18 +60195,18 @@ class FixedNumber {
             numeric = numeric.fromTwos(fixedFormat.width);
         }
         const hex = numeric.toTwos((fixedFormat.signed ? 0 : 1) + fixedFormat.width).toHexString();
-        const decimal = formatFixed(numeric, fixedFormat.decimals);
-        return new FixedNumber(_constructorGuard$2, hex, decimal, fixedFormat);
+        const decimal = formatFixed$1(numeric, fixedFormat.decimals);
+        return new FixedNumber$1(_constructorGuard$2, hex, decimal, fixedFormat);
     }
     static from(value, format) {
         if (typeof (value) === "string") {
-            return FixedNumber.fromString(value, format);
+            return FixedNumber$1.fromString(value, format);
         }
         if (isBytes$1(value)) {
-            return FixedNumber.fromBytes(value, format);
+            return FixedNumber$1.fromBytes(value, format);
         }
         try {
-            return FixedNumber.fromValue(value, 0, format);
+            return FixedNumber$1.fromValue(value, 0, format);
         }
         catch (error) {
             // Allow NUMERIC_FAULT to bubble up
@@ -60214,14 +60214,14 @@ class FixedNumber {
                 throw error;
             }
         }
-        return logger$2.throwArgumentError("invalid FixedNumber value", "value", value);
+        return logger$2$1.throwArgumentError("invalid FixedNumber value", "value", value);
     }
     static isFixedNumber(value) {
         return !!(value && value._isFixedNumber);
     }
 }
-const ONE = FixedNumber.from(1);
-const BUMP = FixedNumber.from("0.5");
+const ONE$1 = FixedNumber$1.from(1);
+const BUMP$1 = FixedNumber$1.from("0.5");
 
 /**
  * [js-sha3]{@link https://github.com/emn178/js-sha3}
@@ -60704,7 +60704,7 @@ var sha3 = createCommonjsModule$1(function (module) {
 var sha3$1 = sha3;
 
 function keccak256(data) {
-    return '0x' + sha3$1.keccak_256(arrayify(data));
+    return '0x' + sha3$1.keccak_256(arrayify$1(data));
 }
 
 const version$1$1 = "address/5.4.0";
@@ -60720,7 +60720,7 @@ function getChecksumAddress(address) {
     for (let i = 0; i < 40; i++) {
         expanded[i] = chars[i].charCodeAt(0);
     }
-    const hashed = arrayify(keccak256(expanded));
+    const hashed = arrayify$1(keccak256(expanded));
     for (let i = 0; i < 40; i += 2) {
         if ((hashed[i >> 1] >> 4) >= 8) {
             chars[i] = chars[i].toUpperCase();
@@ -60802,7 +60802,7 @@ function getAddress(address) {
 const version$5 = "units/5.4.0";
 
 const logger$5 = new Logger$1(version$5);
-const names = [
+const names$1 = [
     "wei",
     "kwei",
     "mwei",
@@ -60811,17 +60811,17 @@ const names = [
     "finney",
     "ether",
 ];
-function parseUnits(value, unitName) {
+function parseUnits$1(value, unitName) {
     if (typeof (value) !== "string") {
         logger$5.throwArgumentError("value must be a string", "value", value);
     }
     if (typeof (unitName) === "string") {
-        const index = names.indexOf(unitName);
+        const index = names$1.indexOf(unitName);
         if (index !== -1) {
             unitName = 3 * index;
         }
     }
-    return parseFixed(value, (unitName != null) ? unitName : 18);
+    return parseFixed$1(value, (unitName != null) ? unitName : 18);
 }
 
 function _optionalChain$1$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
@@ -60855,9 +60855,9 @@ let fixUniswapPath$1 = (path) => {
 
 let minReserveRequirements$1 = ({ reserves, min, token, token0, token1, decimals }) => {
   if(token0.toLowerCase() == token.toLowerCase()) {
-    return reserves[0].gte(parseUnits(min.toString(), decimals))
+    return reserves[0].gte(parseUnits$1(min.toString(), decimals))
   } else if (token1.toLowerCase() == token.toLowerCase()) {
-    return reserves[1].gte(parseUnits(min.toString(), decimals))
+    return reserves[1].gte(parseUnits$1(min.toString(), decimals))
   } else {
     return false
   }
@@ -61205,9 +61205,9 @@ let fixUniswapPath = (path) => {
 
 let minReserveRequirements = ({ reserves, min, token, token0, token1, decimals }) => {
   if(token0.toLowerCase() == token.toLowerCase()) {
-    return reserves[0].gte(parseUnits(min.toString(), decimals))
+    return reserves[0].gte(parseUnits$1(min.toString(), decimals))
   } else if (token1.toLowerCase() == token.toLowerCase()) {
-    return reserves[1].gte(parseUnits(min.toString(), decimals))
+    return reserves[1].gte(parseUnits$1(min.toString(), decimals))
   } else {
     return false
   }
@@ -62710,6 +62710,10 @@ const prepareContractCallAddressPassedAmountBooleanTransaction = (transaction, t
   return transaction
 };
 
+const preparePaymentFeeTransaction = (transaction)=> {
+
+};
+
 var plugins = {
   ethereum: {
     payment: {
@@ -62731,6 +62735,10 @@ var plugins = {
         address: '0x2D18c5A46cc1780d2460DD51B5d0996e55Fd2446',
         prepareTransaction: prepareContractCallAddressPassedAmountBooleanTransaction
       }
+    },
+    paymentFee: {
+      address: '0x874Cb669D7BFff79d4A6A30F4ea52c5e413BD6A7',
+      prepareTransaction: preparePaymentFeeTransaction
     }
   },
   bsc: {
@@ -62753,6 +62761,10 @@ var plugins = {
         address: '0x7E655088214d0657251A51aDccE9109CFd23B5B5',
         prepareTransaction: prepareContractCallAddressPassedAmountBooleanTransaction
       }
+    },
+    paymentFee: {
+      address: '0xae33f10AD57A38113f74FCdc1ffA6B1eC47B94E3',
+      prepareTransaction: preparePaymentFeeTransaction
     }
   } 
 };
@@ -66221,7 +66233,7 @@ var bn = createCommonjsModule(function (module) {
 })(module, commonjsGlobal);
 });
 
-const version$2 = "logger/5.4.1";
+const version$3 = "logger/5.4.1";
 
 let _permanentCensorErrors = false;
 let _censorErrors = false;
@@ -66497,7 +66509,7 @@ class Logger {
     }
     static globalLogger() {
         if (!_globalLogger) {
-            _globalLogger = new Logger(version$2);
+            _globalLogger = new Logger(version$3);
         }
         return _globalLogger;
     }
@@ -66533,13 +66545,23 @@ class Logger {
 Logger.errors = ErrorCode;
 Logger.levels = LogLevel;
 
-const version$1 = "bytes/5.4.0";
+const version$2 = "bytes/5.4.0";
 
-const logger$1 = new Logger(version$1);
+const logger$3 = new Logger(version$2);
 ///////////////////////////////
 function isHexable(value) {
     return !!(value.toHexString);
 }
+function addSlice(array) {
+    if (array.slice) {
+        return array;
+    }
+    array.slice = function () {
+        const args = Array.prototype.slice.call(arguments);
+        return addSlice(new Uint8Array(Array.prototype.slice.apply(array, args)));
+    };
+    return array;
+}
 function isBytes(value) {
     if (value == null) {
         return false;
@@ -66561,6 +66583,52 @@ function isBytes(value) {
     }
     return true;
 }
+function arrayify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof (value) === "number") {
+        logger$3.checkSafeUint53(value, "invalid arrayify value");
+        const result = [];
+        while (value) {
+            result.unshift(value & 0xff);
+            value = parseInt(String(value / 256));
+        }
+        if (result.length === 0) {
+            result.push(0);
+        }
+        return addSlice(new Uint8Array(result));
+    }
+    if (options.allowMissingPrefix && typeof (value) === "string" && value.substring(0, 2) !== "0x") {
+        value = "0x" + value;
+    }
+    if (isHexable(value)) {
+        value = value.toHexString();
+    }
+    if (isHexString(value)) {
+        let hex = value.substring(2);
+        if (hex.length % 2) {
+            if (options.hexPad === "left") {
+                hex = "0x0" + hex.substring(2);
+            }
+            else if (options.hexPad === "right") {
+                hex += "0";
+            }
+            else {
+                logger$3.throwArgumentError("hex data is odd-length", "value", value);
+            }
+        }
+        const result = [];
+        for (let i = 0; i < hex.length; i += 2) {
+            result.push(parseInt(hex.substring(i, i + 2), 16));
+        }
+        return addSlice(new Uint8Array(result));
+    }
+    if (isBytes(value)) {
+        return addSlice(new Uint8Array(value));
+    }
+    return logger$3.throwArgumentError("invalid arrayify value", "value", value);
+}
 function isHexString(value, length) {
     if (typeof (value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
         return false;
@@ -66576,7 +66644,7 @@ function hexlify(value, options) {
         options = {};
     }
     if (typeof (value) === "number") {
-        logger$1.checkSafeUint53(value, "invalid hexlify value");
+        logger$3.checkSafeUint53(value, "invalid hexlify value");
         let hex = "";
         while (value) {
             hex = HexCharacters[value & 0xf] + hex;
@@ -66612,7 +66680,7 @@ function hexlify(value, options) {
                 value += "0";
             }
             else {
-                logger$1.throwArgumentError("hex data is odd-length", "value", value);
+                logger$3.throwArgumentError("hex data is odd-length", "value", value);
             }
         }
         return value.toLowerCase();
@@ -66625,22 +66693,45 @@ function hexlify(value, options) {
         }
         return result;
     }
-    return logger$1.throwArgumentError("invalid hexlify value", "value", value);
+    return logger$3.throwArgumentError("invalid hexlify value", "value", value);
+}
+function hexZeroPad(value, length) {
+    if (typeof (value) !== "string") {
+        value = hexlify(value);
+    }
+    else if (!isHexString(value)) {
+        logger$3.throwArgumentError("invalid hex string", "value", value);
+    }
+    if (value.length > 2 * length + 2) {
+        logger$3.throwArgumentError("value out of range", "value", arguments[1]);
+    }
+    while (value.length < 2 * length + 2) {
+        value = "0x0" + value.substring(2);
+    }
+    return value;
 }
 
-const version = "bignumber/5.4.1";
+const version$1 = "bignumber/5.4.1";
 
 var BN = bn.BN;
-const logger = new Logger(version);
-const _constructorGuard = {};
+const logger$2 = new Logger(version$1);
+const _constructorGuard$1 = {};
 const MAX_SAFE = 0x1fffffffffffff;
+function isBigNumberish(value) {
+    return (value != null) && (BigNumber.isBigNumber(value) ||
+        (typeof (value) === "number" && (value % 1) === 0) ||
+        (typeof (value) === "string" && !!value.match(/^-?[0-9]+$/)) ||
+        isHexString(value) ||
+        (typeof (value) === "bigint") ||
+        isBytes(value));
+}
 // Only warn about passing 10 into radix once
 let _warnedToStringRadix = false;
 class BigNumber {
     constructor(constructorGuard, hex) {
-        logger.checkNew(new.target, BigNumber);
-        if (constructorGuard !== _constructorGuard) {
-            logger.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
+        logger$2.checkNew(new.target, BigNumber);
+        if (constructorGuard !== _constructorGuard$1) {
+            logger$2.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
                 operation: "new (BigNumber)"
             });
         }
@@ -66669,7 +66760,7 @@ class BigNumber {
     div(other) {
         const o = BigNumber.from(other);
         if (o.isZero()) {
-            throwFault("division by zero", "div");
+            throwFault$1("division by zero", "div");
         }
         return toBigNumber(toBN(this).div(toBN(other)));
     }
@@ -66679,53 +66770,53 @@ class BigNumber {
     mod(other) {
         const value = toBN(other);
         if (value.isNeg()) {
-            throwFault("cannot modulo negative values", "mod");
+            throwFault$1("cannot modulo negative values", "mod");
         }
         return toBigNumber(toBN(this).umod(value));
     }
     pow(other) {
         const value = toBN(other);
         if (value.isNeg()) {
-            throwFault("cannot raise to negative values", "pow");
+            throwFault$1("cannot raise to negative values", "pow");
         }
         return toBigNumber(toBN(this).pow(value));
     }
     and(other) {
         const value = toBN(other);
         if (this.isNegative() || value.isNeg()) {
-            throwFault("cannot 'and' negative values", "and");
+            throwFault$1("cannot 'and' negative values", "and");
         }
         return toBigNumber(toBN(this).and(value));
     }
     or(other) {
         const value = toBN(other);
         if (this.isNegative() || value.isNeg()) {
-            throwFault("cannot 'or' negative values", "or");
+            throwFault$1("cannot 'or' negative values", "or");
         }
         return toBigNumber(toBN(this).or(value));
     }
     xor(other) {
         const value = toBN(other);
         if (this.isNegative() || value.isNeg()) {
-            throwFault("cannot 'xor' negative values", "xor");
+            throwFault$1("cannot 'xor' negative values", "xor");
         }
         return toBigNumber(toBN(this).xor(value));
     }
     mask(value) {
         if (this.isNegative() || value < 0) {
-            throwFault("cannot mask negative values", "mask");
+            throwFault$1("cannot mask negative values", "mask");
         }
         return toBigNumber(toBN(this).maskn(value));
     }
     shl(value) {
         if (this.isNegative() || value < 0) {
-            throwFault("cannot shift negative values", "shl");
+            throwFault$1("cannot shift negative values", "shl");
         }
         return toBigNumber(toBN(this).shln(value));
     }
     shr(value) {
         if (this.isNegative() || value < 0) {
-            throwFault("cannot shift negative values", "shr");
+            throwFault$1("cannot shift negative values", "shr");
         }
         return toBigNumber(toBN(this).shrn(value));
     }
@@ -66755,7 +66846,7 @@ class BigNumber {
             return toBN(this).toNumber();
         }
         catch (error) {
-            throwFault("overflow", "toNumber", this.toString());
+            throwFault$1("overflow", "toNumber", this.toString());
         }
         return null;
     }
@@ -66764,7 +66855,7 @@ class BigNumber {
             return BigInt(this.toString());
         }
         catch (e) { }
-        return logger.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
+        return logger$2.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
             value: this.toString()
         });
     }
@@ -66774,14 +66865,14 @@ class BigNumber {
             if (arguments[0] === 10) {
                 if (!_warnedToStringRadix) {
                     _warnedToStringRadix = true;
-                    logger.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
+                    logger$2.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
                 }
             }
             else if (arguments[0] === 16) {
-                logger.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
+                logger$2.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
             }
             else {
-                logger.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
+                logger$2.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
             }
         }
         return toBN(this).toString(10);
@@ -66798,19 +66889,19 @@ class BigNumber {
         }
         if (typeof (value) === "string") {
             if (value.match(/^-?0x[0-9a-f]+$/i)) {
-                return new BigNumber(_constructorGuard, toHex(value));
+                return new BigNumber(_constructorGuard$1, toHex(value));
             }
             if (value.match(/^-?[0-9]+$/)) {
-                return new BigNumber(_constructorGuard, toHex(new BN(value)));
+                return new BigNumber(_constructorGuard$1, toHex(new BN(value)));
             }
-            return logger.throwArgumentError("invalid BigNumber string", "value", value);
+            return logger$2.throwArgumentError("invalid BigNumber string", "value", value);
         }
         if (typeof (value) === "number") {
             if (value % 1) {
-                throwFault("underflow", "BigNumber.from", value);
+                throwFault$1("underflow", "BigNumber.from", value);
             }
             if (value >= MAX_SAFE || value <= -MAX_SAFE) {
-                throwFault("overflow", "BigNumber.from", value);
+                throwFault$1("overflow", "BigNumber.from", value);
             }
             return BigNumber.from(String(value));
         }
@@ -66843,7 +66934,7 @@ class BigNumber {
                 }
             }
         }
-        return logger.throwArgumentError("invalid BigNumber value", "value", value);
+        return logger$2.throwArgumentError("invalid BigNumber value", "value", value);
     }
     static isBigNumber(value) {
         return !!(value && value._isBigNumber);
@@ -66861,7 +66952,7 @@ function toHex(value) {
         value = value.substring(1);
         // Cannot have mulitple negative signs (e.g. "--0x04")
         if (value[0] === "-") {
-            logger.throwArgumentError("invalid hex", "value", value);
+            logger$2.throwArgumentError("invalid hex", "value", value);
         }
         // Call toHex on the positive component
         value = toHex(value);
@@ -66900,24 +66991,399 @@ function toBN(value) {
     }
     return new BN(hex.substring(2), 16);
 }
-function throwFault(fault, operation, value) {
+function throwFault$1(fault, operation, value) {
     const params = { fault: fault, operation: operation };
     if (value != null) {
         params.value = value;
     }
-    return logger.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
+    return logger$2.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
+}
+
+const logger$1 = new Logger(version$1);
+const _constructorGuard = {};
+const Zero = BigNumber.from(0);
+const NegativeOne = BigNumber.from(-1);
+function throwFault(message, fault, operation, value) {
+    const params = { fault: fault, operation: operation };
+    if (value !== undefined) {
+        params.value = value;
+    }
+    return logger$1.throwError(message, Logger.errors.NUMERIC_FAULT, params);
+}
+// Constant to pull zeros from for multipliers
+let zeros = "0";
+while (zeros.length < 256) {
+    zeros += zeros;
+}
+// Returns a string "1" followed by decimal "0"s
+function getMultiplier(decimals) {
+    if (typeof (decimals) !== "number") {
+        try {
+            decimals = BigNumber.from(decimals).toNumber();
+        }
+        catch (e) { }
+    }
+    if (typeof (decimals) === "number" && decimals >= 0 && decimals <= 256 && !(decimals % 1)) {
+        return ("1" + zeros.substring(0, decimals));
+    }
+    return logger$1.throwArgumentError("invalid decimal size", "decimals", decimals);
+}
+function formatFixed(value, decimals) {
+    if (decimals == null) {
+        decimals = 0;
+    }
+    const multiplier = getMultiplier(decimals);
+    // Make sure wei is a big number (convert as necessary)
+    value = BigNumber.from(value);
+    const negative = value.lt(Zero);
+    if (negative) {
+        value = value.mul(NegativeOne);
+    }
+    let fraction = value.mod(multiplier).toString();
+    while (fraction.length < multiplier.length - 1) {
+        fraction = "0" + fraction;
+    }
+    // Strip training 0
+    fraction = fraction.match(/^([0-9]*[1-9]|0)(0*)/)[1];
+    const whole = value.div(multiplier).toString();
+    if (multiplier.length === 1) {
+        value = whole;
+    }
+    else {
+        value = whole + "." + fraction;
+    }
+    if (negative) {
+        value = "-" + value;
+    }
+    return value;
+}
+function parseFixed(value, decimals) {
+    if (decimals == null) {
+        decimals = 0;
+    }
+    const multiplier = getMultiplier(decimals);
+    if (typeof (value) !== "string" || !value.match(/^-?[0-9.,]+$/)) {
+        logger$1.throwArgumentError("invalid decimal value", "value", value);
+    }
+    // Is it negative?
+    const negative = (value.substring(0, 1) === "-");
+    if (negative) {
+        value = value.substring(1);
+    }
+    if (value === ".") {
+        logger$1.throwArgumentError("missing value", "value", value);
+    }
+    // Split it into a whole and fractional part
+    const comps = value.split(".");
+    if (comps.length > 2) {
+        logger$1.throwArgumentError("too many decimal points", "value", value);
+    }
+    let whole = comps[0], fraction = comps[1];
+    if (!whole) {
+        whole = "0";
+    }
+    if (!fraction) {
+        fraction = "0";
+    }
+    // Get significant digits to check truncation for underflow
+    {
+        const sigFraction = fraction.replace(/^([0-9]*?)(0*)$/, (all, sig, zeros) => (sig));
+        if (sigFraction.length > multiplier.length - 1) {
+            throwFault("fractional component exceeds decimals", "underflow", "parseFixed");
+        }
+    }
+    // Fully pad the string with zeros to get to wei
+    while (fraction.length < multiplier.length - 1) {
+        fraction += "0";
+    }
+    const wholeValue = BigNumber.from(whole);
+    const fractionValue = BigNumber.from(fraction);
+    let wei = (wholeValue.mul(multiplier)).add(fractionValue);
+    if (negative) {
+        wei = wei.mul(NegativeOne);
+    }
+    return wei;
+}
+class FixedFormat {
+    constructor(constructorGuard, signed, width, decimals) {
+        if (constructorGuard !== _constructorGuard) {
+            logger$1.throwError("cannot use FixedFormat constructor; use FixedFormat.from", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: "new FixedFormat"
+            });
+        }
+        this.signed = signed;
+        this.width = width;
+        this.decimals = decimals;
+        this.name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
+        this._multiplier = getMultiplier(decimals);
+        Object.freeze(this);
+    }
+    static from(value) {
+        if (value instanceof FixedFormat) {
+            return value;
+        }
+        if (typeof (value) === "number") {
+            value = `fixed128x${value}`;
+        }
+        let signed = true;
+        let width = 128;
+        let decimals = 18;
+        if (typeof (value) === "string") {
+            if (value === "fixed") ;
+            else if (value === "ufixed") {
+                signed = false;
+            }
+            else {
+                const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
+                if (!match) {
+                    logger$1.throwArgumentError("invalid fixed format", "format", value);
+                }
+                signed = (match[1] !== "u");
+                width = parseInt(match[2]);
+                decimals = parseInt(match[3]);
+            }
+        }
+        else if (value) {
+            const check = (key, type, defaultValue) => {
+                if (value[key] == null) {
+                    return defaultValue;
+                }
+                if (typeof (value[key]) !== type) {
+                    logger$1.throwArgumentError("invalid fixed format (" + key + " not " + type + ")", "format." + key, value[key]);
+                }
+                return value[key];
+            };
+            signed = check("signed", "boolean", signed);
+            width = check("width", "number", width);
+            decimals = check("decimals", "number", decimals);
+        }
+        if (width % 8) {
+            logger$1.throwArgumentError("invalid fixed format width (not byte aligned)", "format.width", width);
+        }
+        if (decimals > 80) {
+            logger$1.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals);
+        }
+        return new FixedFormat(_constructorGuard, signed, width, decimals);
+    }
+}
+class FixedNumber {
+    constructor(constructorGuard, hex, value, format) {
+        logger$1.checkNew(new.target, FixedNumber);
+        if (constructorGuard !== _constructorGuard) {
+            logger$1.throwError("cannot use FixedNumber constructor; use FixedNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: "new FixedFormat"
+            });
+        }
+        this.format = format;
+        this._hex = hex;
+        this._value = value;
+        this._isFixedNumber = true;
+        Object.freeze(this);
+    }
+    _checkFormat(other) {
+        if (this.format.name !== other.format.name) {
+            logger$1.throwArgumentError("incompatible format; use fixedNumber.toFormat", "other", other);
+        }
+    }
+    addUnsafe(other) {
+        this._checkFormat(other);
+        const a = parseFixed(this._value, this.format.decimals);
+        const b = parseFixed(other._value, other.format.decimals);
+        return FixedNumber.fromValue(a.add(b), this.format.decimals, this.format);
+    }
+    subUnsafe(other) {
+        this._checkFormat(other);
+        const a = parseFixed(this._value, this.format.decimals);
+        const b = parseFixed(other._value, other.format.decimals);
+        return FixedNumber.fromValue(a.sub(b), this.format.decimals, this.format);
+    }
+    mulUnsafe(other) {
+        this._checkFormat(other);
+        const a = parseFixed(this._value, this.format.decimals);
+        const b = parseFixed(other._value, other.format.decimals);
+        return FixedNumber.fromValue(a.mul(b).div(this.format._multiplier), this.format.decimals, this.format);
+    }
+    divUnsafe(other) {
+        this._checkFormat(other);
+        const a = parseFixed(this._value, this.format.decimals);
+        const b = parseFixed(other._value, other.format.decimals);
+        return FixedNumber.fromValue(a.mul(this.format._multiplier).div(b), this.format.decimals, this.format);
+    }
+    floor() {
+        const comps = this.toString().split(".");
+        if (comps.length === 1) {
+            comps.push("0");
+        }
+        let result = FixedNumber.from(comps[0], this.format);
+        const hasFraction = !comps[1].match(/^(0*)$/);
+        if (this.isNegative() && hasFraction) {
+            result = result.subUnsafe(ONE.toFormat(result.format));
+        }
+        return result;
+    }
+    ceiling() {
+        const comps = this.toString().split(".");
+        if (comps.length === 1) {
+            comps.push("0");
+        }
+        let result = FixedNumber.from(comps[0], this.format);
+        const hasFraction = !comps[1].match(/^(0*)$/);
+        if (!this.isNegative() && hasFraction) {
+            result = result.addUnsafe(ONE.toFormat(result.format));
+        }
+        return result;
+    }
+    // @TODO: Support other rounding algorithms
+    round(decimals) {
+        if (decimals == null) {
+            decimals = 0;
+        }
+        // If we are already in range, we're done
+        const comps = this.toString().split(".");
+        if (comps.length === 1) {
+            comps.push("0");
+        }
+        if (decimals < 0 || decimals > 80 || (decimals % 1)) {
+            logger$1.throwArgumentError("invalid decimal count", "decimals", decimals);
+        }
+        if (comps[1].length <= decimals) {
+            return this;
+        }
+        const factor = FixedNumber.from("1" + zeros.substring(0, decimals), this.format);
+        const bump = BUMP.toFormat(this.format);
+        return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor);
+    }
+    isZero() {
+        return (this._value === "0.0" || this._value === "0");
+    }
+    isNegative() {
+        return (this._value[0] === "-");
+    }
+    toString() { return this._value; }
+    toHexString(width) {
+        if (width == null) {
+            return this._hex;
+        }
+        if (width % 8) {
+            logger$1.throwArgumentError("invalid byte width", "width", width);
+        }
+        const hex = BigNumber.from(this._hex).fromTwos(this.format.width).toTwos(width).toHexString();
+        return hexZeroPad(hex, width / 8);
+    }
+    toUnsafeFloat() { return parseFloat(this.toString()); }
+    toFormat(format) {
+        return FixedNumber.fromString(this._value, format);
+    }
+    static fromValue(value, decimals, format) {
+        // If decimals looks more like a format, and there is no format, shift the parameters
+        if (format == null && decimals != null && !isBigNumberish(decimals)) {
+            format = decimals;
+            decimals = null;
+        }
+        if (decimals == null) {
+            decimals = 0;
+        }
+        if (format == null) {
+            format = "fixed";
+        }
+        return FixedNumber.fromString(formatFixed(value, decimals), FixedFormat.from(format));
+    }
+    static fromString(value, format) {
+        if (format == null) {
+            format = "fixed";
+        }
+        const fixedFormat = FixedFormat.from(format);
+        const numeric = parseFixed(value, fixedFormat.decimals);
+        if (!fixedFormat.signed && numeric.lt(Zero)) {
+            throwFault("unsigned value cannot be negative", "overflow", "value", value);
+        }
+        let hex = null;
+        if (fixedFormat.signed) {
+            hex = numeric.toTwos(fixedFormat.width).toHexString();
+        }
+        else {
+            hex = numeric.toHexString();
+            hex = hexZeroPad(hex, fixedFormat.width / 8);
+        }
+        const decimal = formatFixed(numeric, fixedFormat.decimals);
+        return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat);
+    }
+    static fromBytes(value, format) {
+        if (format == null) {
+            format = "fixed";
+        }
+        const fixedFormat = FixedFormat.from(format);
+        if (arrayify(value).length > fixedFormat.width / 8) {
+            throw new Error("overflow");
+        }
+        let numeric = BigNumber.from(value);
+        if (fixedFormat.signed) {
+            numeric = numeric.fromTwos(fixedFormat.width);
+        }
+        const hex = numeric.toTwos((fixedFormat.signed ? 0 : 1) + fixedFormat.width).toHexString();
+        const decimal = formatFixed(numeric, fixedFormat.decimals);
+        return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat);
+    }
+    static from(value, format) {
+        if (typeof (value) === "string") {
+            return FixedNumber.fromString(value, format);
+        }
+        if (isBytes(value)) {
+            return FixedNumber.fromBytes(value, format);
+        }
+        try {
+            return FixedNumber.fromValue(value, 0, format);
+        }
+        catch (error) {
+            // Allow NUMERIC_FAULT to bubble up
+            if (error.code !== Logger.errors.INVALID_ARGUMENT) {
+                throw error;
+            }
+        }
+        return logger$1.throwArgumentError("invalid FixedNumber value", "value", value);
+    }
+    static isFixedNumber(value) {
+        return !!(value && value._isFixedNumber);
+    }
+}
+const ONE = FixedNumber.from(1);
+const BUMP = FixedNumber.from("0.5");
+
+const version = "units/5.4.0";
+
+const logger = new Logger(version);
+const names = [
+    "wei",
+    "kwei",
+    "mwei",
+    "gwei",
+    "szabo",
+    "finney",
+    "ether",
+];
+function parseUnits(value, unitName) {
+    if (typeof (value) !== "string") {
+        logger.throwArgumentError("value must be a string", "value", value);
+    }
+    if (typeof (unitName) === "string") {
+        const index = names.indexOf(unitName);
+        if (index !== -1) {
+            unitName = 3 * index;
+        }
+    }
+    return parseFixed(value, (unitName != null) ? unitName : 18);
 }
 
 function _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-let getTransaction = ({ paymentRoute, event })=> {
+let getTransaction = ({ paymentRoute, event, fee })=> {
   let exchangeRoute = paymentRoute.exchangeRoutes[0];
 
   let transaction = {
     blockchain: paymentRoute.blockchain,
-    to: transactionAddress({ paymentRoute }),
-    api: transactionApi({ paymentRoute }),
-    method: transactionMethod({ paymentRoute }),
-    params: transactionParams({ paymentRoute, exchangeRoute, event }),
+    to: transactionAddress({ paymentRoute, fee }),
+    api: transactionApi({ paymentRoute, fee }),
+    method: transactionMethod({ paymentRoute, fee }),
+    params: transactionParams({ paymentRoute, exchangeRoute, event, fee }),
     value: transactionValue({ paymentRoute, exchangeRoute })
   };
 
@@ -66934,8 +67400,8 @@ let getTransaction = ({ paymentRoute, event })=> {
   return transaction
 };
 
-let transactionAddress = ({ paymentRoute })=> {
-  if(paymentRoute.directTransfer) {
+let transactionAddress = ({ paymentRoute, fee })=> {
+  if(paymentRoute.directTransfer && !fee) {
     if(paymentRoute.toToken.address == CONSTANTS$2[paymentRoute.blockchain].NATIVE) {
       return paymentRoute.toAddress
     } else {
@@ -66946,8 +67412,8 @@ let transactionAddress = ({ paymentRoute })=> {
   }
 };
 
-let transactionApi = ({ paymentRoute })=> {
-  if(paymentRoute.directTransfer) {
+let transactionApi = ({ paymentRoute, fee })=> {
+  if(paymentRoute.directTransfer && !fee) {
     if(paymentRoute.toToken.address == CONSTANTS$2[paymentRoute.blockchain].NATIVE) {
       return undefined
     } else {
@@ -66958,8 +67424,8 @@ let transactionApi = ({ paymentRoute })=> {
   }
 };
 
-let transactionMethod = ({ paymentRoute })=> {
-  if(paymentRoute.directTransfer) {
+let transactionMethod = ({ paymentRoute, fee })=> {
+  if(paymentRoute.directTransfer && !fee) {
     if(paymentRoute.toToken.address == CONSTANTS$2[paymentRoute.blockchain].NATIVE) {
       return undefined
     } else {
@@ -66970,8 +67436,8 @@ let transactionMethod = ({ paymentRoute })=> {
   }
 };
 
-let transactionParams = ({ paymentRoute, exchangeRoute, event })=> {
-  if(paymentRoute.directTransfer) {
+let transactionParams = ({ paymentRoute, exchangeRoute, event, fee })=> {
+  if(paymentRoute.directTransfer && !fee) {
     if(paymentRoute.toToken.address == CONSTANTS$2[paymentRoute.blockchain].NATIVE) {
       return undefined
     } else {
@@ -66980,9 +67446,9 @@ let transactionParams = ({ paymentRoute, exchangeRoute, event })=> {
   } else {
     return {
       path: transactionPath({ paymentRoute, exchangeRoute }),
-      amounts: transactionAmounts({ paymentRoute, exchangeRoute }),
-      addresses: transactionAddresses({ paymentRoute }),
-      plugins: transactionPlugins({ paymentRoute, exchangeRoute, event }),
+      amounts: transactionAmounts({ paymentRoute, exchangeRoute, fee }),
+      addresses: transactionAddresses({ paymentRoute, fee }),
+      plugins: transactionPlugins({ paymentRoute, exchangeRoute, event, fee }),
       data: []
     }
   }
@@ -66996,23 +67462,59 @@ let transactionPath = ({ paymentRoute, exchangeRoute })=> {
   }
 };
 
-let transactionAmounts = ({ paymentRoute, exchangeRoute })=> {
+let transactionAmounts = ({ paymentRoute, exchangeRoute, fee })=> {
+  let amounts;
   if(exchangeRoute) {
-    return [
+    amounts = [
       exchangeRoute.amountIn.toString(),
-      exchangeRoute.amountOutMin.toString(),
+      subtractFee({ amount: exchangeRoute.amountOutMin.toString(), paymentRoute, fee }),
       exchangeRoute.transaction.params.deadline
-    ]
+    ];
+  } else {
+    amounts = [
+      paymentRoute.toAmount, // from
+      subtractFee({ amount: paymentRoute.toAmount, paymentRoute, fee }) // to
+    ];
+  }
+  if(fee){
+    amounts[4] = transactionFeeAmount({ paymentRoute, fee });
+  }
+  for(var i = 0; i < amounts.length; i++) {
+    if(amounts[i] == undefined){ amounts[i] = '0'; }
+  }
+  return amounts
+};
+
+let subtractFee = ({ amount, paymentRoute, fee })=> {
+  if(fee) {
+    let feeAmount = transactionFeeAmount({ paymentRoute, fee });
+    return BigNumber.from(amount).sub(feeAmount).toString()
   } else {
-    return [paymentRoute.toAmount, paymentRoute.toAmount]
+    return amount
   }
 };
 
-let transactionAddresses = ({ paymentRoute })=> {
-  return [paymentRoute.fromAddress, paymentRoute.toAddress]
+let transactionFeeAmount = ({ paymentRoute, fee })=> {
+  if(typeof fee.amount == 'string' && fee.amount.match('%')) {
+    return BigNumber.from(paymentRoute.toAmount).div(100).mul(parseFloat(fee.amount)).toString()
+  } else if(typeof fee.amount == 'string') {
+    return fee.amount
+  } else if(typeof fee.amount == 'number') {
+    return parseUnits(fee.amount.toString(), paymentRoute.toDecimals).toString()
+  } else {
+    throw('Unknown fee amount type!')
+  }
 };
 
-let transactionPlugins = ({ paymentRoute, exchangeRoute, event })=> {
+let transactionAddresses = ({ paymentRoute, fee })=> {
+  if(fee) {
+    return [paymentRoute.fromAddress, fee.receiver, paymentRoute.toAddress]
+  } else {
+    return [paymentRoute.fromAddress, paymentRoute.toAddress]
+  }
+};
+
+let transactionPlugins = ({ paymentRoute, exchangeRoute, event, fee })=> {
   let paymentPlugins = [];
 
   if(exchangeRoute) {
@@ -67040,6 +67542,10 @@ let transactionPlugins = ({ paymentRoute, exchangeRoute, event })=> {
     paymentPlugins.push(plugins[paymentRoute.blockchain].payment.address);
   }
 
+  if(fee) {
+    paymentPlugins.push(plugins[paymentRoute.blockchain].paymentFee.address);
+  }
+
   return paymentPlugins
 };
 
@@ -67057,11 +67563,12 @@ let transactionValue = ({ paymentRoute, exchangeRoute })=> {
 
 function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 class PaymentRoute {
-  constructor({ blockchain, fromToken, toToken, toAmount, fromAddress, toAddress, toContract }) {
+  constructor({ blockchain, fromToken, toToken, toDecimals, toAmount, fromAddress, toAddress, toContract }) {
     this.blockchain = blockchain;
     this.fromToken = fromToken;
     this.fromBalance = 0;
     this.toToken = toToken;
+    this.toDecimals = toDecimals;
     this.toAmount = _optionalChain([toAmount, 'optionalAccess', _ => _.toString, 'call', _2 => _2()]);
     this.fromAddress = fromAddress;
     this.toAddress = toAddress;
@@ -67120,38 +67627,32 @@ async function getAllAssets({ accept, apiKey, whitelist }) {
 }
 
 function convertToRoutes({ tokens, accept }) {
-
-  return tokens.map((fromToken)=>{
+  return Promise.all(tokens.map(async (fromToken)=>{
     let relevantConfigurations = accept.filter((configuration)=>(configuration.blockchain == fromToken.blockchain));
-    return relevantConfigurations.map((configuration)=>{
+    return Promise.all(relevantConfigurations.map(async (configuration)=>{
       let blockchain = configuration.blockchain;
       let toToken = new Token({ blockchain, address: configuration.token });
+      let toDecimals = await toToken.decimals();
+      let toAmount = (await toToken.BigNumber(configuration.amount)).toString();
       return new PaymentRoute({
         blockchain,
         fromToken: fromToken,
         toToken: toToken,
-        toAmount: configuration.amount,
+        toAmount: toAmount,
+        toDecimals: toDecimals,
         fromAddress: configuration.fromAddress,
         toAddress: configuration.toAddress,
         toContract: configuration.toContract
       })
-    })
-  }).flat()
+    }))
+  })).then((routes)=> routes.flat())
 }
 
-async function convertToAmounts(routes) {
-  return await Promise.all(routes.map(async (route)=>{
-    route.toAmount = (await route.toToken.BigNumber(route.toAmount)).toString();
-    return route
-  }))
-}
-
-async function route({ accept, whitelist, blacklist, apiKey, event }) {
+async function route({ accept, whitelist, blacklist, apiKey, event, fee }) {
   let paymentRoutes = getAllAssets({ accept, whitelist, apiKey })
     .then((assets)=>filterBlacklistedAssets({ assets, blacklist }))
     .then(assetsToTokens)
     .then((tokens) => convertToRoutes({ tokens, accept }))
-    .then(convertToAmounts)
     .then(addDirectTransferStatus)
     .then(addExchangeRoutes)
     .then(filterExchangeRoutesWithoutPlugin)
@@ -67160,7 +67661,7 @@ async function route({ accept, whitelist, blacklist, apiKey, event }) {
     .then(filterInsufficientBalance)
     .then(addApproval)
     .then(sortPaymentRoutes)
-    .then((routes)=>addTransactions({ routes, event }))
+    .then((routes)=>addTransactions({ routes, event, fee }))
     .then(addFromAmount)
     .then(filterDuplicateFromTokens);
 
@@ -67283,7 +67784,7 @@ let addDirectTransferStatus = (routes) => {
 
 let addFromAmount = (routes)=> {
   return routes.map((route)=>{
-    if(route.directTransfer) {
+    if(route.directTransfer && !route.fee) {
       if(route.fromToken.address.toLowerCase() == CONSTANTS$2[route.blockchain].NATIVE.toLowerCase()) {
         route.fromAmount = route.transaction.value;
       } else {
@@ -67357,10 +67858,11 @@ let sortPaymentRoutes = (routes) => {
   })
 };
 
-let addTransactions = ({ routes, event }) => {
+let addTransactions = ({ routes, event, fee }) => {
   return routes.map((route)=>{
-    route.transaction = getTransaction({ paymentRoute: route, event });
+    route.transaction = getTransaction({ paymentRoute: route, event, fee });
     route.event = !route.directTransfer;
+    route.fee = !!fee;
     return route
   })
 };
@@ -67414,6 +67916,7 @@ var PaymentRoutingProvider = (function (props) {
       whitelist: props.whitelist,
       blacklist: props.blacklist,
       event: props.event,
+      fee: props.fee,
       apiKey: apiKey
     }).then(function (routes) {
       if (routes.length == 0) {
@@ -70752,7 +71255,8 @@ var PaymentAmountRoutingProvider = (function (props) {
     whitelist: props.whitelist,
     blacklist: props.blacklist,
     event: props.event,
-    setMaxRoute: setMaxRoute
+    setMaxRoute: setMaxRoute,
+    fee: props.fee
   }, props.children));
 });
 
@@ -70945,12 +71449,12 @@ var preflight$1 = /*#__PURE__*/function () {
 
 var Payment = /*#__PURE__*/function () {
   var _ref4 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee2(_ref3) {
-    var accept, amount, event, sent, confirmed, failed, error, critical, style, whitelist, blacklist, providers, currency, connected, closed, track, document, unmount;
+    var accept, amount, event, sent, confirmed, failed, error, critical, style, whitelist, blacklist, providers, currency, connected, closed, track, fee, document, unmount;
     return regenerator.wrap(function _callee2$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            accept = _ref3.accept, amount = _ref3.amount, event = _ref3.event, sent = _ref3.sent, confirmed = _ref3.confirmed, failed = _ref3.failed, error = _ref3.error, critical = _ref3.critical, style = _ref3.style, whitelist = _ref3.whitelist, blacklist = _ref3.blacklist, providers = _ref3.providers, currency = _ref3.currency, connected = _ref3.connected, closed = _ref3.closed, track = _ref3.track, document = _ref3.document;
+            accept = _ref3.accept, amount = _ref3.amount, event = _ref3.event, sent = _ref3.sent, confirmed = _ref3.confirmed, failed = _ref3.failed, error = _ref3.error, critical = _ref3.critical, style = _ref3.style, whitelist = _ref3.whitelist, blacklist = _ref3.blacklist, providers = _ref3.providers, currency = _ref3.currency, connected = _ref3.connected, closed = _ref3.closed, track = _ref3.track, fee = _ref3.fee, document = _ref3.document;
             _context2.prev = 1;
             _context2.next = 4;
             return preflight$1({
@@ -70980,7 +71484,8 @@ var Payment = /*#__PURE__*/function () {
                     whitelist: whitelist,
                     blacklist: blacklist,
                     providers: providers,
-                    track: track
+                    track: track,
+                    fee: fee
                   }
                 }, /*#__PURE__*/react.createElement(UpdatableProvider, null, /*#__PURE__*/react.createElement(ClosableProvider, {
                   unmount: unmount
@@ -70995,7 +71500,8 @@ var Payment = /*#__PURE__*/function () {
                   accept: accept,
                   whitelist: whitelist,
                   blacklist: blacklist,
-                  event: event
+                  event: event,
+                  fee: fee
                 }, /*#__PURE__*/react.createElement(TrackingProvider, {
                   document: ensureDocument(document)
                 }, /*#__PURE__*/react.createElement(PaymentProvider, {