refactor: HL EVM signing via sonirico/go-hyperliquid SDK

hl_helper/node_modules/ethers/lib.esm/README.md

@@ -0,0 +1,16 @@
+ESM Files
+=========
+
+The contents of this folder are for using `import` in ESM
+projects.
+
+
+Notes
+-----
+
+The contents are generated via the `npm run build` target
+using `tsc` and the `/tsconfig.esm.json` configuration.
+
+Do not modify the files in this folder. They are deleted on `build-clean`.
+
+To modify this `README.md`, see the `/output/post-build/lib.esm`.

hl_helper/node_modules/ethers/lib.esm/_version.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  The current version of Ethers.
+ */
+export declare const version: string;
+//# sourceMappingURL=_version.d.ts.map

hl_helper/node_modules/ethers/lib.esm/_version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_version.d.ts","sourceRoot":"","sources":["../src.ts/_version.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAiB,CAAC"}

hl_helper/node_modules/ethers/lib.esm/_version.js

@@ -0,0 +1,6 @@
+/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
+/**
+ *  The current version of Ethers.
+ */
+export const version = "6.16.0";
+//# sourceMappingURL=_version.js.map

hl_helper/node_modules/ethers/lib.esm/_version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_version.js","sourceRoot":"","sources":["../src.ts/_version.ts"],"names":[],"mappings":"AAAA,mEAAmE;AAEnE;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAW,QAAQ,CAAC"}

hl_helper/node_modules/ethers/lib.esm/abi/abi-coder.d.ts

@@ -0,0 +1,61 @@
+/**
+ *  When sending values to or receiving values from a [[Contract]], the
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
+ *
+ *  The AbiCoder provides a utility to encode values to ABI data and
+ *  decode values from ABI data.
+ *
+ *  Most of the time, developers should favour the [[Contract]] class,
+ *  which further abstracts a lot of the finer details of ABI data.
+ *
+ *  @_section api/abi/abi-coder:ABI Encoding
+ */
+import { Result } from "./coders/abstract-coder.js";
+import { ParamType } from "./fragments.js";
+import type { BytesLike, CallExceptionAction, CallExceptionError } from "../utils/index.js";
+/**
+ *  The **AbiCoder** is a low-level class responsible for encoding JavaScript
+ *  values into binary data and decoding binary data into JavaScript values.
+ */
+export declare class AbiCoder {
+    #private;
+    /**
+     *  Get the default values for the given %%types%%.
+     *
+     *  For example, a ``uint`` is by default ``0`` and ``bool``
+     *  is by default ``false``.
+     */
+    getDefaultValue(types: ReadonlyArray<string | ParamType>): Result;
+    /**
+     *  Encode the %%values%% as the %%types%% into ABI data.
+     *
+     *  @returns DataHexstring
+     */
+    encode(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): string;
+    /**
+     *  Decode the ABI %%data%% as the %%types%% into values.
+     *
+     *  If %%loose%% decoding is enabled, then strict padding is
+     *  not enforced. Some older versions of Solidity incorrectly
+     *  padded event data emitted from ``external`` functions.
+     */
+    decode(types: ReadonlyArray<string | ParamType>, data: BytesLike, loose?: boolean): Result;
+    static _setDefaultMaxInflation(value: number): void;
+    /**
+     *  Returns the shared singleton instance of a default [[AbiCoder]].
+     *
+     *  On the first call, the instance is created internally.
+     */
+    static defaultAbiCoder(): AbiCoder;
+    /**
+     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+     *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+     *  the Transaction %%tx%%.
+     */
+    static getBuiltinCallException(action: CallExceptionAction, tx: {
+        to?: null | string;
+        from?: null | string;
+        data?: string;
+    }, data: null | BytesLike): CallExceptionError;
+}
+//# sourceMappingURL=abi-coder.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/abi-coder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi-coder.d.ts","sourceRoot":"","sources":["../../src.ts/abi/abi-coder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,OAAO,EAAiB,MAAM,EAAU,MAAM,4BAA4B,CAAC;AAU3E,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAK3C,OAAO,KAAK,EACR,SAAS,EACT,mBAAmB,EAAE,kBAAkB,EAC1C,MAAM,mBAAmB,CAAC;AAuF3B;;;GAGG;AACH,qBAAa,QAAQ;;IA4CjB;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM;IAMjE;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,MAAM;IAWpF;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM;IAM1F,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKnD;;;;OAIG;IACH,MAAM,CAAC,eAAe,IAAI,QAAQ;IAOlC;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAAC,MAAM,EAAE,mBAAmB,EAAE,EAAE,EAAE;QAAE,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,kBAAkB;CAG3K"}

hl_helper/node_modules/ethers/lib.esm/abi/abi-coder.js

@@ -0,0 +1,206 @@
+/**
+ *  When sending values to or receiving values from a [[Contract]], the
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
+ *
+ *  The AbiCoder provides a utility to encode values to ABI data and
+ *  decode values from ABI data.
+ *
+ *  Most of the time, developers should favour the [[Contract]] class,
+ *  which further abstracts a lot of the finer details of ABI data.
+ *
+ *  @_section api/abi/abi-coder:ABI Encoding
+ */
+// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI
+import { assertArgumentCount, assertArgument } from "../utils/index.js";
+import { Reader, Writer } from "./coders/abstract-coder.js";
+import { AddressCoder } from "./coders/address.js";
+import { ArrayCoder } from "./coders/array.js";
+import { BooleanCoder } from "./coders/boolean.js";
+import { BytesCoder } from "./coders/bytes.js";
+import { FixedBytesCoder } from "./coders/fixed-bytes.js";
+import { NullCoder } from "./coders/null.js";
+import { NumberCoder } from "./coders/number.js";
+import { StringCoder } from "./coders/string.js";
+import { TupleCoder } from "./coders/tuple.js";
+import { ParamType } from "./fragments.js";
+import { getAddress } from "../address/index.js";
+import { getBytes, hexlify, makeError } from "../utils/index.js";
+// https://docs.soliditylang.org/en/v0.8.17/control-structures.html
+const PanicReasons = new Map();
+PanicReasons.set(0x00, "GENERIC_PANIC");
+PanicReasons.set(0x01, "ASSERT_FALSE");
+PanicReasons.set(0x11, "OVERFLOW");
+PanicReasons.set(0x12, "DIVIDE_BY_ZERO");
+PanicReasons.set(0x21, "ENUM_RANGE_ERROR");
+PanicReasons.set(0x22, "BAD_STORAGE_DATA");
+PanicReasons.set(0x31, "STACK_UNDERFLOW");
+PanicReasons.set(0x32, "ARRAY_RANGE_ERROR");
+PanicReasons.set(0x41, "OUT_OF_MEMORY");
+PanicReasons.set(0x51, "UNINITIALIZED_FUNCTION_CALL");
+const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/);
+const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/);
+let defaultCoder = null;
+let defaultMaxInflation = 1024;
+function getBuiltinCallException(action, tx, data, abiCoder) {
+    let message = "missing revert data";
+    let reason = null;
+    const invocation = null;
+    let revert = null;
+    if (data) {
+        message = "execution reverted";
+        const bytes = getBytes(data);
+        data = hexlify(data);
+        if (bytes.length === 0) {
+            message += " (no data present; likely require(false) occurred";
+            reason = "require(false)";
+        }
+        else if (bytes.length % 32 !== 4) {
+            message += " (could not decode reason; invalid data length)";
+        }
+        else if (hexlify(bytes.slice(0, 4)) === "0x08c379a0") {
+            // Error(string)
+            try {
+                reason = abiCoder.decode(["string"], bytes.slice(4))[0];
+                revert = {
+                    signature: "Error(string)",
+                    name: "Error",
+                    args: [reason]
+                };
+                message += `: ${JSON.stringify(reason)}`;
+            }
+            catch (error) {
+                message += " (could not decode reason; invalid string data)";
+            }
+        }
+        else if (hexlify(bytes.slice(0, 4)) === "0x4e487b71") {
+            // Panic(uint256)
+            try {
+                const code = Number(abiCoder.decode(["uint256"], bytes.slice(4))[0]);
+                revert = {
+                    signature: "Panic(uint256)",
+                    name: "Panic",
+                    args: [code]
+                };
+                reason = `Panic due to ${PanicReasons.get(code) || "UNKNOWN"}(${code})`;
+                message += `: ${reason}`;
+            }
+            catch (error) {
+                message += " (could not decode panic code)";
+            }
+        }
+        else {
+            message += " (unknown custom error)";
+        }
+    }
+    const transaction = {
+        to: (tx.to ? getAddress(tx.to) : null),
+        data: (tx.data || "0x")
+    };
+    if (tx.from) {
+        transaction.from = getAddress(tx.from);
+    }
+    return makeError(message, "CALL_EXCEPTION", {
+        action, data, reason, transaction, invocation, revert
+    });
+}
+/**
+ *  The **AbiCoder** is a low-level class responsible for encoding JavaScript
+ *  values into binary data and decoding binary data into JavaScript values.
+ */
+export class AbiCoder {
+    #getCoder(param) {
+        if (param.isArray()) {
+            return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name);
+        }
+        if (param.isTuple()) {
+            return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name);
+        }
+        switch (param.baseType) {
+            case "address":
+                return new AddressCoder(param.name);
+            case "bool":
+                return new BooleanCoder(param.name);
+            case "string":
+                return new StringCoder(param.name);
+            case "bytes":
+                return new BytesCoder(param.name);
+            case "":
+                return new NullCoder(param.name);
+        }
+        // u?int[0-9]*
+        let match = param.type.match(paramTypeNumber);
+        if (match) {
+            let size = parseInt(match[2] || "256");
+            assertArgument(size !== 0 && size <= 256 && (size % 8) === 0, "invalid " + match[1] + " bit length", "param", param);
+            return new NumberCoder(size / 8, (match[1] === "int"), param.name);
+        }
+        // bytes[0-9]+
+        match = param.type.match(paramTypeBytes);
+        if (match) {
+            let size = parseInt(match[1]);
+            assertArgument(size !== 0 && size <= 32, "invalid bytes length", "param", param);
+            return new FixedBytesCoder(size, param.name);
+        }
+        assertArgument(false, "invalid type", "type", param.type);
+    }
+    /**
+     *  Get the default values for the given %%types%%.
+     *
+     *  For example, a ``uint`` is by default ``0`` and ``bool``
+     *  is by default ``false``.
+     */
+    getDefaultValue(types) {
+        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.defaultValue();
+    }
+    /**
+     *  Encode the %%values%% as the %%types%% into ABI data.
+     *
+     *  @returns DataHexstring
+     */
+    encode(types, values) {
+        assertArgumentCount(values.length, types.length, "types/values length mismatch");
+        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));
+        const coder = (new TupleCoder(coders, "_"));
+        const writer = new Writer();
+        coder.encode(writer, values);
+        return writer.data;
+    }
+    /**
+     *  Decode the ABI %%data%% as the %%types%% into values.
+     *
+     *  If %%loose%% decoding is enabled, then strict padding is
+     *  not enforced. Some older versions of Solidity incorrectly
+     *  padded event data emitted from ``external`` functions.
+     */
+    decode(types, data, loose) {
+        const coders = types.map((type) => this.#getCoder(ParamType.from(type)));
+        const coder = new TupleCoder(coders, "_");
+        return coder.decode(new Reader(data, loose, defaultMaxInflation));
+    }
+    static _setDefaultMaxInflation(value) {
+        assertArgument(typeof (value) === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
+        defaultMaxInflation = value;
+    }
+    /**
+     *  Returns the shared singleton instance of a default [[AbiCoder]].
+     *
+     *  On the first call, the instance is created internally.
+     */
+    static defaultAbiCoder() {
+        if (defaultCoder == null) {
+            defaultCoder = new AbiCoder();
+        }
+        return defaultCoder;
+    }
+    /**
+     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+     *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+     *  the Transaction %%tx%%.
+     */
+    static getBuiltinCallException(action, tx, data) {
+        return getBuiltinCallException(action, tx, data, AbiCoder.defaultAbiCoder());
+    }
+}
+//# sourceMappingURL=abi-coder.js.map

hl_helper/node_modules/ethers/lib.esm/abi/bytes32.d.ts

@@ -0,0 +1,15 @@
+/**
+ *  About bytes32 strings...
+ *
+ *  @_docloc: api/utils:Bytes32 Strings
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Encodes %%text%% as a Bytes32 string.
+ */
+export declare function encodeBytes32String(text: string): string;
+/**
+ *  Encodes the Bytes32-encoded %%bytes%% into a string.
+ */
+export declare function decodeBytes32String(_bytes: BytesLike): string;
+//# sourceMappingURL=bytes32.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/bytes32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes32.d.ts","sourceRoot":"","sources":["../../src.ts/abi/bytes32.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAUxD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAa7D"}

hl_helper/node_modules/ethers/lib.esm/abi/bytes32.js

@@ -0,0 +1,40 @@
+/**
+ *  About bytes32 strings...
+ *
+ *  @_docloc: api/utils:Bytes32 Strings
+ */
+import { getBytes, toUtf8Bytes, toUtf8String, zeroPadBytes } from "../utils/index.js";
+/**
+ *  Encodes %%text%% as a Bytes32 string.
+ */
+export function encodeBytes32String(text) {
+    // Get the bytes
+    const bytes = toUtf8Bytes(text);
+    // Check we have room for null-termination
+    if (bytes.length > 31) {
+        throw new Error("bytes32 string must be less than 32 bytes");
+    }
+    // Zero-pad (implicitly null-terminates)
+    return zeroPadBytes(bytes, 32);
+}
+/**
+ *  Encodes the Bytes32-encoded %%bytes%% into a string.
+ */
+export function decodeBytes32String(_bytes) {
+    const data = getBytes(_bytes, "bytes");
+    // Must be 32 bytes with a null-termination
+    if (data.length !== 32) {
+        throw new Error("invalid bytes32 - not 32 bytes long");
+    }
+    if (data[31] !== 0) {
+        throw new Error("invalid bytes32 string - no null terminator");
+    }
+    // Find the null termination
+    let length = 31;
+    while (data[length - 1] === 0) {
+        length--;
+    }
+    // Determine the string value
+    return toUtf8String(data.slice(0, length));
+}
+//# sourceMappingURL=bytes32.js.map

hl_helper/node_modules/ethers/lib.esm/abi/bytes32.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes32.js","sourceRoot":"","sources":["../../src.ts/abi/bytes32.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACH,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EACpD,MAAM,mBAAmB,CAAC;AAI3B;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAY;IAE5C,gBAAgB;IAChB,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IAEhC,0CAA0C;IAC1C,IAAI,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;KAAE;IAExF,wCAAwC;IACxC,OAAO,YAAY,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AACnC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAiB;IACjD,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEvC,2CAA2C;IAC3C,IAAI,IAAI,CAAC,MAAM,KAAK,EAAE,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;KAAE;IACnF,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;KAAE;IAEvF,4BAA4B;IAC5B,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE;QAAE,MAAM,EAAE,CAAC;KAAE;IAE5C,6BAA6B;IAC7B,OAAO,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC/C,CAAC"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/abstract-coder.d.ts

@@ -0,0 +1,124 @@
+import type { BigNumberish, BytesLike } from "../../utils/index.js";
+/**
+ * @_ignore:
+ */
+export declare const WordSize: number;
+/**
+ *  A [[Result]] is a sub-class of Array, which allows accessing any
+ *  of its values either positionally by its index or, if keys are
+ *  provided by its name.
+ *
+ *  @_docloc: api/abi
+ */
+export declare class Result extends Array<any> {
+    #private;
+    [K: string | number]: any;
+    /**
+     *  @private
+     */
+    constructor(...args: Array<any>);
+    /**
+     *  Returns the Result as a normal Array. If %%deep%%, any children
+     *  which are Result objects are also converted to a normal Array.
+     *
+     *  This will throw if there are any outstanding deferred
+     *  errors.
+     */
+    toArray(deep?: boolean): Array<any>;
+    /**
+     *  Returns the Result as an Object with each name-value pair. If
+     *  %%deep%%, any children which are Result objects are also
+     *  converted to an Object.
+     *
+     *  This will throw if any value is unnamed, or if there are
+     *  any outstanding deferred errors.
+     */
+    toObject(deep?: boolean): Record<string, any>;
+    /**
+     *  @_ignore
+     */
+    slice(start?: number | undefined, end?: number | undefined): Result;
+    /**
+     *  @_ignore
+     */
+    filter(callback: (el: any, index: number, array: Result) => boolean, thisArg?: any): Result;
+    /**
+     *  @_ignore
+     */
+    map<T extends any = any>(callback: (el: any, index: number, array: Result) => T, thisArg?: any): Array<T>;
+    /**
+     *  Returns the value for %%name%%.
+     *
+     *  Since it is possible to have a key whose name conflicts with
+     *  a method on a [[Result]] or its superclass Array, or any
+     *  JavaScript keyword, this ensures all named values are still
+     *  accessible by name.
+     */
+    getValue(name: string): any;
+    /**
+     *  Creates a new [[Result]] for %%items%% with each entry
+     *  also accessible by its corresponding name in %%keys%%.
+     */
+    static fromItems(items: Array<any>, keys?: Array<null | string>): Result;
+}
+/**
+ *  Returns all errors found in a [[Result]].
+ *
+ *  Since certain errors encountered when creating a [[Result]] do
+ *  not impact the ability to continue parsing data, they are
+ *  deferred until they are actually accessed. Hence a faulty string
+ *  in an Event that is never used does not impact the program flow.
+ *
+ *  However, sometimes it may be useful to access, identify or
+ *  validate correctness of a [[Result]].
+ *
+ *  @_docloc api/abi
+ */
+export declare function checkResultErrors(result: Result): Array<{
+    path: Array<string | number>;
+    error: Error;
+}>;
+/**
+ *  @_ignore
+ */
+export declare abstract class Coder {
+    readonly name: string;
+    readonly type: string;
+    readonly localName: string;
+    readonly dynamic: boolean;
+    constructor(name: string, type: string, localName: string, dynamic: boolean);
+    _throwError(message: string, value: any): never;
+    abstract encode(writer: Writer, value: any): number;
+    abstract decode(reader: Reader): any;
+    abstract defaultValue(): any;
+}
+/**
+ *  @_ignore
+ */
+export declare class Writer {
+    #private;
+    constructor();
+    get data(): string;
+    get length(): number;
+    appendWriter(writer: Writer): number;
+    writeBytes(value: BytesLike): number;
+    writeValue(value: BigNumberish): number;
+    writeUpdatableValue(): (value: BigNumberish) => void;
+}
+/**
+ *  @_ignore
+ */
+export declare class Reader {
+    #private;
+    readonly allowLoose: boolean;
+    constructor(data: BytesLike, allowLoose?: boolean, maxInflation?: number);
+    get data(): string;
+    get dataLength(): number;
+    get consumed(): number;
+    get bytes(): Uint8Array;
+    subReader(offset: number): Reader;
+    readBytes(length: number, loose?: boolean): Uint8Array;
+    readValue(): bigint;
+    readIndex(): number;
+}
+//# sourceMappingURL=abstract-coder.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/abstract-coder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-coder.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/abstract-coder.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAW,CAAC;AA+CnC;;;;;;GAMG;AACH,qBAAa,MAAO,SAAQ,KAAK,CAAC,GAAG,CAAC;;IAMlC,CAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAI,GAAG,CAAA;IAE3B;;OAEG;gBACS,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC;IA+F/B;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC,GAAG,CAAC;IAYnC;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAY7C;;OAEG;IACH,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM;IAyBnE;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,MAAM;IAmB3F;;OAEG;IACH,GAAG,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC;IAezG;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG;IAa3B;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,EAAE,KAAK,CAAC,IAAI,GAAG,MAAM,CAAC,GAAG,MAAM;CAG3E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CAqBvG;AAeD;;GAEG;AACH,8BAAsB,KAAK;IAIvB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;IAIvB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;IAIvB,QAAQ,CAAC,SAAS,EAAG,MAAM,CAAC;IAK5B,QAAQ,CAAC,OAAO,EAAG,OAAO,CAAC;gBAEf,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAM3E,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK;IAI/C,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,MAAM;IACnD,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;IAEpC,QAAQ,CAAC,YAAY,IAAI,GAAG;CAC/B;AAED;;GAEG;AACH,qBAAa,MAAM;;;IAUf,IAAI,IAAI,IAAI,MAAM,CAEjB;IACD,IAAI,MAAM,IAAI,MAAM,CAA6B;IAQjD,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAKpC,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM;IAUpC,UAAU,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM;IAMvC,mBAAmB,IAAI,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI;CAQvD;AAED;;GAEG;AACH,qBAAa,MAAM;;IAKf,QAAQ,CAAC,UAAU,EAAG,OAAO,CAAC;gBASlB,IAAI,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,EAAE,MAAM;IAWxE,IAAI,IAAI,IAAI,MAAM,CAAgC;IAClD,IAAI,UAAU,IAAI,MAAM,CAA8B;IACtD,IAAI,QAAQ,IAAI,MAAM,CAAyB;IAC/C,IAAI,KAAK,IAAI,UAAU,CAAuC;IAkC9D,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOjC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,UAAU;IAStD,SAAS,IAAI,MAAM;IAInB,SAAS,IAAI,MAAM;CAGtB"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/abstract-coder.js

@@ -0,0 +1,466 @@
+import { defineProperties, concat, getBytesCopy, getNumber, hexlify, toBeArray, toBigInt, toNumber, assert, assertArgument
+/*, isError*/
+ } from "../../utils/index.js";
+/**
+ * @_ignore:
+ */
+export const WordSize = 32;
+const Padding = new Uint8Array(WordSize);
+// Properties used to immediate pass through to the underlying object
+// - `then` is used to detect if an object is a Promise for await
+const passProperties = ["then"];
+const _guard = {};
+const resultNames = new WeakMap();
+function getNames(result) {
+    return resultNames.get(result);
+}
+function setNames(result, names) {
+    resultNames.set(result, names);
+}
+function throwError(name, error) {
+    const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);
+    wrapped.error = error;
+    throw wrapped;
+}
+function toObject(names, items, deep) {
+    if (names.indexOf(null) >= 0) {
+        return items.map((item, index) => {
+            if (item instanceof Result) {
+                return toObject(getNames(item), item, deep);
+            }
+            return item;
+        });
+    }
+    return names.reduce((accum, name, index) => {
+        let item = items.getValue(name);
+        if (!(name in accum)) {
+            if (deep && item instanceof Result) {
+                item = toObject(getNames(item), item, deep);
+            }
+            accum[name] = item;
+        }
+        return accum;
+    }, {});
+}
+/**
+ *  A [[Result]] is a sub-class of Array, which allows accessing any
+ *  of its values either positionally by its index or, if keys are
+ *  provided by its name.
+ *
+ *  @_docloc: api/abi
+ */
+export class Result extends Array {
+    // No longer used; but cannot be removed as it will remove the
+    // #private field from the .d.ts which may break backwards
+    // compatibility
+    #names;
+    /**
+     *  @private
+     */
+    constructor(...args) {
+        // To properly sub-class Array so the other built-in
+        // functions work, the constructor has to behave fairly
+        // well. So, in the event we are created via fromItems()
+        // we build the read-only Result object we want, but on
+        // any other input, we use the default constructor
+        // constructor(guard: any, items: Array<any>, keys?: Array<null | string>);
+        const guard = args[0];
+        let items = args[1];
+        let names = (args[2] || []).slice();
+        let wrap = true;
+        if (guard !== _guard) {
+            items = args;
+            names = [];
+            wrap = false;
+        }
+        // Can't just pass in ...items since an array of length 1
+        // is a special case in the super.
+        super(items.length);
+        items.forEach((item, index) => { this[index] = item; });
+        // Find all unique keys
+        const nameCounts = names.reduce((accum, name) => {
+            if (typeof (name) === "string") {
+                accum.set(name, (accum.get(name) || 0) + 1);
+            }
+            return accum;
+        }, (new Map()));
+        // Remove any key thats not unique
+        setNames(this, Object.freeze(items.map((item, index) => {
+            const name = names[index];
+            if (name != null && nameCounts.get(name) === 1) {
+                return name;
+            }
+            return null;
+        })));
+        // Dummy operations to prevent TypeScript from complaining
+        this.#names = [];
+        if (this.#names == null) {
+            void (this.#names);
+        }
+        if (!wrap) {
+            return;
+        }
+        // A wrapped Result is immutable
+        Object.freeze(this);
+        // Proxy indices and names so we can trap deferred errors
+        const proxy = new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (typeof (prop) === "string") {
+                    // Index accessor
+                    if (prop.match(/^[0-9]+$/)) {
+                        const index = getNumber(prop, "%index");
+                        if (index < 0 || index >= this.length) {
+                            throw new RangeError("out of result range");
+                        }
+                        const item = target[index];
+                        if (item instanceof Error) {
+                            throwError(`index ${index}`, item);
+                        }
+                        return item;
+                    }
+                    // Pass important checks (like `then` for Promise) through
+                    if (passProperties.indexOf(prop) >= 0) {
+                        return Reflect.get(target, prop, receiver);
+                    }
+                    const value = target[prop];
+                    if (value instanceof Function) {
+                        // Make sure functions work with private variables
+                        // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#no_private_property_forwarding
+                        return function (...args) {
+                            return value.apply((this === receiver) ? target : this, args);
+                        };
+                    }
+                    else if (!(prop in target)) {
+                        // Possible name accessor
+                        return target.getValue.apply((this === receiver) ? target : this, [prop]);
+                    }
+                }
+                return Reflect.get(target, prop, receiver);
+            }
+        });
+        setNames(proxy, getNames(this));
+        return proxy;
+    }
+    /**
+     *  Returns the Result as a normal Array. If %%deep%%, any children
+     *  which are Result objects are also converted to a normal Array.
+     *
+     *  This will throw if there are any outstanding deferred
+     *  errors.
+     */
+    toArray(deep) {
+        const result = [];
+        this.forEach((item, index) => {
+            if (item instanceof Error) {
+                throwError(`index ${index}`, item);
+            }
+            if (deep && item instanceof Result) {
+                item = item.toArray(deep);
+            }
+            result.push(item);
+        });
+        return result;
+    }
+    /**
+     *  Returns the Result as an Object with each name-value pair. If
+     *  %%deep%%, any children which are Result objects are also
+     *  converted to an Object.
+     *
+     *  This will throw if any value is unnamed, or if there are
+     *  any outstanding deferred errors.
+     */
+    toObject(deep) {
+        const names = getNames(this);
+        return names.reduce((accum, name, index) => {
+            assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", {
+                operation: "toObject()"
+            });
+            return toObject(names, this, deep);
+        }, {});
+    }
+    /**
+     *  @_ignore
+     */
+    slice(start, end) {
+        if (start == null) {
+            start = 0;
+        }
+        if (start < 0) {
+            start += this.length;
+            if (start < 0) {
+                start = 0;
+            }
+        }
+        if (end == null) {
+            end = this.length;
+        }
+        if (end < 0) {
+            end += this.length;
+            if (end < 0) {
+                end = 0;
+            }
+        }
+        if (end > this.length) {
+            end = this.length;
+        }
+        const _names = getNames(this);
+        const result = [], names = [];
+        for (let i = start; i < end; i++) {
+            result.push(this[i]);
+            names.push(_names[i]);
+        }
+        return new Result(_guard, result, names);
+    }
+    /**
+     *  @_ignore
+     */
+    filter(callback, thisArg) {
+        const _names = getNames(this);
+        const result = [], names = [];
+        for (let i = 0; i < this.length; i++) {
+            const item = this[i];
+            if (item instanceof Error) {
+                throwError(`index ${i}`, item);
+            }
+            if (callback.call(thisArg, item, i, this)) {
+                result.push(item);
+                names.push(_names[i]);
+            }
+        }
+        return new Result(_guard, result, names);
+    }
+    /**
+     *  @_ignore
+     */
+    map(callback, thisArg) {
+        const result = [];
+        for (let i = 0; i < this.length; i++) {
+            const item = this[i];
+            if (item instanceof Error) {
+                throwError(`index ${i}`, item);
+            }
+            result.push(callback.call(thisArg, item, i, this));
+        }
+        return result;
+    }
+    /**
+     *  Returns the value for %%name%%.
+     *
+     *  Since it is possible to have a key whose name conflicts with
+     *  a method on a [[Result]] or its superclass Array, or any
+     *  JavaScript keyword, this ensures all named values are still
+     *  accessible by name.
+     */
+    getValue(name) {
+        const index = getNames(this).indexOf(name);
+        if (index === -1) {
+            return undefined;
+        }
+        const value = this[index];
+        if (value instanceof Error) {
+            throwError(`property ${JSON.stringify(name)}`, value.error);
+        }
+        return value;
+    }
+    /**
+     *  Creates a new [[Result]] for %%items%% with each entry
+     *  also accessible by its corresponding name in %%keys%%.
+     */
+    static fromItems(items, keys) {
+        return new Result(_guard, items, keys);
+    }
+}
+/**
+ *  Returns all errors found in a [[Result]].
+ *
+ *  Since certain errors encountered when creating a [[Result]] do
+ *  not impact the ability to continue parsing data, they are
+ *  deferred until they are actually accessed. Hence a faulty string
+ *  in an Event that is never used does not impact the program flow.
+ *
+ *  However, sometimes it may be useful to access, identify or
+ *  validate correctness of a [[Result]].
+ *
+ *  @_docloc api/abi
+ */
+export function checkResultErrors(result) {
+    // Find the first error (if any)
+    const errors = [];
+    const checkErrors = function (path, object) {
+        if (!Array.isArray(object)) {
+            return;
+        }
+        for (let key in object) {
+            const childPath = path.slice();
+            childPath.push(key);
+            try {
+                checkErrors(childPath, object[key]);
+            }
+            catch (error) {
+                errors.push({ path: childPath, error: error });
+            }
+        }
+    };
+    checkErrors([], result);
+    return errors;
+}
+function getValue(value) {
+    let bytes = toBeArray(value);
+    assert(bytes.length <= WordSize, "value out-of-bounds", "BUFFER_OVERRUN", { buffer: bytes, length: WordSize, offset: bytes.length });
+    if (bytes.length !== WordSize) {
+        bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));
+    }
+    return bytes;
+}
+/**
+ *  @_ignore
+ */
+export class Coder {
+    // The coder name:
+    //   - address, uint256, tuple, array, etc.
+    name;
+    // The fully expanded type, including composite types:
+    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.
+    type;
+    // The localName bound in the signature, in this example it is "baz":
+    //   - tuple(address foo, uint bar) baz
+    localName;
+    // Whether this type is dynamic:
+    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.
+    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)
+    dynamic;
+    constructor(name, type, localName, dynamic) {
+        defineProperties(this, { name, type, localName, dynamic }, {
+            name: "string", type: "string", localName: "string", dynamic: "boolean"
+        });
+    }
+    _throwError(message, value) {
+        assertArgument(false, message, this.localName, value);
+    }
+}
+/**
+ *  @_ignore
+ */
+export class Writer {
+    // An array of WordSize lengthed objects to concatenation
+    #data;
+    #dataLength;
+    constructor() {
+        this.#data = [];
+        this.#dataLength = 0;
+    }
+    get data() {
+        return concat(this.#data);
+    }
+    get length() { return this.#dataLength; }
+    #writeData(data) {
+        this.#data.push(data);
+        this.#dataLength += data.length;
+        return data.length;
+    }
+    appendWriter(writer) {
+        return this.#writeData(getBytesCopy(writer.data));
+    }
+    // Arrayish item; pad on the right to *nearest* WordSize
+    writeBytes(value) {
+        let bytes = getBytesCopy(value);
+        const paddingOffset = bytes.length % WordSize;
+        if (paddingOffset) {
+            bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
+        }
+        return this.#writeData(bytes);
+    }
+    // Numeric item; pad on the left *to* WordSize
+    writeValue(value) {
+        return this.#writeData(getValue(value));
+    }
+    // Inserts a numeric place-holder, returning a callback that can
+    // be used to asjust the value later
+    writeUpdatableValue() {
+        const offset = this.#data.length;
+        this.#data.push(Padding);
+        this.#dataLength += WordSize;
+        return (value) => {
+            this.#data[offset] = getValue(value);
+        };
+    }
+}
+/**
+ *  @_ignore
+ */
+export class Reader {
+    // Allows incomplete unpadded data to be read; otherwise an error
+    // is raised if attempting to overrun the buffer. This is required
+    // to deal with an old Solidity bug, in which event data for
+    // external (not public thoguh) was tightly packed.
+    allowLoose;
+    #data;
+    #offset;
+    #bytesRead;
+    #parent;
+    #maxInflation;
+    constructor(data, allowLoose, maxInflation) {
+        defineProperties(this, { allowLoose: !!allowLoose });
+        this.#data = getBytesCopy(data);
+        this.#bytesRead = 0;
+        this.#parent = null;
+        this.#maxInflation = (maxInflation != null) ? maxInflation : 1024;
+        this.#offset = 0;
+    }
+    get data() { return hexlify(this.#data); }
+    get dataLength() { return this.#data.length; }
+    get consumed() { return this.#offset; }
+    get bytes() { return new Uint8Array(this.#data); }
+    #incrementBytesRead(count) {
+        if (this.#parent) {
+            return this.#parent.#incrementBytesRead(count);
+        }
+        this.#bytesRead += count;
+        // Check for excessive inflation (see: #4537)
+        assert(this.#maxInflation < 1 || this.#bytesRead <= this.#maxInflation * this.dataLength, `compressed ABI data exceeds inflation ratio of ${this.#maxInflation} ( see: https:/\/github.com/ethers-io/ethers.js/issues/4537 )`, "BUFFER_OVERRUN", {
+            buffer: getBytesCopy(this.#data), offset: this.#offset,
+            length: count, info: {
+                bytesRead: this.#bytesRead,
+                dataLength: this.dataLength
+            }
+        });
+    }
+    #peekBytes(offset, length, loose) {
+        let alignedLength = Math.ceil(length / WordSize) * WordSize;
+        if (this.#offset + alignedLength > this.#data.length) {
+            if (this.allowLoose && loose && this.#offset + length <= this.#data.length) {
+                alignedLength = length;
+            }
+            else {
+                assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
+                    buffer: getBytesCopy(this.#data),
+                    length: this.#data.length,
+                    offset: this.#offset + alignedLength
+                });
+            }
+        }
+        return this.#data.slice(this.#offset, this.#offset + alignedLength);
+    }
+    // Create a sub-reader with the same underlying data, but offset
+    subReader(offset) {
+        const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);
+        reader.#parent = this;
+        return reader;
+    }
+    // Read bytes
+    readBytes(length, loose) {
+        let bytes = this.#peekBytes(0, length, !!loose);
+        this.#incrementBytesRead(length);
+        this.#offset += bytes.length;
+        // @TODO: Make sure the length..end bytes are all 0?
+        return bytes.slice(0, length);
+    }
+    // Read a numeric values
+    readValue() {
+        return toBigInt(this.readBytes(WordSize));
+    }
+    readIndex() {
+        return toNumber(this.readBytes(WordSize));
+    }
+}
+//# sourceMappingURL=abstract-coder.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/address.d.ts

@@ -0,0 +1,13 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class AddressCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: string | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=address.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/address.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;gBAEvB,SAAS,EAAE,MAAM;IAI7B,YAAY,IAAI,MAAM;IAItB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM;IAUtD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/address.js

@@ -0,0 +1,29 @@
+import { getAddress } from "../../address/index.js";
+import { toBeHex } from "../../utils/maths.js";
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class AddressCoder extends Coder {
+    constructor(localName) {
+        super("address", "address", localName, false);
+    }
+    defaultValue() {
+        return "0x0000000000000000000000000000000000000000";
+    }
+    encode(writer, _value) {
+        let value = Typed.dereference(_value, "string");
+        try {
+            value = getAddress(value);
+        }
+        catch (error) {
+            return this._throwError(error.message, _value);
+        }
+        return writer.writeValue(value);
+    }
+    decode(reader) {
+        return getAddress(toBeHex(reader.readValue(), 20));
+    }
+}
+//# sourceMappingURL=address.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAK5C;;GAEG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IAEnC,YAAY,SAAiB;QACzB,KAAK,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED,YAAY;QACR,OAAO,4CAA4C,CAAC;IACxD,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,MAAsB;QACzC,IAAI,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAChD,IAAI;YACA,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;SAC7B;QAAC,OAAO,KAAU,EAAE;YACjB,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;SAClD;QACD,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;IACvD,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/anonymous.d.ts

@@ -0,0 +1,15 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  Clones the functionality of an existing Coder, but without a localName
+ *
+ *  @_ignore
+ */
+export declare class AnonymousCoder extends Coder {
+    private coder;
+    constructor(coder: Coder);
+    defaultValue(): any;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=anonymous.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/anonymous.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymous.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/anonymous.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACrC,OAAO,CAAC,KAAK,CAAQ;gBAET,KAAK,EAAE,KAAK;IAKxB,YAAY,IAAI,GAAG;IAInB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,MAAM;IAI1C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/anonymous.js

@@ -0,0 +1,23 @@
+import { Coder } from "./abstract-coder.js";
+/**
+ *  Clones the functionality of an existing Coder, but without a localName
+ *
+ *  @_ignore
+ */
+export class AnonymousCoder extends Coder {
+    coder;
+    constructor(coder) {
+        super(coder.name, coder.type, "_", coder.dynamic);
+        this.coder = coder;
+    }
+    defaultValue() {
+        return this.coder.defaultValue();
+    }
+    encode(writer, value) {
+        return this.coder.encode(writer, value);
+    }
+    decode(reader) {
+        return this.coder.decode(reader);
+    }
+}
+//# sourceMappingURL=anonymous.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/anonymous.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymous.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/anonymous.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAI5C;;;;GAIG;AACH,MAAM,OAAO,cAAe,SAAQ,KAAK;IAC7B,KAAK,CAAQ;IAErB,YAAY,KAAY;QACpB,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;QAClD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;IAED,YAAY;QACR,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;IACrC,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,KAAU;QAC7B,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/array.d.ts

@@ -0,0 +1,25 @@
+import { Typed } from "../typed.js";
+import { Coder, Result, Writer } from "./abstract-coder.js";
+import type { Reader } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare function pack(writer: Writer, coders: ReadonlyArray<Coder>, values: Array<any> | {
+    [name: string]: any;
+}): number;
+/**
+ *  @_ignore
+ */
+export declare function unpack(reader: Reader, coders: ReadonlyArray<Coder>): Result;
+/**
+ *  @_ignore
+ */
+export declare class ArrayCoder extends Coder {
+    readonly coder: Coder;
+    readonly length: number;
+    constructor(coder: Coder, length: number, localName: string);
+    defaultValue(): Array<any>;
+    encode(writer: Writer, _value: Array<any> | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=array.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/array.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,KAAK,EAAE,MAAM,EAAY,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAGtE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD;;GAEG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG;IAAE,CAAE,IAAI,EAAE,MAAM,GAAI,GAAG,CAAA;CAAE,GAAG,MAAM,CA2DzH;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,MAAM,CAoD3E;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACjC,QAAQ,CAAC,KAAK,EAAG,KAAK,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAG,MAAM,CAAC;gBAEb,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAO3D,YAAY,IAAI,KAAK,CAAC,GAAG,CAAC;IAW1B,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,GAAG,MAAM;IAsB1D,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAkB9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/array.js

@@ -0,0 +1,159 @@
+import { defineProperties, isError, assert, assertArgument, assertArgumentCount } from "../../utils/index.js";
+import { Typed } from "../typed.js";
+import { Coder, Result, WordSize, Writer } from "./abstract-coder.js";
+import { AnonymousCoder } from "./anonymous.js";
+/**
+ *  @_ignore
+ */
+export function pack(writer, coders, values) {
+    let arrayValues = [];
+    if (Array.isArray(values)) {
+        arrayValues = values;
+    }
+    else if (values && typeof (values) === "object") {
+        let unique = {};
+        arrayValues = coders.map((coder) => {
+            const name = coder.localName;
+            assert(name, "cannot encode object for signature with missing names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+            assert(!unique[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+            unique[name] = true;
+            return values[name];
+        });
+    }
+    else {
+        assertArgument(false, "invalid tuple value", "tuple", values);
+    }
+    assertArgument(coders.length === arrayValues.length, "types/value length mismatch", "tuple", values);
+    let staticWriter = new Writer();
+    let dynamicWriter = new Writer();
+    let updateFuncs = [];
+    coders.forEach((coder, index) => {
+        let value = arrayValues[index];
+        if (coder.dynamic) {
+            // Get current dynamic offset (for the future pointer)
+            let dynamicOffset = dynamicWriter.length;
+            // Encode the dynamic value into the dynamicWriter
+            coder.encode(dynamicWriter, value);
+            // Prepare to populate the correct offset once we are done
+            let updateFunc = staticWriter.writeUpdatableValue();
+            updateFuncs.push((baseOffset) => {
+                updateFunc(baseOffset + dynamicOffset);
+            });
+        }
+        else {
+            coder.encode(staticWriter, value);
+        }
+    });
+    // Backfill all the dynamic offsets, now that we know the static length
+    updateFuncs.forEach((func) => { func(staticWriter.length); });
+    let length = writer.appendWriter(staticWriter);
+    length += writer.appendWriter(dynamicWriter);
+    return length;
+}
+/**
+ *  @_ignore
+ */
+export function unpack(reader, coders) {
+    let values = [];
+    let keys = [];
+    // A reader anchored to this base
+    let baseReader = reader.subReader(0);
+    coders.forEach((coder) => {
+        let value = null;
+        if (coder.dynamic) {
+            let offset = reader.readIndex();
+            let offsetReader = baseReader.subReader(offset);
+            try {
+                value = coder.decode(offsetReader);
+            }
+            catch (error) {
+                // Cannot recover from this
+                if (isError(error, "BUFFER_OVERRUN")) {
+                    throw error;
+                }
+                value = error;
+                value.baseType = coder.name;
+                value.name = coder.localName;
+                value.type = coder.type;
+            }
+        }
+        else {
+            try {
+                value = coder.decode(reader);
+            }
+            catch (error) {
+                // Cannot recover from this
+                if (isError(error, "BUFFER_OVERRUN")) {
+                    throw error;
+                }
+                value = error;
+                value.baseType = coder.name;
+                value.name = coder.localName;
+                value.type = coder.type;
+            }
+        }
+        if (value == undefined) {
+            throw new Error("investigate");
+        }
+        values.push(value);
+        keys.push(coder.localName || null);
+    });
+    return Result.fromItems(values, keys);
+}
+/**
+ *  @_ignore
+ */
+export class ArrayCoder extends Coder {
+    coder;
+    length;
+    constructor(coder, length, localName) {
+        const type = (coder.type + "[" + (length >= 0 ? length : "") + "]");
+        const dynamic = (length === -1 || coder.dynamic);
+        super("array", type, localName, dynamic);
+        defineProperties(this, { coder, length });
+    }
+    defaultValue() {
+        // Verifies the child coder is valid (even if the array is dynamic or 0-length)
+        const defaultChild = this.coder.defaultValue();
+        const result = [];
+        for (let i = 0; i < this.length; i++) {
+            result.push(defaultChild);
+        }
+        return result;
+    }
+    encode(writer, _value) {
+        const value = Typed.dereference(_value, "array");
+        if (!Array.isArray(value)) {
+            this._throwError("expected array value", value);
+        }
+        let count = this.length;
+        if (count === -1) {
+            count = value.length;
+            writer.writeValue(value.length);
+        }
+        assertArgumentCount(value.length, count, "coder array" + (this.localName ? (" " + this.localName) : ""));
+        let coders = [];
+        for (let i = 0; i < value.length; i++) {
+            coders.push(this.coder);
+        }
+        return pack(writer, coders, value);
+    }
+    decode(reader) {
+        let count = this.length;
+        if (count === -1) {
+            count = reader.readIndex();
+            // Check that there is *roughly* enough data to ensure
+            // stray random data is not being read as a length. Each
+            // slot requires at least 32 bytes for their value (or 32
+            // bytes as a link to the data). This could use a much
+            // tighter bound, but we are erroring on the side of safety.
+            assert(count * WordSize <= reader.dataLength, "insufficient data length", "BUFFER_OVERRUN", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });
+        }
+        let coders = [];
+        for (let i = 0; i < count; i++) {
+            coders.push(new AnonymousCoder(this.coder));
+        }
+        return unpack(reader, coders);
+    }
+}
+//# sourceMappingURL=array.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/boolean.d.ts

@@ -0,0 +1,13 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class BooleanCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): boolean;
+    encode(writer: Writer, _value: boolean | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=boolean.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;gBAEvB,SAAS,EAAE,MAAM;IAI7B,YAAY,IAAI,OAAO;IAIvB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM;IAKvD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/boolean.js

@@ -0,0 +1,21 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class BooleanCoder extends Coder {
+    constructor(localName) {
+        super("bool", "bool", localName, false);
+    }
+    defaultValue() {
+        return false;
+    }
+    encode(writer, _value) {
+        const value = Typed.dereference(_value, "bool");
+        return writer.writeValue(value ? 1 : 0);
+    }
+    decode(reader) {
+        return !!reader.readValue();
+    }
+}
+//# sourceMappingURL=boolean.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/boolean.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAI5C;;GAEG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IAEnC,YAAY,SAAiB;QACzB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,YAAY;QACR,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,MAAuB;QAC1C,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,CAAC,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;IAChC,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/bytes.d.ts

@@ -0,0 +1,19 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class DynamicBytesCoder extends Coder {
+    constructor(type: string, localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}
+/**
+ *  @_ignore
+ */
+export declare class BytesCoder extends DynamicBytesCoder {
+    constructor(localName: string);
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=bytes.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/bytes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;gBAC5B,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAI3C,YAAY,IAAI,MAAM;IAItB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,MAAM;IAO1C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B;AAED;;GAEG;AACH,qBAAa,UAAW,SAAQ,iBAAiB;gBACjC,SAAS,EAAE,MAAM;IAI7B,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/bytes.js

@@ -0,0 +1,34 @@
+import { getBytesCopy, hexlify } from "../../utils/index.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class DynamicBytesCoder extends Coder {
+    constructor(type, localName) {
+        super(type, type, localName, true);
+    }
+    defaultValue() {
+        return "0x";
+    }
+    encode(writer, value) {
+        value = getBytesCopy(value);
+        let length = writer.writeValue(value.length);
+        length += writer.writeBytes(value);
+        return length;
+    }
+    decode(reader) {
+        return reader.readBytes(reader.readIndex(), true);
+    }
+}
+/**
+ *  @_ignore
+ */
+export class BytesCoder extends DynamicBytesCoder {
+    constructor(localName) {
+        super("bytes", localName);
+    }
+    decode(reader) {
+        return hexlify(super.decode(reader));
+    }
+}
+//# sourceMappingURL=bytes.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE7D,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAK5C;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IACxC,YAAY,IAAY,EAAE,SAAiB;QACxC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;IAED,YAAY;QACR,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,KAAU;QAC7B,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7C,MAAM,IAAI,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACnC,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,CAAC;IACtD,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,iBAAiB;IAC7C,YAAY,SAAiB;QACzB,KAAK,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IACzC,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/fixed-bytes.d.ts

@@ -0,0 +1,15 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { BytesLike } from "../../utils/index.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class FixedBytesCoder extends Coder {
+    readonly size: number;
+    constructor(size: number, localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: BytesLike | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=fixed-bytes.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/fixed-bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-bytes.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/fixed-bytes.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;gBAEX,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAM3C,YAAY,IAAI,MAAM;IAItB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,KAAK,GAAG,MAAM;IAMzD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/fixed-bytes.js

@@ -0,0 +1,28 @@
+import { defineProperties, getBytesCopy, hexlify } from "../../utils/index.js";
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export class FixedBytesCoder extends Coder {
+    size;
+    constructor(size, localName) {
+        let name = "bytes" + String(size);
+        super(name, name, localName, false);
+        defineProperties(this, { size }, { size: "number" });
+    }
+    defaultValue() {
+        return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
+    }
+    encode(writer, _value) {
+        let data = getBytesCopy(Typed.dereference(_value, this.type));
+        if (data.length !== this.size) {
+            this._throwError("incorrect data length", _value);
+        }
+        return writer.writeBytes(data);
+    }
+    decode(reader) {
+        return hexlify(reader.readBytes(this.size));
+    }
+}
+//# sourceMappingURL=fixed-bytes.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/fixed-bytes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed-bytes.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/fixed-bytes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAE/E,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAO5C;;GAEG;AACH,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC7B,IAAI,CAAU;IAEvB,YAAY,IAAY,EAAE,SAAiB;QACvC,IAAI,IAAI,GAAG,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;QAClC,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QACpC,gBAAgB,CAAkB,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,YAAY;QACR,OAAO,CAAC,oEAAoE,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;IAClH,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,MAAyB;QAC5C,IAAI,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9D,IAAI,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,IAAI,EAAE;YAAE,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC;SAAE;QACrF,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAChD,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/null.d.ts

@@ -0,0 +1,12 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class NullCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): null;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=null.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/null.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAI1D;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;gBAEpB,SAAS,EAAE,MAAM;IAI7B,YAAY,IAAI,IAAI;IAIpB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,MAAM;IAK1C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAI9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/null.js

@@ -0,0 +1,24 @@
+import { Coder } from "./abstract-coder.js";
+const Empty = new Uint8Array([]);
+/**
+ *  @_ignore
+ */
+export class NullCoder extends Coder {
+    constructor(localName) {
+        super("null", "", localName, false);
+    }
+    defaultValue() {
+        return null;
+    }
+    encode(writer, value) {
+        if (value != null) {
+            this._throwError("not null", value);
+        }
+        return writer.writeBytes(Empty);
+    }
+    decode(reader) {
+        reader.readBytes(0);
+        return null;
+    }
+}
+//# sourceMappingURL=null.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/null.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/null.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAG5C,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,EAAG,CAAC,CAAC;AAElC;;GAEG;AACH,MAAM,OAAO,SAAU,SAAQ,KAAK;IAEhC,YAAY,SAAiB;QACzB,KAAK,CAAC,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,YAAY;QACR,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,KAAU;QAC7B,IAAI,KAAK,IAAI,IAAI,EAAE;YAAE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;SAAE;QAC3D,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACpB,OAAO,IAAI,CAAC;IAChB,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/number.d.ts

@@ -0,0 +1,16 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { BigNumberish } from "../../utils/index.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class NumberCoder extends Coder {
+    readonly size: number;
+    readonly signed: boolean;
+    constructor(size: number, signed: boolean, localName: string);
+    defaultValue(): number;
+    encode(writer: Writer, _value: BigNumberish | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=number.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/number.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAY,MAAM,qBAAqB,CAAC;AAEtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAO1D;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IAClC,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAG,OAAO,CAAC;gBAEd,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM;IAO5D,YAAY,IAAI,MAAM;IAItB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,KAAK,GAAG,MAAM;IAkB5D,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAS9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/number.js

@@ -0,0 +1,45 @@
+import { defineProperties, fromTwos, getBigInt, mask, toTwos } from "../../utils/index.js";
+import { Typed } from "../typed.js";
+import { Coder, WordSize } from "./abstract-coder.js";
+const BN_0 = BigInt(0);
+const BN_1 = BigInt(1);
+const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+/**
+ *  @_ignore
+ */
+export class NumberCoder extends Coder {
+    size;
+    signed;
+    constructor(size, signed, localName) {
+        const name = ((signed ? "int" : "uint") + (size * 8));
+        super(name, name, localName, false);
+        defineProperties(this, { size, signed }, { size: "number", signed: "boolean" });
+    }
+    defaultValue() {
+        return 0;
+    }
+    encode(writer, _value) {
+        let value = getBigInt(Typed.dereference(_value, this.type));
+        // Check bounds are safe for encoding
+        let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);
+        if (this.signed) {
+            let bounds = mask(maxUintValue, (this.size * 8) - 1);
+            if (value > bounds || value < -(bounds + BN_1)) {
+                this._throwError("value out-of-bounds", _value);
+            }
+            value = toTwos(value, 8 * WordSize);
+        }
+        else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {
+            this._throwError("value out-of-bounds", _value);
+        }
+        return writer.writeValue(value);
+    }
+    decode(reader) {
+        let value = mask(reader.readValue(), this.size * 8);
+        if (this.signed) {
+            value = fromTwos(value, this.size * 8);
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=number.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/number.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,gBAAgB,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EACtD,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAOtD,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AACvB,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AACvB,MAAM,cAAc,GAAG,MAAM,CAAC,oEAAoE,CAAC,CAAC;AAEpG;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IACzB,IAAI,CAAU;IACd,MAAM,CAAW;IAE1B,YAAY,IAAY,EAAE,MAAe,EAAE,SAAiB;QACxD,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAA,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC;QACrD,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;QAEpC,gBAAgB,CAAc,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;IACjG,CAAC;IAED,YAAY;QACR,OAAO,CAAC,CAAC;IACb,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,MAA4B;QAC/C,IAAI,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QAE5D,qCAAqC;QACrC,IAAI,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;QACtD,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,IAAI,MAAM,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACrD,IAAI,KAAK,GAAG,MAAM,IAAI,KAAK,GAAG,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE;gBAC5C,IAAI,CAAC,WAAW,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;aACnD;YACD,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC;SACvC;aAAM,IAAI,KAAK,GAAG,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE;YAClE,IAAI,CAAC,WAAW,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;SACnD;QAED,OAAO,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;QAEpD,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,KAAK,GAAG,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;SAC1C;QAED,OAAO,KAAK,CAAC;IACjB,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/string.d.ts

@@ -0,0 +1,13 @@
+import { Typed } from "../typed.js";
+import { DynamicBytesCoder } from "./bytes.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class StringCoder extends DynamicBytesCoder {
+    constructor(localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: string | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=string.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/string.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAG1D;;GAEG;AACH,qBAAa,WAAY,SAAQ,iBAAiB;gBAElC,SAAS,EAAE,MAAM;IAI7B,YAAY,IAAI,MAAM;IAItB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM;IAItD,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/string.js

@@ -0,0 +1,21 @@
+import { toUtf8Bytes, toUtf8String } from "../../utils/utf8.js";
+import { Typed } from "../typed.js";
+import { DynamicBytesCoder } from "./bytes.js";
+/**
+ *  @_ignore
+ */
+export class StringCoder extends DynamicBytesCoder {
+    constructor(localName) {
+        super("string", localName);
+    }
+    defaultValue() {
+        return "";
+    }
+    encode(writer, _value) {
+        return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string")));
+    }
+    decode(reader) {
+        return toUtf8String(super.decode(reader));
+    }
+}
+//# sourceMappingURL=string.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEhE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAK/C;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,iBAAiB;IAE9C,YAAY,SAAiB;QACzB,KAAK,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC/B,CAAC;IAED,YAAY;QACR,OAAO,EAAE,CAAC;IACd,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,MAAsB;QACzC,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAClF,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9C,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/tuple.d.ts

@@ -0,0 +1,16 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class TupleCoder extends Coder {
+    readonly coders: ReadonlyArray<Coder>;
+    constructor(coders: Array<Coder>, localName: string);
+    defaultValue(): any;
+    encode(writer: Writer, _value: Array<any> | {
+        [name: string]: any;
+    } | Typed): number;
+    decode(reader: Reader): any;
+}
+//# sourceMappingURL=tuple.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["../../../src.ts/abi/coders/tuple.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAI5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE1D;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACjC,QAAQ,CAAC,MAAM,EAAG,aAAa,CAAC,KAAK,CAAC,CAAC;gBAE3B,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,MAAM;IAanD,YAAY,IAAI,GAAG;IA+BnB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG;QAAE,CAAE,IAAI,EAAE,MAAM,GAAI,GAAG,CAAA;KAAE,GAAG,KAAK,GAAG,MAAM;IAKtF,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG;CAG9B"}

hl_helper/node_modules/ethers/lib.esm/abi/coders/tuple.js

@@ -0,0 +1,63 @@
+import { defineProperties } from "../../utils/properties.js";
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import { pack, unpack } from "./array.js";
+/**
+ *  @_ignore
+ */
+export class TupleCoder extends Coder {
+    coders;
+    constructor(coders, localName) {
+        let dynamic = false;
+        const types = [];
+        coders.forEach((coder) => {
+            if (coder.dynamic) {
+                dynamic = true;
+            }
+            types.push(coder.type);
+        });
+        const type = ("tuple(" + types.join(",") + ")");
+        super("tuple", type, localName, dynamic);
+        defineProperties(this, { coders: Object.freeze(coders.slice()) });
+    }
+    defaultValue() {
+        const values = [];
+        this.coders.forEach((coder) => {
+            values.push(coder.defaultValue());
+        });
+        // We only output named properties for uniquely named coders
+        const uniqueNames = this.coders.reduce((accum, coder) => {
+            const name = coder.localName;
+            if (name) {
+                if (!accum[name]) {
+                    accum[name] = 0;
+                }
+                accum[name]++;
+            }
+            return accum;
+        }, {});
+        // Add named values
+        this.coders.forEach((coder, index) => {
+            let name = coder.localName;
+            if (!name || uniqueNames[name] !== 1) {
+                return;
+            }
+            if (name === "length") {
+                name = "_length";
+            }
+            if (values[name] != null) {
+                return;
+            }
+            values[name] = values[index];
+        });
+        return Object.freeze(values);
+    }
+    encode(writer, _value) {
+        const value = Typed.dereference(_value, "tuple");
+        return pack(writer, this.coders, value);
+    }
+    decode(reader) {
+        return unpack(reader, this.coders);
+    }
+}
+//# sourceMappingURL=tuple.js.map

hl_helper/node_modules/ethers/lib.esm/abi/coders/tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.js","sourceRoot":"","sources":["../../../src.ts/abi/coders/tuple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAI1C;;GAEG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACxB,MAAM,CAAwB;IAEvC,YAAY,MAAoB,EAAE,SAAiB;QAC/C,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,KAAK,GAAkB,EAAE,CAAC;QAChC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YACrB,IAAI,KAAK,CAAC,OAAO,EAAE;gBAAE,OAAO,GAAG,IAAI,CAAC;aAAE;YACtC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,MAAM,IAAI,GAAG,CAAC,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC;QAEhD,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QACzC,gBAAgB,CAAa,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC;IAClF,CAAC;IAED,YAAY;QACR,MAAM,MAAM,GAAQ,EAAG,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,CAAC;QACtC,CAAC,CAAC,CAAC;QAEH,4DAA4D;QAC5D,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YACpD,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC;YAC7B,IAAI,IAAI,EAAE;gBACN,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;oBAAE,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;iBAAE;gBACtC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;aACjB;YACD,OAAO,KAAK,CAAC;QACjB,CAAC,EAAgC,EAAG,CAAC,CAAC;QAEtC,mBAAmB;QACnB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,KAAY,EAAE,KAAa,EAAE,EAAE;YAChD,IAAI,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC;YAC3B,IAAI,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;gBAAE,OAAO;aAAE;YAEjD,IAAI,IAAI,KAAK,QAAQ,EAAE;gBAAE,IAAI,GAAG,SAAS,CAAC;aAAE;YAE5C,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE;gBAAE,OAAO;aAAE;YAErC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAED,MAAM,CAAC,MAAc,EAAE,MAAsD;QACzE,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjD,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM,CAAC,MAAc;QACjB,OAAO,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACvC,CAAC;CACJ"}

hl_helper/node_modules/ethers/lib.esm/abi/fragments.d.ts

@@ -0,0 +1,466 @@
+/**
+ *  A fragment is a single item from an ABI, which may represent any of:
+ *
+ *  - [Functions](FunctionFragment)
+ *  - [Events](EventFragment)
+ *  - [Constructors](ConstructorFragment)
+ *  - Custom [Errors](ErrorFragment)
+ *  - [Fallback or Receive](FallbackFragment) functions
+ *
+ *  @_subsection api/abi/abi-coder:Fragments  [about-fragments]
+ */
+/**
+ *  A Type description in a [JSON ABI format](link-solc-jsonabi).
+ */
+export interface JsonFragmentType {
+    /**
+     *  The parameter name.
+     */
+    readonly name?: string;
+    /**
+     *  If the parameter is indexed.
+     */
+    readonly indexed?: boolean;
+    /**
+     *  The type of the parameter.
+     */
+    readonly type?: string;
+    /**
+     *  The internal Solidity type.
+     */
+    readonly internalType?: string;
+    /**
+     *  The components for a tuple.
+     */
+    readonly components?: ReadonlyArray<JsonFragmentType>;
+}
+/**
+ *  A fragment for a method, event or error in a [JSON ABI format](link-solc-jsonabi).
+ */
+export interface JsonFragment {
+    /**
+     *  The name of the error, event, function, etc.
+     */
+    readonly name?: string;
+    /**
+     *  The type of the fragment (e.g. ``event``, ``"function"``, etc.)
+     */
+    readonly type?: string;
+    /**
+     *  If the event is anonymous.
+     */
+    readonly anonymous?: boolean;
+    /**
+     *  If the function is payable.
+     */
+    readonly payable?: boolean;
+    /**
+     *  If the function is constant.
+     */
+    readonly constant?: boolean;
+    /**
+     *  The mutability state of the function.
+     */
+    readonly stateMutability?: string;
+    /**
+     *  The input parameters.
+     */
+    readonly inputs?: ReadonlyArray<JsonFragmentType>;
+    /**
+     *  The output parameters.
+     */
+    readonly outputs?: ReadonlyArray<JsonFragmentType>;
+    /**
+     *  The gas limit to use when sending a transaction for this function.
+     */
+    readonly gas?: string;
+}
+/**
+ *  The format to serialize the output as.
+ *
+ *  **``"sighash"``** - the bare formatting, used to compute the selector
+ *  or topic hash; this format cannot be reversed (as it discards ``indexed``)
+ *  so cannot by used to export an [[Interface]].
+ *
+ *  **``"minimal"``** - Human-Readable ABI with minimal spacing and without
+ *  names, so it is compact, but will result in Result objects that cannot
+ *  be accessed by name.
+ *
+ *  **``"full"``** - Full Human-Readable ABI, with readable spacing and names
+ *  intact; this is generally the recommended format.
+ *
+ *  **``"json"``** - The [JSON ABI format](link-solc-jsonabi).
+ */
+export type FormatType = "sighash" | "minimal" | "full" | "json";
+/**
+ *  When [walking](ParamType-walk) a [[ParamType]], this is called
+ *  on each component.
+ */
+export type ParamTypeWalkFunc = (type: string, value: any) => any;
+/**
+ *  When [walking asynchronously](ParamType-walkAsync) a [[ParamType]],
+ *  this is called on each component.
+ */
+export type ParamTypeWalkAsyncFunc = (type: string, value: any) => any | Promise<any>;
+/**
+ *  Each input and output of a [[Fragment]] is an Array of **ParamType**.
+ */
+export declare class ParamType {
+    #private;
+    /**
+     *  The local name of the parameter (or ``""`` if unbound)
+     */
+    readonly name: string;
+    /**
+     *  The fully qualified type (e.g. ``"address"``, ``"tuple(address)"``,
+     *  ``"uint256[3][]"``)
+     */
+    readonly type: string;
+    /**
+     *  The base type (e.g. ``"address"``, ``"tuple"``, ``"array"``)
+     */
+    readonly baseType: string;
+    /**
+     *  True if the parameters is indexed.
+     *
+     *  For non-indexable types this is ``null``.
+     */
+    readonly indexed: null | boolean;
+    /**
+     *  The components for the tuple.
+     *
+     *  For non-tuple types this is ``null``.
+     */
+    readonly components: null | ReadonlyArray<ParamType>;
+    /**
+     *  The array length, or ``-1`` for dynamic-lengthed arrays.
+     *
+     *  For non-array types this is ``null``.
+     */
+    readonly arrayLength: null | number;
+    /**
+     *  The type of each child in the array.
+     *
+     *  For non-array types this is ``null``.
+     */
+    readonly arrayChildren: null | ParamType;
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, type: string, baseType: string, indexed: null | boolean, components: null | ReadonlyArray<ParamType>, arrayLength: null | number, arrayChildren: null | ParamType);
+    /**
+     *  Return a string representation of this type.
+     *
+     *  For example,
+     *
+     *  ``sighash" => "(uint256,address)"``
+     *
+     *  ``"minimal" => "tuple(uint256,address) indexed"``
+     *
+     *  ``"full" => "tuple(uint256 foo, address bar) indexed baz"``
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Returns true if %%this%% is an Array type.
+     *
+     *  This provides a type gaurd ensuring that [[arrayChildren]]
+     *  and [[arrayLength]] are non-null.
+     */
+    isArray(): this is (ParamType & {
+        arrayChildren: ParamType;
+        arrayLength: number;
+    });
+    /**
+     *  Returns true if %%this%% is a Tuple type.
+     *
+     *  This provides a type gaurd ensuring that [[components]]
+     *  is non-null.
+     */
+    isTuple(): this is (ParamType & {
+        components: ReadonlyArray<ParamType>;
+    });
+    /**
+     *  Returns true if %%this%% is an Indexable type.
+     *
+     *  This provides a type gaurd ensuring that [[indexed]]
+     *  is non-null.
+     */
+    isIndexable(): this is (ParamType & {
+        indexed: boolean;
+    });
+    /**
+     *  Walks the **ParamType** with %%value%%, calling %%process%%
+     *  on each type, destructing the %%value%% recursively.
+     */
+    walk(value: any, process: ParamTypeWalkFunc): any;
+    /**
+     *  Walks the **ParamType** with %%value%%, asynchronously calling
+     *  %%process%% on each type, destructing the %%value%% recursively.
+     *
+     *  This can be used to resolve ENS names by walking and resolving each
+     *  ``"address"`` type.
+     */
+    walkAsync(value: any, process: ParamTypeWalkAsyncFunc): Promise<any>;
+    /**
+     *  Creates a new **ParamType** for %%obj%%.
+     *
+     *  If %%allowIndexed%% then the ``indexed`` keyword is permitted,
+     *  otherwise the ``indexed`` keyword will throw an error.
+     */
+    static from(obj: any, allowIndexed?: boolean): ParamType;
+    /**
+     *  Returns true if %%value%% is a **ParamType**.
+     */
+    static isParamType(value: any): value is ParamType;
+}
+/**
+ *  The type of a [[Fragment]].
+ */
+export type FragmentType = "constructor" | "error" | "event" | "fallback" | "function" | "struct";
+/**
+ *  An abstract class to represent An individual fragment from a parse ABI.
+ */
+export declare abstract class Fragment {
+    /**
+     *  The type of the fragment.
+     */
+    readonly type: FragmentType;
+    /**
+     *  The inputs for the fragment.
+     */
+    readonly inputs: ReadonlyArray<ParamType>;
+    /**
+     *  @private
+     */
+    constructor(guard: any, type: FragmentType, inputs: ReadonlyArray<ParamType>);
+    /**
+     *  Returns a string representation of this fragment as %%format%%.
+     */
+    abstract format(format?: FormatType): string;
+    /**
+     *  Creates a new **Fragment** for %%obj%%, wich can be any supported
+     *  ABI frgament type.
+     */
+    static from(obj: any): Fragment;
+    /**
+     *  Returns true if %%value%% is a [[ConstructorFragment]].
+     */
+    static isConstructor(value: any): value is ConstructorFragment;
+    /**
+     *  Returns true if %%value%% is an [[ErrorFragment]].
+     */
+    static isError(value: any): value is ErrorFragment;
+    /**
+     *  Returns true if %%value%% is an [[EventFragment]].
+     */
+    static isEvent(value: any): value is EventFragment;
+    /**
+     *  Returns true if %%value%% is a [[FunctionFragment]].
+     */
+    static isFunction(value: any): value is FunctionFragment;
+    /**
+     *  Returns true if %%value%% is a [[StructFragment]].
+     */
+    static isStruct(value: any): value is StructFragment;
+}
+/**
+ *  An abstract class to represent An individual fragment
+ *  which has a name from a parse ABI.
+ */
+export declare abstract class NamedFragment extends Fragment {
+    /**
+     *  The name of the fragment.
+     */
+    readonly name: string;
+    /**
+     *  @private
+     */
+    constructor(guard: any, type: FragmentType, name: string, inputs: ReadonlyArray<ParamType>);
+}
+/**
+ *  A Fragment which represents a //Custom Error//.
+ */
+export declare class ErrorFragment extends NamedFragment {
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>);
+    /**
+     *  The Custom Error selector.
+     */
+    get selector(): string;
+    /**
+     *  Returns a string representation of this fragment as %%format%%.
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Returns a new **ErrorFragment** for %%obj%%.
+     */
+    static from(obj: any): ErrorFragment;
+    /**
+     *  Returns ``true`` and provides a type guard if %%value%% is an
+     *  **ErrorFragment**.
+     */
+    static isFragment(value: any): value is ErrorFragment;
+}
+/**
+ *  A Fragment which represents an Event.
+ */
+export declare class EventFragment extends NamedFragment {
+    /**
+     *  Whether this event is anonymous.
+     */
+    readonly anonymous: boolean;
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>, anonymous: boolean);
+    /**
+     *  The Event topic hash.
+     */
+    get topicHash(): string;
+    /**
+     *  Returns a string representation of this event as %%format%%.
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Return the topic hash for an event with %%name%% and %%params%%.
+     */
+    static getTopicHash(name: string, params?: Array<any>): string;
+    /**
+     *  Returns a new **EventFragment** for %%obj%%.
+     */
+    static from(obj: any): EventFragment;
+    /**
+     *  Returns ``true`` and provides a type guard if %%value%% is an
+     *  **EventFragment**.
+     */
+    static isFragment(value: any): value is EventFragment;
+}
+/**
+ *  A Fragment which represents a constructor.
+ */
+export declare class ConstructorFragment extends Fragment {
+    /**
+     *  Whether the constructor can receive an endowment.
+     */
+    readonly payable: boolean;
+    /**
+     *  The recommended gas limit for deployment or ``null``.
+     */
+    readonly gas: null | bigint;
+    /**
+     *  @private
+     */
+    constructor(guard: any, type: FragmentType, inputs: ReadonlyArray<ParamType>, payable: boolean, gas: null | bigint);
+    /**
+     *  Returns a string representation of this constructor as %%format%%.
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Returns a new **ConstructorFragment** for %%obj%%.
+     */
+    static from(obj: any): ConstructorFragment;
+    /**
+     *  Returns ``true`` and provides a type guard if %%value%% is a
+     *  **ConstructorFragment**.
+     */
+    static isFragment(value: any): value is ConstructorFragment;
+}
+/**
+ *  A Fragment which represents a method.
+ */
+export declare class FallbackFragment extends Fragment {
+    /**
+     *  If the function can be sent value during invocation.
+     */
+    readonly payable: boolean;
+    constructor(guard: any, inputs: ReadonlyArray<ParamType>, payable: boolean);
+    /**
+     *  Returns a string representation of this fallback as %%format%%.
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Returns a new **FallbackFragment** for %%obj%%.
+     */
+    static from(obj: any): FallbackFragment;
+    /**
+     *  Returns ``true`` and provides a type guard if %%value%% is a
+     *  **FallbackFragment**.
+     */
+    static isFragment(value: any): value is FallbackFragment;
+}
+/**
+ *  A Fragment which represents a method.
+ */
+export declare class FunctionFragment extends NamedFragment {
+    /**
+     *  If the function is constant (e.g. ``pure`` or ``view`` functions).
+     */
+    readonly constant: boolean;
+    /**
+     *  The returned types for the result of calling this function.
+     */
+    readonly outputs: ReadonlyArray<ParamType>;
+    /**
+     *  The state mutability (e.g. ``payable``, ``nonpayable``, ``view``
+     *  or ``pure``)
+     */
+    readonly stateMutability: "payable" | "nonpayable" | "view" | "pure";
+    /**
+     *  If the function can be sent value during invocation.
+     */
+    readonly payable: boolean;
+    /**
+     *  The recommended gas limit to send when calling this function.
+     */
+    readonly gas: null | bigint;
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, stateMutability: "payable" | "nonpayable" | "view" | "pure", inputs: ReadonlyArray<ParamType>, outputs: ReadonlyArray<ParamType>, gas: null | bigint);
+    /**
+     *  The Function selector.
+     */
+    get selector(): string;
+    /**
+     *  Returns a string representation of this function as %%format%%.
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Return the selector for a function with %%name%% and %%params%%.
+     */
+    static getSelector(name: string, params?: Array<any>): string;
+    /**
+     *  Returns a new **FunctionFragment** for %%obj%%.
+     */
+    static from(obj: any): FunctionFragment;
+    /**
+     *  Returns ``true`` and provides a type guard if %%value%% is a
+     *  **FunctionFragment**.
+     */
+    static isFragment(value: any): value is FunctionFragment;
+}
+/**
+ *  A Fragment which represents a structure.
+ */
+export declare class StructFragment extends NamedFragment {
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>);
+    /**
+     *  Returns a string representation of this struct as %%format%%.
+     */
+    format(): string;
+    /**
+     *  Returns a new **StructFragment** for %%obj%%.
+     */
+    static from(obj: any): StructFragment;
+    /**
+     *  Returns ``true`` and provides a type guard if %%value%% is a
+     *  **StructFragment**.
+     */
+    static isFragment(value: any): value is FunctionFragment;
+}
+//# sourceMappingURL=fragments.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ *  The Application Binary Interface (ABI) describes how method input
+ *  parameters should be encoded, their results decoded, and how to
+ *  decode events and errors.
+ *
+ *  See [About ABIs](docs-abi) for more details how they are used.
+ *
+ *  @_section api/abi:Application Binary Interface  [about-abi]
+ *  @_navTitle: ABI
+ */
+export { AbiCoder } from "./abi-coder.js";
+export { decodeBytes32String, encodeBytes32String } from "./bytes32.js";
+export { ConstructorFragment, ErrorFragment, EventFragment, FallbackFragment, Fragment, FunctionFragment, NamedFragment, ParamType, StructFragment, } from "./fragments.js";
+export { checkResultErrors, Indexed, Interface, ErrorDescription, LogDescription, TransactionDescription, Result } from "./interface.js";
+export { Typed } from "./typed.js";
+export type { JsonFragment, JsonFragmentType, FormatType, FragmentType, ParamTypeWalkAsyncFunc, ParamTypeWalkFunc } from "./fragments.js";
+export type { InterfaceAbi, } from "./interface.js";
+//# sourceMappingURL=index.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src.ts/abi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExE,OAAO,EACH,mBAAmB,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EACnE,QAAQ,EAAE,gBAAgB,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,GACvE,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACH,iBAAiB,EACjB,OAAO,EACP,SAAS,EACT,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EACxD,MAAM,EACT,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,YAAY,EACR,YAAY,EAAE,gBAAgB,EAC9B,UAAU,EAAE,YAAY,EAAE,sBAAsB,EAAE,iBAAiB,EACtE,MAAM,gBAAgB,CAAC;AAExB,YAAY,EACR,YAAY,GACf,MAAM,gBAAgB,CAAC"}

hl_helper/node_modules/ethers/lib.esm/abi/index.js

@@ -0,0 +1,17 @@
+/**
+ *  The Application Binary Interface (ABI) describes how method input
+ *  parameters should be encoded, their results decoded, and how to
+ *  decode events and errors.
+ *
+ *  See [About ABIs](docs-abi) for more details how they are used.
+ *
+ *  @_section api/abi:Application Binary Interface  [about-abi]
+ *  @_navTitle: ABI
+ */
+//////
+export { AbiCoder } from "./abi-coder.js";
+export { decodeBytes32String, encodeBytes32String } from "./bytes32.js";
+export { ConstructorFragment, ErrorFragment, EventFragment, FallbackFragment, Fragment, FunctionFragment, NamedFragment, ParamType, StructFragment, } from "./fragments.js";
+export { checkResultErrors, Indexed, Interface, ErrorDescription, LogDescription, TransactionDescription, Result } from "./interface.js";
+export { Typed } from "./typed.js";
+//# sourceMappingURL=index.js.map

hl_helper/node_modules/ethers/lib.esm/abi/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src.ts/abi/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,MAAM;AACN,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,OAAO,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExE,OAAO,EACH,mBAAmB,EAAE,aAAa,EAAE,aAAa,EAAE,gBAAgB,EACnE,QAAQ,EAAE,gBAAgB,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,GACvE,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACH,iBAAiB,EACjB,OAAO,EACP,SAAS,EACT,gBAAgB,EAAE,cAAc,EAAE,sBAAsB,EACxD,MAAM,EACT,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC"}

hl_helper/node_modules/ethers/lib.esm/abi/interface.d.ts

@@ -0,0 +1,382 @@
+/**
+ *  The Interface class is a low-level class that accepts an
+ *  ABI and provides all the necessary functionality to encode
+ *  and decode paramaters to and results from methods, events
+ *  and errors.
+ *
+ *  It also provides several convenience methods to automatically
+ *  search and find matching transactions and events to parse them.
+ *
+ *  @_subsection api/abi:Interfaces  [interfaces]
+ */
+import { AbiCoder } from "./abi-coder.js";
+import { checkResultErrors, Result } from "./coders/abstract-coder.js";
+import { ConstructorFragment, ErrorFragment, EventFragment, FallbackFragment, Fragment, FunctionFragment, ParamType } from "./fragments.js";
+import { Typed } from "./typed.js";
+import type { BigNumberish, BytesLike, CallExceptionError, CallExceptionTransaction } from "../utils/index.js";
+import type { JsonFragment } from "./fragments.js";
+export { checkResultErrors, Result };
+/**
+ *  When using the [[Interface-parseLog]] to automatically match a Log to its event
+ *  for parsing, a **LogDescription** is returned.
+ */
+export declare class LogDescription {
+    /**
+     *  The matching fragment for the ``topic0``.
+     */
+    readonly fragment: EventFragment;
+    /**
+     *  The name of the Event.
+     */
+    readonly name: string;
+    /**
+     *  The full Event signature.
+     */
+    readonly signature: string;
+    /**
+     *  The topic hash for the Event.
+     */
+    readonly topic: string;
+    /**
+     *  The arguments passed into the Event with ``emit``.
+     */
+    readonly args: Result;
+    /**
+     *  @_ignore:
+     */
+    constructor(fragment: EventFragment, topic: string, args: Result);
+}
+/**
+ *  When using the [[Interface-parseTransaction]] to automatically match
+ *  a transaction data to its function for parsing,
+ *  a **TransactionDescription** is returned.
+ */
+export declare class TransactionDescription {
+    /**
+     *  The matching fragment from the transaction ``data``.
+     */
+    readonly fragment: FunctionFragment;
+    /**
+     *  The name of the Function from the transaction ``data``.
+     */
+    readonly name: string;
+    /**
+     *  The arguments passed to the Function from the transaction ``data``.
+     */
+    readonly args: Result;
+    /**
+     *  The full Function signature from the transaction ``data``.
+     */
+    readonly signature: string;
+    /**
+     *  The selector for the Function from the transaction ``data``.
+     */
+    readonly selector: string;
+    /**
+     *  The ``value`` (in wei) from the transaction.
+     */
+    readonly value: bigint;
+    /**
+     *  @_ignore:
+     */
+    constructor(fragment: FunctionFragment, selector: string, args: Result, value: bigint);
+}
+/**
+ *  When using the [[Interface-parseError]] to automatically match an
+ *  error for a call result for parsing, an **ErrorDescription** is returned.
+ */
+export declare class ErrorDescription {
+    /**
+     *  The matching fragment.
+     */
+    readonly fragment: ErrorFragment;
+    /**
+     *  The name of the Error.
+     */
+    readonly name: string;
+    /**
+     *  The arguments passed to the Error with ``revert``.
+     */
+    readonly args: Result;
+    /**
+     *  The full Error signature.
+     */
+    readonly signature: string;
+    /**
+     *  The selector for the Error.
+     */
+    readonly selector: string;
+    /**
+     *  @_ignore:
+     */
+    constructor(fragment: ErrorFragment, selector: string, args: Result);
+}
+/**
+ *  An **Indexed** is used as a value when a value that does not
+ *  fit within a topic (i.e. not a fixed-length, 32-byte type). It
+ *  is the ``keccak256`` of the value, and used for types such as
+ *  arrays, tuples, bytes and strings.
+ */
+export declare class Indexed {
+    /**
+     *  The ``keccak256`` of the value logged.
+     */
+    readonly hash: null | string;
+    /**
+     *  @_ignore:
+     */
+    readonly _isIndexed: boolean;
+    /**
+     *  Returns ``true`` if %%value%% is an **Indexed**.
+     *
+     *  This provides a Type Guard for property access.
+     */
+    static isIndexed(value: any): value is Indexed;
+    /**
+     *  @_ignore:
+     */
+    constructor(hash: null | string);
+}
+/**
+ *  An **InterfaceAbi** may be any supported ABI format.
+ *
+ *  A string is expected to be a JSON string, which will be parsed
+ *  using ``JSON.parse``. This means that the value **must** be a valid
+ *  JSON string, with no stray commas, etc.
+ *
+ *  An array may contain any combination of:
+ *  - Human-Readable fragments
+ *  - Parsed JSON fragment
+ *  - [[Fragment]] instances
+ *
+ *  A **Human-Readable Fragment** is a string which resembles a Solidity
+ *  signature and is introduced in [this blog entry](link-ricmoo-humanreadableabi).
+ *  For example, ``function balanceOf(address) view returns (uint)``.
+ *
+ *  A **Parsed JSON Fragment** is a JavaScript Object desribed in the
+ *  [Solidity documentation](link-solc-jsonabi).
+ */
+export type InterfaceAbi = string | ReadonlyArray<Fragment | JsonFragment | string>;
+/**
+ *  An Interface abstracts many of the low-level details for
+ *  encoding and decoding the data on the blockchain.
+ *
+ *  An ABI provides information on how to encode data to send to
+ *  a Contract, how to decode the results and events and how to
+ *  interpret revert errors.
+ *
+ *  The ABI can be specified by [any supported format](InterfaceAbi).
+ */
+export declare class Interface {
+    #private;
+    /**
+     *  All the Contract ABI members (i.e. methods, events, errors, etc).
+     */
+    readonly fragments: ReadonlyArray<Fragment>;
+    /**
+     *  The Contract constructor.
+     */
+    readonly deploy: ConstructorFragment;
+    /**
+     *  The Fallback method, if any.
+     */
+    readonly fallback: null | FallbackFragment;
+    /**
+     *  If receiving ether is supported.
+     */
+    readonly receive: boolean;
+    /**
+     *  Create a new Interface for the %%fragments%%.
+     */
+    constructor(fragments: InterfaceAbi);
+    /**
+     *  Returns the entire Human-Readable ABI, as an array of
+     *  signatures, optionally as %%minimal%% strings, which
+     *  removes parameter names and unneceesary spaces.
+     */
+    format(minimal?: boolean): Array<string>;
+    /**
+     *  Return the JSON-encoded ABI. This is the format Solidiy
+     *  returns.
+     */
+    formatJson(): string;
+    /**
+     *  The ABI coder that will be used to encode and decode binary
+     *  data.
+     */
+    getAbiCoder(): AbiCoder;
+    /**
+     *  Get the function name for %%key%%, which may be a function selector,
+     *  function name or function signature that belongs to the ABI.
+     */
+    getFunctionName(key: string): string;
+    /**
+     *  Returns true if %%key%% (a function selector, function name or
+     *  function signature) is present in the ABI.
+     *
+     *  In the case of a function name, the name may be ambiguous, so
+     *  accessing the [[FunctionFragment]] may require refinement.
+     */
+    hasFunction(key: string): boolean;
+    /**
+     *  Get the [[FunctionFragment]] for %%key%%, which may be a function
+     *  selector, function name or function signature that belongs to the ABI.
+     *
+     *  If %%values%% is provided, it will use the Typed API to handle
+     *  ambiguous cases where multiple functions match by name.
+     *
+     *  If the %%key%% and %%values%% do not refine to a single function in
+     *  the ABI, this will throw.
+     */
+    getFunction(key: string, values?: Array<any | Typed>): null | FunctionFragment;
+    /**
+     *  Iterate over all functions, calling %%callback%%, sorted by their name.
+     */
+    forEachFunction(callback: (func: FunctionFragment, index: number) => void): void;
+    /**
+     *  Get the event name for %%key%%, which may be a topic hash,
+     *  event name or event signature that belongs to the ABI.
+     */
+    getEventName(key: string): string;
+    /**
+     *  Returns true if %%key%% (an event topic hash, event name or
+     *  event signature) is present in the ABI.
+     *
+     *  In the case of an event name, the name may be ambiguous, so
+     *  accessing the [[EventFragment]] may require refinement.
+     */
+    hasEvent(key: string): boolean;
+    /**
+     *  Get the [[EventFragment]] for %%key%%, which may be a topic hash,
+     *  event name or event signature that belongs to the ABI.
+     *
+     *  If %%values%% is provided, it will use the Typed API to handle
+     *  ambiguous cases where multiple events match by name.
+     *
+     *  If the %%key%% and %%values%% do not refine to a single event in
+     *  the ABI, this will throw.
+     */
+    getEvent(key: string, values?: Array<any | Typed>): null | EventFragment;
+    /**
+     *  Iterate over all events, calling %%callback%%, sorted by their name.
+     */
+    forEachEvent(callback: (func: EventFragment, index: number) => void): void;
+    /**
+     *  Get the [[ErrorFragment]] for %%key%%, which may be an error
+     *  selector, error name or error signature that belongs to the ABI.
+     *
+     *  If %%values%% is provided, it will use the Typed API to handle
+     *  ambiguous cases where multiple errors match by name.
+     *
+     *  If the %%key%% and %%values%% do not refine to a single error in
+     *  the ABI, this will throw.
+     */
+    getError(key: string, values?: Array<any | Typed>): null | ErrorFragment;
+    /**
+     *  Iterate over all errors, calling %%callback%%, sorted by their name.
+     */
+    forEachError(callback: (func: ErrorFragment, index: number) => void): void;
+    _decodeParams(params: ReadonlyArray<ParamType>, data: BytesLike): Result;
+    _encodeParams(params: ReadonlyArray<ParamType>, values: ReadonlyArray<any>): string;
+    /**
+     *  Encodes a ``tx.data`` object for deploying the Contract with
+     *  the %%values%% as the constructor arguments.
+     */
+    encodeDeploy(values?: ReadonlyArray<any>): string;
+    /**
+     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
+     *  specified error (see [[getError]] for valid values for
+     *  %%key%%).
+     *
+     *  Most developers should prefer the [[parseCallResult]] method instead,
+     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the
+     *  corresponding error.
+     */
+    decodeErrorResult(fragment: ErrorFragment | string, data: BytesLike): Result;
+    /**
+     *  Encodes the transaction revert data for a call result that
+     *  reverted from the the Contract with the sepcified %%error%%
+     *  (see [[getError]] for valid values for %%fragment%%) with the %%values%%.
+     *
+     *  This is generally not used by most developers, unless trying to mock
+     *  a result from a Contract.
+     */
+    encodeErrorResult(fragment: ErrorFragment | string, values?: ReadonlyArray<any>): string;
+    /**
+     *  Decodes the %%data%% from a transaction ``tx.data`` for
+     *  the function specified (see [[getFunction]] for valid values
+     *  for %%fragment%%).
+     *
+     *  Most developers should prefer the [[parseTransaction]] method
+     *  instead, which will automatically detect the fragment.
+     */
+    decodeFunctionData(fragment: FunctionFragment | string, data: BytesLike): Result;
+    /**
+     *  Encodes the ``tx.data`` for a transaction that calls the function
+     *  specified (see [[getFunction]] for valid values for %%fragment%%) with
+     *  the %%values%%.
+     */
+    encodeFunctionData(fragment: FunctionFragment | string, values?: ReadonlyArray<any>): string;
+    /**
+     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
+     *  specified function (see [[getFunction]] for valid values for
+     *  %%key%%).
+     *
+     *  Most developers should prefer the [[parseCallResult]] method instead,
+     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the
+     *  corresponding error.
+     */
+    decodeFunctionResult(fragment: FunctionFragment | string, data: BytesLike): Result;
+    makeError(_data: BytesLike, tx: CallExceptionTransaction): CallExceptionError;
+    /**
+     *  Encodes the result data (e.g. from an ``eth_call``) for the
+     *  specified function (see [[getFunction]] for valid values
+     *  for %%fragment%%) with %%values%%.
+     *
+     *  This is generally not used by most developers, unless trying to mock
+     *  a result from a Contract.
+     */
+    encodeFunctionResult(fragment: FunctionFragment | string, values?: ReadonlyArray<any>): string;
+    encodeFilterTopics(fragment: EventFragment | string, values: ReadonlyArray<any>): Array<null | string | Array<string>>;
+    encodeEventLog(fragment: EventFragment | string, values: ReadonlyArray<any>): {
+        data: string;
+        topics: Array<string>;
+    };
+    decodeEventLog(fragment: EventFragment | string, data: BytesLike, topics?: ReadonlyArray<string>): Result;
+    /**
+     *  Parses a transaction, finding the matching function and extracts
+     *  the parameter values along with other useful function details.
+     *
+     *  If the matching function cannot be found, return null.
+     */
+    parseTransaction(tx: {
+        data: string;
+        value?: BigNumberish;
+    }): null | TransactionDescription;
+    parseCallResult(data: BytesLike): Result;
+    /**
+     *  Parses a receipt log, finding the matching event and extracts
+     *  the parameter values along with other useful event details.
+     *
+     *  If the matching event cannot be found, returns null.
+     */
+    parseLog(log: {
+        topics: ReadonlyArray<string>;
+        data: string;
+    }): null | LogDescription;
+    /**
+     *  Parses a revert data, finding the matching error and extracts
+     *  the parameter values along with other useful error details.
+     *
+     *  If the matching error cannot be found, returns null.
+     */
+    parseError(data: BytesLike): null | ErrorDescription;
+    /**
+     *  Creates a new [[Interface]] from the ABI %%value%%.
+     *
+     *  The %%value%% may be provided as an existing [[Interface]] object,
+     *  a JSON-encoded ABI or any Human-Readable ABI format.
+     */
+    static from(value: InterfaceAbi | Interface): Interface;
+}
+//# sourceMappingURL=interface.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/typed.d.ts

@@ -0,0 +1,570 @@
+/**
+ *  A Typed object allows a value to have its type explicitly
+ *  specified.
+ *
+ *  For example, in Solidity, the value ``45`` could represent a
+ *  ``uint8`` or a ``uint256``. The value ``0x1234`` could represent
+ *  a ``bytes2`` or ``bytes``.
+ *
+ *  Since JavaScript has no meaningful way to explicitly inform any
+ *  APIs which what the type is, this allows transparent interoperation
+ *  with Soldity.
+ *
+ *  @_subsection: api/abi:Typed Values
+ */
+import type { Addressable } from "../address/index.js";
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+import type { Result } from "./coders/abstract-coder.js";
+/**
+ *  @_ignore:
+ */
+export interface TypedNumber extends Typed {
+    value: number;
+    defaultValue(): number;
+    minValue(): number;
+    maxValue(): number;
+}
+/**
+ *  A **Typed** that represents a numeric value.
+ */
+export interface TypedBigInt extends Typed {
+    /**
+     *  The value.
+     */
+    value: bigint;
+    /**
+     *  The default value for all numeric types is ``0``.
+     */
+    defaultValue(): bigint;
+    /**
+     *  The minimum value for this type, accounting for bit-width and signed-ness.
+     */
+    minValue(): bigint;
+    /**
+     *  The minimum value for this type, accounting for bit-width.
+     */
+    maxValue(): bigint;
+}
+/**
+ *  A **Typed** that represents a binary sequence of data as bytes.
+ */
+export interface TypedData extends Typed {
+    /**
+     *  The value.
+     */
+    value: string;
+    /**
+     *  The default value for this type.
+     */
+    defaultValue(): string;
+}
+/**
+ *  A **Typed** that represents a UTF-8 sequence of bytes.
+ */
+export interface TypedString extends Typed {
+    /**
+     *  The value.
+     */
+    value: string;
+    /**
+     *  The default value for the string type is the empty string (i.e. ``""``).
+     */
+    defaultValue(): string;
+}
+/**
+ *  The **Typed** class to wrap values providing explicit type information.
+ */
+export declare class Typed {
+    #private;
+    /**
+     *  The type, as a Solidity-compatible type.
+     */
+    readonly type: string;
+    /**
+     *  The actual value.
+     */
+    readonly value: any;
+    /**
+     *  @_ignore:
+     */
+    readonly _typedSymbol: Symbol;
+    /**
+     *  @_ignore:
+     */
+    constructor(gaurd: any, type: string, value: any, options?: any);
+    /**
+     *  Format the type as a Human-Readable type.
+     */
+    format(): string;
+    /**
+     *  The default value returned by this type.
+     */
+    defaultValue(): string | number | bigint | Result;
+    /**
+     *  The minimum value for numeric types.
+     */
+    minValue(): string | number | bigint;
+    /**
+     *  The maximum value for numeric types.
+     */
+    maxValue(): string | number | bigint;
+    /**
+     *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
+     */
+    isBigInt(): this is TypedBigInt;
+    /**
+     *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
+     */
+    isData(): this is TypedData;
+    /**
+     *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
+     */
+    isString(): this is TypedString;
+    /**
+     *  Returns the tuple name, if this is a tuple. Throws otherwise.
+     */
+    get tupleName(): null | string;
+    /**
+     *  Returns the length of the array type or ``-1`` if it is dynamic.
+     *
+     *  Throws if the type is not an array.
+     */
+    get arrayLength(): null | number;
+    /**
+     *  Returns a new **Typed** of %%type%% with the %%value%%.
+     */
+    static from(type: string, value: any): Typed;
+    /**
+     *  Return a new ``uint8`` type for %%v%%.
+     */
+    static uint8(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint16`` type for %%v%%.
+     */
+    static uint16(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint24`` type for %%v%%.
+     */
+    static uint24(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint32`` type for %%v%%.
+     */
+    static uint32(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint40`` type for %%v%%.
+     */
+    static uint40(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint48`` type for %%v%%.
+     */
+    static uint48(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint56`` type for %%v%%.
+     */
+    static uint56(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint64`` type for %%v%%.
+     */
+    static uint64(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint72`` type for %%v%%.
+     */
+    static uint72(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint80`` type for %%v%%.
+     */
+    static uint80(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint88`` type for %%v%%.
+     */
+    static uint88(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint96`` type for %%v%%.
+     */
+    static uint96(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint104`` type for %%v%%.
+     */
+    static uint104(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint112`` type for %%v%%.
+     */
+    static uint112(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint120`` type for %%v%%.
+     */
+    static uint120(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint128`` type for %%v%%.
+     */
+    static uint128(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint136`` type for %%v%%.
+     */
+    static uint136(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint144`` type for %%v%%.
+     */
+    static uint144(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint152`` type for %%v%%.
+     */
+    static uint152(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint160`` type for %%v%%.
+     */
+    static uint160(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint168`` type for %%v%%.
+     */
+    static uint168(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint176`` type for %%v%%.
+     */
+    static uint176(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint184`` type for %%v%%.
+     */
+    static uint184(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint192`` type for %%v%%.
+     */
+    static uint192(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint200`` type for %%v%%.
+     */
+    static uint200(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint208`` type for %%v%%.
+     */
+    static uint208(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint216`` type for %%v%%.
+     */
+    static uint216(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint224`` type for %%v%%.
+     */
+    static uint224(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint232`` type for %%v%%.
+     */
+    static uint232(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint240`` type for %%v%%.
+     */
+    static uint240(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint248`` type for %%v%%.
+     */
+    static uint248(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint256`` type for %%v%%.
+     */
+    static uint256(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``uint256`` type for %%v%%.
+     */
+    static uint(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int8`` type for %%v%%.
+     */
+    static int8(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int16`` type for %%v%%.
+     */
+    static int16(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int24`` type for %%v%%.
+     */
+    static int24(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int32`` type for %%v%%.
+     */
+    static int32(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int40`` type for %%v%%.
+     */
+    static int40(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int48`` type for %%v%%.
+     */
+    static int48(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int56`` type for %%v%%.
+     */
+    static int56(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int64`` type for %%v%%.
+     */
+    static int64(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int72`` type for %%v%%.
+     */
+    static int72(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int80`` type for %%v%%.
+     */
+    static int80(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int88`` type for %%v%%.
+     */
+    static int88(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int96`` type for %%v%%.
+     */
+    static int96(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int104`` type for %%v%%.
+     */
+    static int104(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int112`` type for %%v%%.
+     */
+    static int112(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int120`` type for %%v%%.
+     */
+    static int120(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int128`` type for %%v%%.
+     */
+    static int128(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int136`` type for %%v%%.
+     */
+    static int136(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int144`` type for %%v%%.
+     */
+    static int144(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int52`` type for %%v%%.
+     */
+    static int152(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int160`` type for %%v%%.
+     */
+    static int160(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int168`` type for %%v%%.
+     */
+    static int168(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int176`` type for %%v%%.
+     */
+    static int176(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int184`` type for %%v%%.
+     */
+    static int184(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int92`` type for %%v%%.
+     */
+    static int192(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int200`` type for %%v%%.
+     */
+    static int200(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int208`` type for %%v%%.
+     */
+    static int208(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int216`` type for %%v%%.
+     */
+    static int216(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int224`` type for %%v%%.
+     */
+    static int224(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int232`` type for %%v%%.
+     */
+    static int232(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int240`` type for %%v%%.
+     */
+    static int240(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int248`` type for %%v%%.
+     */
+    static int248(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int256`` type for %%v%%.
+     */
+    static int256(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``int256`` type for %%v%%.
+     */
+    static int(v: BigNumberish): Typed;
+    /**
+     *  Return a new ``bytes1`` type for %%v%%.
+     */
+    static bytes1(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes2`` type for %%v%%.
+     */
+    static bytes2(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes3`` type for %%v%%.
+     */
+    static bytes3(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes4`` type for %%v%%.
+     */
+    static bytes4(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes5`` type for %%v%%.
+     */
+    static bytes5(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes6`` type for %%v%%.
+     */
+    static bytes6(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes7`` type for %%v%%.
+     */
+    static bytes7(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes8`` type for %%v%%.
+     */
+    static bytes8(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes9`` type for %%v%%.
+     */
+    static bytes9(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes10`` type for %%v%%.
+     */
+    static bytes10(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes11`` type for %%v%%.
+     */
+    static bytes11(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes12`` type for %%v%%.
+     */
+    static bytes12(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes13`` type for %%v%%.
+     */
+    static bytes13(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes14`` type for %%v%%.
+     */
+    static bytes14(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes15`` type for %%v%%.
+     */
+    static bytes15(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes16`` type for %%v%%.
+     */
+    static bytes16(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes17`` type for %%v%%.
+     */
+    static bytes17(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes18`` type for %%v%%.
+     */
+    static bytes18(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes19`` type for %%v%%.
+     */
+    static bytes19(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes20`` type for %%v%%.
+     */
+    static bytes20(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes21`` type for %%v%%.
+     */
+    static bytes21(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes22`` type for %%v%%.
+     */
+    static bytes22(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes23`` type for %%v%%.
+     */
+    static bytes23(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes24`` type for %%v%%.
+     */
+    static bytes24(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes25`` type for %%v%%.
+     */
+    static bytes25(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes26`` type for %%v%%.
+     */
+    static bytes26(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes27`` type for %%v%%.
+     */
+    static bytes27(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes28`` type for %%v%%.
+     */
+    static bytes28(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes29`` type for %%v%%.
+     */
+    static bytes29(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes30`` type for %%v%%.
+     */
+    static bytes30(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes31`` type for %%v%%.
+     */
+    static bytes31(v: BytesLike): Typed;
+    /**
+     *  Return a new ``bytes32`` type for %%v%%.
+     */
+    static bytes32(v: BytesLike): Typed;
+    /**
+     *  Return a new ``address`` type for %%v%%.
+     */
+    static address(v: string | Addressable): Typed;
+    /**
+     *  Return a new ``bool`` type for %%v%%.
+     */
+    static bool(v: any): Typed;
+    /**
+     *  Return a new ``bytes`` type for %%v%%.
+     */
+    static bytes(v: BytesLike): Typed;
+    /**
+     *  Return a new ``string`` type for %%v%%.
+     */
+    static string(v: string): Typed;
+    /**
+     *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
+     */
+    static array(v: Array<any | Typed>, dynamic?: null | boolean): Typed;
+    /**
+     *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
+     */
+    static tuple(v: Array<any | Typed> | Record<string, any | Typed>, name?: string): Typed;
+    /**
+     *  Return a new ``uint8`` type for %%v%%.
+     */
+    static overrides(v: Record<string, any>): Typed;
+    /**
+     *  Returns true only if %%value%% is a [[Typed]] instance.
+     */
+    static isTyped(value: any): value is Typed;
+    /**
+     *  If the value is a [[Typed]] instance, validates the underlying value
+     *  and returns it, otherwise returns value directly.
+     *
+     *  This is useful for functions that with to accept either a [[Typed]]
+     *  object or values.
+     */
+    static dereference<T>(value: Typed | T, type: string): T;
+}
+//# sourceMappingURL=typed.d.ts.map

hl_helper/node_modules/ethers/lib.esm/abi/typed.js

@@ -0,0 +1,602 @@
+/**
+ *  A Typed object allows a value to have its type explicitly
+ *  specified.
+ *
+ *  For example, in Solidity, the value ``45`` could represent a
+ *  ``uint8`` or a ``uint256``. The value ``0x1234`` could represent
+ *  a ``bytes2`` or ``bytes``.
+ *
+ *  Since JavaScript has no meaningful way to explicitly inform any
+ *  APIs which what the type is, this allows transparent interoperation
+ *  with Soldity.
+ *
+ *  @_subsection: api/abi:Typed Values
+ */
+import { assertPrivate, defineProperties } from "../utils/index.js";
+const _gaurd = {};
+function n(value, width) {
+    let signed = false;
+    if (width < 0) {
+        signed = true;
+        width *= -1;
+    }
+    // @TODO: Check range is valid for value
+    return new Typed(_gaurd, `${signed ? "" : "u"}int${width}`, value, { signed, width });
+}
+function b(value, size) {
+    // @TODO: Check range is valid for value
+    return new Typed(_gaurd, `bytes${(size) ? size : ""}`, value, { size });
+}
+const _typedSymbol = Symbol.for("_ethers_typed");
+/**
+ *  The **Typed** class to wrap values providing explicit type information.
+ */
+export class Typed {
+    /**
+     *  The type, as a Solidity-compatible type.
+     */
+    type;
+    /**
+     *  The actual value.
+     */
+    value;
+    #options;
+    /**
+     *  @_ignore:
+     */
+    _typedSymbol;
+    /**
+     *  @_ignore:
+     */
+    constructor(gaurd, type, value, options) {
+        if (options == null) {
+            options = null;
+        }
+        assertPrivate(_gaurd, gaurd, "Typed");
+        defineProperties(this, { _typedSymbol, type, value });
+        this.#options = options;
+        // Check the value is valid
+        this.format();
+    }
+    /**
+     *  Format the type as a Human-Readable type.
+     */
+    format() {
+        if (this.type === "array") {
+            throw new Error("");
+        }
+        else if (this.type === "dynamicArray") {
+            throw new Error("");
+        }
+        else if (this.type === "tuple") {
+            return `tuple(${this.value.map((v) => v.format()).join(",")})`;
+        }
+        return this.type;
+    }
+    /**
+     *  The default value returned by this type.
+     */
+    defaultValue() {
+        return 0;
+    }
+    /**
+     *  The minimum value for numeric types.
+     */
+    minValue() {
+        return 0;
+    }
+    /**
+     *  The maximum value for numeric types.
+     */
+    maxValue() {
+        return 0;
+    }
+    /**
+     *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
+     */
+    isBigInt() {
+        return !!(this.type.match(/^u?int[0-9]+$/));
+    }
+    /**
+     *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
+     */
+    isData() {
+        return this.type.startsWith("bytes");
+    }
+    /**
+     *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
+     */
+    isString() {
+        return (this.type === "string");
+    }
+    /**
+     *  Returns the tuple name, if this is a tuple. Throws otherwise.
+     */
+    get tupleName() {
+        if (this.type !== "tuple") {
+            throw TypeError("not a tuple");
+        }
+        return this.#options;
+    }
+    // Returns the length of this type as an array
+    // - `null` indicates the length is unforced, it could be dynamic
+    // - `-1` indicates the length is dynamic
+    // - any other value indicates it is a static array and is its length
+    /**
+     *  Returns the length of the array type or ``-1`` if it is dynamic.
+     *
+     *  Throws if the type is not an array.
+     */
+    get arrayLength() {
+        if (this.type !== "array") {
+            throw TypeError("not an array");
+        }
+        if (this.#options === true) {
+            return -1;
+        }
+        if (this.#options === false) {
+            return (this.value).length;
+        }
+        return null;
+    }
+    /**
+     *  Returns a new **Typed** of %%type%% with the %%value%%.
+     */
+    static from(type, value) {
+        return new Typed(_gaurd, type, value);
+    }
+    /**
+     *  Return a new ``uint8`` type for %%v%%.
+     */
+    static uint8(v) { return n(v, 8); }
+    /**
+     *  Return a new ``uint16`` type for %%v%%.
+     */
+    static uint16(v) { return n(v, 16); }
+    /**
+     *  Return a new ``uint24`` type for %%v%%.
+     */
+    static uint24(v) { return n(v, 24); }
+    /**
+     *  Return a new ``uint32`` type for %%v%%.
+     */
+    static uint32(v) { return n(v, 32); }
+    /**
+     *  Return a new ``uint40`` type for %%v%%.
+     */
+    static uint40(v) { return n(v, 40); }
+    /**
+     *  Return a new ``uint48`` type for %%v%%.
+     */
+    static uint48(v) { return n(v, 48); }
+    /**
+     *  Return a new ``uint56`` type for %%v%%.
+     */
+    static uint56(v) { return n(v, 56); }
+    /**
+     *  Return a new ``uint64`` type for %%v%%.
+     */
+    static uint64(v) { return n(v, 64); }
+    /**
+     *  Return a new ``uint72`` type for %%v%%.
+     */
+    static uint72(v) { return n(v, 72); }
+    /**
+     *  Return a new ``uint80`` type for %%v%%.
+     */
+    static uint80(v) { return n(v, 80); }
+    /**
+     *  Return a new ``uint88`` type for %%v%%.
+     */
+    static uint88(v) { return n(v, 88); }
+    /**
+     *  Return a new ``uint96`` type for %%v%%.
+     */
+    static uint96(v) { return n(v, 96); }
+    /**
+     *  Return a new ``uint104`` type for %%v%%.
+     */
+    static uint104(v) { return n(v, 104); }
+    /**
+     *  Return a new ``uint112`` type for %%v%%.
+     */
+    static uint112(v) { return n(v, 112); }
+    /**
+     *  Return a new ``uint120`` type for %%v%%.
+     */
+    static uint120(v) { return n(v, 120); }
+    /**
+     *  Return a new ``uint128`` type for %%v%%.
+     */
+    static uint128(v) { return n(v, 128); }
+    /**
+     *  Return a new ``uint136`` type for %%v%%.
+     */
+    static uint136(v) { return n(v, 136); }
+    /**
+     *  Return a new ``uint144`` type for %%v%%.
+     */
+    static uint144(v) { return n(v, 144); }
+    /**
+     *  Return a new ``uint152`` type for %%v%%.
+     */
+    static uint152(v) { return n(v, 152); }
+    /**
+     *  Return a new ``uint160`` type for %%v%%.
+     */
+    static uint160(v) { return n(v, 160); }
+    /**
+     *  Return a new ``uint168`` type for %%v%%.
+     */
+    static uint168(v) { return n(v, 168); }
+    /**
+     *  Return a new ``uint176`` type for %%v%%.
+     */
+    static uint176(v) { return n(v, 176); }
+    /**
+     *  Return a new ``uint184`` type for %%v%%.
+     */
+    static uint184(v) { return n(v, 184); }
+    /**
+     *  Return a new ``uint192`` type for %%v%%.
+     */
+    static uint192(v) { return n(v, 192); }
+    /**
+     *  Return a new ``uint200`` type for %%v%%.
+     */
+    static uint200(v) { return n(v, 200); }
+    /**
+     *  Return a new ``uint208`` type for %%v%%.
+     */
+    static uint208(v) { return n(v, 208); }
+    /**
+     *  Return a new ``uint216`` type for %%v%%.
+     */
+    static uint216(v) { return n(v, 216); }
+    /**
+     *  Return a new ``uint224`` type for %%v%%.
+     */
+    static uint224(v) { return n(v, 224); }
+    /**
+     *  Return a new ``uint232`` type for %%v%%.
+     */
+    static uint232(v) { return n(v, 232); }
+    /**
+     *  Return a new ``uint240`` type for %%v%%.
+     */
+    static uint240(v) { return n(v, 240); }
+    /**
+     *  Return a new ``uint248`` type for %%v%%.
+     */
+    static uint248(v) { return n(v, 248); }
+    /**
+     *  Return a new ``uint256`` type for %%v%%.
+     */
+    static uint256(v) { return n(v, 256); }
+    /**
+     *  Return a new ``uint256`` type for %%v%%.
+     */
+    static uint(v) { return n(v, 256); }
+    /**
+     *  Return a new ``int8`` type for %%v%%.
+     */
+    static int8(v) { return n(v, -8); }
+    /**
+     *  Return a new ``int16`` type for %%v%%.
+     */
+    static int16(v) { return n(v, -16); }
+    /**
+     *  Return a new ``int24`` type for %%v%%.
+     */
+    static int24(v) { return n(v, -24); }
+    /**
+     *  Return a new ``int32`` type for %%v%%.
+     */
+    static int32(v) { return n(v, -32); }
+    /**
+     *  Return a new ``int40`` type for %%v%%.
+     */
+    static int40(v) { return n(v, -40); }
+    /**
+     *  Return a new ``int48`` type for %%v%%.
+     */
+    static int48(v) { return n(v, -48); }
+    /**
+     *  Return a new ``int56`` type for %%v%%.
+     */
+    static int56(v) { return n(v, -56); }
+    /**
+     *  Return a new ``int64`` type for %%v%%.
+     */
+    static int64(v) { return n(v, -64); }
+    /**
+     *  Return a new ``int72`` type for %%v%%.
+     */
+    static int72(v) { return n(v, -72); }
+    /**
+     *  Return a new ``int80`` type for %%v%%.
+     */
+    static int80(v) { return n(v, -80); }
+    /**
+     *  Return a new ``int88`` type for %%v%%.
+     */
+    static int88(v) { return n(v, -88); }
+    /**
+     *  Return a new ``int96`` type for %%v%%.
+     */
+    static int96(v) { return n(v, -96); }
+    /**
+     *  Return a new ``int104`` type for %%v%%.
+     */
+    static int104(v) { return n(v, -104); }
+    /**
+     *  Return a new ``int112`` type for %%v%%.
+     */
+    static int112(v) { return n(v, -112); }
+    /**
+     *  Return a new ``int120`` type for %%v%%.
+     */
+    static int120(v) { return n(v, -120); }
+    /**
+     *  Return a new ``int128`` type for %%v%%.
+     */
+    static int128(v) { return n(v, -128); }
+    /**
+     *  Return a new ``int136`` type for %%v%%.
+     */
+    static int136(v) { return n(v, -136); }
+    /**
+     *  Return a new ``int144`` type for %%v%%.
+     */
+    static int144(v) { return n(v, -144); }
+    /**
+     *  Return a new ``int52`` type for %%v%%.
+     */
+    static int152(v) { return n(v, -152); }
+    /**
+     *  Return a new ``int160`` type for %%v%%.
+     */
+    static int160(v) { return n(v, -160); }
+    /**
+     *  Return a new ``int168`` type for %%v%%.
+     */
+    static int168(v) { return n(v, -168); }
+    /**
+     *  Return a new ``int176`` type for %%v%%.
+     */
+    static int176(v) { return n(v, -176); }
+    /**
+     *  Return a new ``int184`` type for %%v%%.
+     */
+    static int184(v) { return n(v, -184); }
+    /**
+     *  Return a new ``int92`` type for %%v%%.
+     */
+    static int192(v) { return n(v, -192); }
+    /**
+     *  Return a new ``int200`` type for %%v%%.
+     */
+    static int200(v) { return n(v, -200); }
+    /**
+     *  Return a new ``int208`` type for %%v%%.
+     */
+    static int208(v) { return n(v, -208); }
+    /**
+     *  Return a new ``int216`` type for %%v%%.
+     */
+    static int216(v) { return n(v, -216); }
+    /**
+     *  Return a new ``int224`` type for %%v%%.
+     */
+    static int224(v) { return n(v, -224); }
+    /**
+     *  Return a new ``int232`` type for %%v%%.
+     */
+    static int232(v) { return n(v, -232); }
+    /**
+     *  Return a new ``int240`` type for %%v%%.
+     */
+    static int240(v) { return n(v, -240); }
+    /**
+     *  Return a new ``int248`` type for %%v%%.
+     */
+    static int248(v) { return n(v, -248); }
+    /**
+     *  Return a new ``int256`` type for %%v%%.
+     */
+    static int256(v) { return n(v, -256); }
+    /**
+     *  Return a new ``int256`` type for %%v%%.
+     */
+    static int(v) { return n(v, -256); }
+    /**
+     *  Return a new ``bytes1`` type for %%v%%.
+     */
+    static bytes1(v) { return b(v, 1); }
+    /**
+     *  Return a new ``bytes2`` type for %%v%%.
+     */
+    static bytes2(v) { return b(v, 2); }
+    /**
+     *  Return a new ``bytes3`` type for %%v%%.
+     */
+    static bytes3(v) { return b(v, 3); }
+    /**
+     *  Return a new ``bytes4`` type for %%v%%.
+     */
+    static bytes4(v) { return b(v, 4); }
+    /**
+     *  Return a new ``bytes5`` type for %%v%%.
+     */
+    static bytes5(v) { return b(v, 5); }
+    /**
+     *  Return a new ``bytes6`` type for %%v%%.
+     */
+    static bytes6(v) { return b(v, 6); }
+    /**
+     *  Return a new ``bytes7`` type for %%v%%.
+     */
+    static bytes7(v) { return b(v, 7); }
+    /**
+     *  Return a new ``bytes8`` type for %%v%%.
+     */
+    static bytes8(v) { return b(v, 8); }
+    /**
+     *  Return a new ``bytes9`` type for %%v%%.
+     */
+    static bytes9(v) { return b(v, 9); }
+    /**
+     *  Return a new ``bytes10`` type for %%v%%.
+     */
+    static bytes10(v) { return b(v, 10); }
+    /**
+     *  Return a new ``bytes11`` type for %%v%%.
+     */
+    static bytes11(v) { return b(v, 11); }
+    /**
+     *  Return a new ``bytes12`` type for %%v%%.
+     */
+    static bytes12(v) { return b(v, 12); }
+    /**
+     *  Return a new ``bytes13`` type for %%v%%.
+     */
+    static bytes13(v) { return b(v, 13); }
+    /**
+     *  Return a new ``bytes14`` type for %%v%%.
+     */
+    static bytes14(v) { return b(v, 14); }
+    /**
+     *  Return a new ``bytes15`` type for %%v%%.
+     */
+    static bytes15(v) { return b(v, 15); }
+    /**
+     *  Return a new ``bytes16`` type for %%v%%.
+     */
+    static bytes16(v) { return b(v, 16); }
+    /**
+     *  Return a new ``bytes17`` type for %%v%%.
+     */
+    static bytes17(v) { return b(v, 17); }
+    /**
+     *  Return a new ``bytes18`` type for %%v%%.
+     */
+    static bytes18(v) { return b(v, 18); }
+    /**
+     *  Return a new ``bytes19`` type for %%v%%.
+     */
+    static bytes19(v) { return b(v, 19); }
+    /**
+     *  Return a new ``bytes20`` type for %%v%%.
+     */
+    static bytes20(v) { return b(v, 20); }
+    /**
+     *  Return a new ``bytes21`` type for %%v%%.
+     */
+    static bytes21(v) { return b(v, 21); }
+    /**
+     *  Return a new ``bytes22`` type for %%v%%.
+     */
+    static bytes22(v) { return b(v, 22); }
+    /**
+     *  Return a new ``bytes23`` type for %%v%%.
+     */
+    static bytes23(v) { return b(v, 23); }
+    /**
+     *  Return a new ``bytes24`` type for %%v%%.
+     */
+    static bytes24(v) { return b(v, 24); }
+    /**
+     *  Return a new ``bytes25`` type for %%v%%.
+     */
+    static bytes25(v) { return b(v, 25); }
+    /**
+     *  Return a new ``bytes26`` type for %%v%%.
+     */
+    static bytes26(v) { return b(v, 26); }
+    /**
+     *  Return a new ``bytes27`` type for %%v%%.
+     */
+    static bytes27(v) { return b(v, 27); }
+    /**
+     *  Return a new ``bytes28`` type for %%v%%.
+     */
+    static bytes28(v) { return b(v, 28); }
+    /**
+     *  Return a new ``bytes29`` type for %%v%%.
+     */
+    static bytes29(v) { return b(v, 29); }
+    /**
+     *  Return a new ``bytes30`` type for %%v%%.
+     */
+    static bytes30(v) { return b(v, 30); }
+    /**
+     *  Return a new ``bytes31`` type for %%v%%.
+     */
+    static bytes31(v) { return b(v, 31); }
+    /**
+     *  Return a new ``bytes32`` type for %%v%%.
+     */
+    static bytes32(v) { return b(v, 32); }
+    /**
+     *  Return a new ``address`` type for %%v%%.
+     */
+    static address(v) { return new Typed(_gaurd, "address", v); }
+    /**
+     *  Return a new ``bool`` type for %%v%%.
+     */
+    static bool(v) { return new Typed(_gaurd, "bool", !!v); }
+    /**
+     *  Return a new ``bytes`` type for %%v%%.
+     */
+    static bytes(v) { return new Typed(_gaurd, "bytes", v); }
+    /**
+     *  Return a new ``string`` type for %%v%%.
+     */
+    static string(v) { return new Typed(_gaurd, "string", v); }
+    /**
+     *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
+     */
+    static array(v, dynamic) {
+        throw new Error("not implemented yet");
+        return new Typed(_gaurd, "array", v, dynamic);
+    }
+    /**
+     *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
+     */
+    static tuple(v, name) {
+        throw new Error("not implemented yet");
+        return new Typed(_gaurd, "tuple", v, name);
+    }
+    /**
+     *  Return a new ``uint8`` type for %%v%%.
+     */
+    static overrides(v) {
+        return new Typed(_gaurd, "overrides", Object.assign({}, v));
+    }
+    /**
+     *  Returns true only if %%value%% is a [[Typed]] instance.
+     */
+    static isTyped(value) {
+        return (value
+            && typeof (value) === "object"
+            && "_typedSymbol" in value
+            && value._typedSymbol === _typedSymbol);
+    }
+    /**
+     *  If the value is a [[Typed]] instance, validates the underlying value
+     *  and returns it, otherwise returns value directly.
+     *
+     *  This is useful for functions that with to accept either a [[Typed]]
+     *  object or values.
+     */
+    static dereference(value, type) {
+        if (Typed.isTyped(value)) {
+            if (value.type !== type) {
+                throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);
+            }
+            return value.value;
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=typed.js.map

hl_helper/node_modules/ethers/lib.esm/address/address.d.ts

@@ -0,0 +1,56 @@
+/**
+ *  Returns a normalized and checksumed address for %%address%%.
+ *  This accepts non-checksum addresses, checksum addresses and
+ *  [[getIcapAddress]] formats.
+ *
+ *  The checksum in Ethereum uses the capitalization (upper-case
+ *  vs lower-case) of the characters within an address to encode
+ *  its checksum, which offers, on average, a checksum of 15-bits.
+ *
+ *  If %%address%% contains both upper-case and lower-case, it is
+ *  assumed to already be a checksum address and its checksum is
+ *  validated, and if the address fails its expected checksum an
+ *  error is thrown.
+ *
+ *  If you wish the checksum of %%address%% to be ignore, it should
+ *  be converted to lower-case (i.e. ``.toLowercase()``) before
+ *  being passed in. This should be a very rare situation though,
+ *  that you wish to bypass the safegaurds in place to protect
+ *  against an address that has been incorrectly copied from another
+ *  source.
+ *
+ *  @example:
+ *    // Adds the checksum (via upper-casing specific letters)
+ *    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
+ *    //_result:
+ *
+ *    // Converts ICAP address and adds checksum
+ *    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if an address contains mixed case,
+ *    // but the checksum fails
+ *    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_error:
+ */
+export declare function getAddress(address: string): string;
+/**
+ *  The [ICAP Address format](link-icap) format is an early checksum
+ *  format which attempts to be compatible with the banking
+ *  industry [IBAN format](link-wiki-iban) for bank accounts.
+ *
+ *  It is no longer common or a recommended format.
+ *
+ *  @example:
+ *    getIcapAddress("0x8ba1f109551bd432803012645ac136ddd64dba72");
+ *    //_result:
+ *
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if the ICAP checksum is wrong
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37");
+ *    //_error:
+ */
+export declare function getIcapAddress(address: string): string;
+//# sourceMappingURL=address.d.ts.map

hl_helper/node_modules/ethers/lib.esm/address/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../../src.ts/address/address.ts"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA6BlD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAKtD"}

hl_helper/node_modules/ethers/lib.esm/address/address.js

@@ -0,0 +1,156 @@
+import { keccak256 } from "../crypto/index.js";
+import { getBytes, assertArgument } from "../utils/index.js";
+const BN_0 = BigInt(0);
+const BN_36 = BigInt(36);
+function getChecksumAddress(address) {
+    //    if (!isHexString(address, 20)) {
+    //        logger.throwArgumentError("invalid address", "address", address);
+    //    }
+    address = address.toLowerCase();
+    const chars = address.substring(2).split("");
+    const expanded = new Uint8Array(40);
+    for (let i = 0; i < 40; i++) {
+        expanded[i] = chars[i].charCodeAt(0);
+    }
+    const hashed = getBytes(keccak256(expanded));
+    for (let i = 0; i < 40; i += 2) {
+        if ((hashed[i >> 1] >> 4) >= 8) {
+            chars[i] = chars[i].toUpperCase();
+        }
+        if ((hashed[i >> 1] & 0x0f) >= 8) {
+            chars[i + 1] = chars[i + 1].toUpperCase();
+        }
+    }
+    return "0x" + chars.join("");
+}
+// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number
+// Create lookup table
+const ibanLookup = {};
+for (let i = 0; i < 10; i++) {
+    ibanLookup[String(i)] = String(i);
+}
+for (let i = 0; i < 26; i++) {
+    ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
+}
+// How many decimal digits can we process? (for 64-bit float, this is 15)
+// i.e. Math.floor(Math.log10(Number.MAX_SAFE_INTEGER));
+const safeDigits = 15;
+function ibanChecksum(address) {
+    address = address.toUpperCase();
+    address = address.substring(4) + address.substring(0, 2) + "00";
+    let expanded = address.split("").map((c) => { return ibanLookup[c]; }).join("");
+    // Javascript can handle integers safely up to 15 (decimal) digits
+    while (expanded.length >= safeDigits) {
+        let block = expanded.substring(0, safeDigits);
+        expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
+    }
+    let checksum = String(98 - (parseInt(expanded, 10) % 97));
+    while (checksum.length < 2) {
+        checksum = "0" + checksum;
+    }
+    return checksum;
+}
+;
+const Base36 = (function () {
+    ;
+    const result = {};
+    for (let i = 0; i < 36; i++) {
+        const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i];
+        result[key] = BigInt(i);
+    }
+    return result;
+})();
+function fromBase36(value) {
+    value = value.toLowerCase();
+    let result = BN_0;
+    for (let i = 0; i < value.length; i++) {
+        result = result * BN_36 + Base36[value[i]];
+    }
+    return result;
+}
+/**
+ *  Returns a normalized and checksumed address for %%address%%.
+ *  This accepts non-checksum addresses, checksum addresses and
+ *  [[getIcapAddress]] formats.
+ *
+ *  The checksum in Ethereum uses the capitalization (upper-case
+ *  vs lower-case) of the characters within an address to encode
+ *  its checksum, which offers, on average, a checksum of 15-bits.
+ *
+ *  If %%address%% contains both upper-case and lower-case, it is
+ *  assumed to already be a checksum address and its checksum is
+ *  validated, and if the address fails its expected checksum an
+ *  error is thrown.
+ *
+ *  If you wish the checksum of %%address%% to be ignore, it should
+ *  be converted to lower-case (i.e. ``.toLowercase()``) before
+ *  being passed in. This should be a very rare situation though,
+ *  that you wish to bypass the safegaurds in place to protect
+ *  against an address that has been incorrectly copied from another
+ *  source.
+ *
+ *  @example:
+ *    // Adds the checksum (via upper-casing specific letters)
+ *    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
+ *    //_result:
+ *
+ *    // Converts ICAP address and adds checksum
+ *    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if an address contains mixed case,
+ *    // but the checksum fails
+ *    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_error:
+ */
+export function getAddress(address) {
+    assertArgument(typeof (address) === "string", "invalid address", "address", address);
+    if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
+        // Missing the 0x prefix
+        if (!address.startsWith("0x")) {
+            address = "0x" + address;
+        }
+        const result = getChecksumAddress(address);
+        // It is a checksummed address with a bad checksum
+        assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, "bad address checksum", "address", address);
+        return result;
+    }
+    // Maybe ICAP? (we only support direct mode)
+    if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
+        // It is an ICAP address with a bad checksum
+        assertArgument(address.substring(2, 4) === ibanChecksum(address), "bad icap checksum", "address", address);
+        let result = fromBase36(address.substring(4)).toString(16);
+        while (result.length < 40) {
+            result = "0" + result;
+        }
+        return getChecksumAddress("0x" + result);
+    }
+    assertArgument(false, "invalid address", "address", address);
+}
+/**
+ *  The [ICAP Address format](link-icap) format is an early checksum
+ *  format which attempts to be compatible with the banking
+ *  industry [IBAN format](link-wiki-iban) for bank accounts.
+ *
+ *  It is no longer common or a recommended format.
+ *
+ *  @example:
+ *    getIcapAddress("0x8ba1f109551bd432803012645ac136ddd64dba72");
+ *    //_result:
+ *
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if the ICAP checksum is wrong
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37");
+ *    //_error:
+ */
+export function getIcapAddress(address) {
+    //let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase();
+    let base36 = BigInt(getAddress(address)).toString(36).toUpperCase();
+    while (base36.length < 30) {
+        base36 = "0" + base36;
+    }
+    return "XE" + ibanChecksum("XE00" + base36) + base36;
+}
+//# sourceMappingURL=address.js.map

hl_helper/node_modules/ethers/lib.esm/address/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../src.ts/address/address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG7D,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AACvB,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC;AAEzB,SAAS,kBAAkB,CAAC,OAAe;IAC3C,sCAAsC;IACtC,2EAA2E;IAC3E,OAAO;IAEH,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAEhC,MAAM,KAAK,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAE7C,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;QACzB,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;KACxC;IAED,MAAM,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;IAE7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE;QAC5B,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE;YAC5B,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;SACrC;QACD,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,EAAE;YAC9B,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;SAC7C;KACJ;IAED,OAAO,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACjC,CAAC;AAED,uEAAuE;AAEvE,sBAAsB;AACtB,MAAM,UAAU,GAAoC,EAAG,CAAC;AACxD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;IAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;CAAE;AACnE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;IAAE,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;CAAE;AAE1F,yEAAyE;AACzE,wDAAwD;AACxD,MAAM,UAAU,GAAG,EAAE,CAAC;AAEtB,SAAS,YAAY,CAAC,OAAe;IACjC,OAAO,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAChC,OAAO,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC;IAEhE,IAAI,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAEhF,kEAAkE;IAClE,OAAO,QAAQ,CAAC,MAAM,IAAI,UAAU,EAAC;QACjC,IAAI,KAAK,GAAG,QAAQ,CAAC,SAAS,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAC9C,QAAQ,GAAG,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;KAC1E;IAED,IAAI,QAAQ,GAAG,MAAM,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1D,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;QAAE,QAAQ,GAAG,GAAG,GAAG,QAAQ,CAAC;KAAE;IAE1D,OAAO,QAAQ,CAAC;AACpB,CAAC;AAAA,CAAC;AAEF,MAAM,MAAM,GAAG,CAAC;IAAY,CAAC;IACzB,MAAM,MAAM,GAA2B,EAAG,CAAC;IAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE;QACzB,MAAM,GAAG,GAAG,sCAAsC,CAAC,CAAC,CAAC,CAAC;QACtD,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;KAC3B;IACD,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC,EAAE,CAAC;AAEL,SAAS,UAAU,CAAC,KAAa;IAC7B,KAAK,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IAE5B,IAAI,MAAM,GAAG,IAAI,CAAC;IAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACnC,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;KAC9C;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,UAAU,UAAU,CAAC,OAAe;IAEtC,cAAc,CAAC,OAAM,CAAC,OAAO,CAAC,KAAK,QAAQ,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAEpF,IAAI,OAAO,CAAC,KAAK,CAAC,wBAAwB,CAAC,EAAE;QAEzC,wBAAwB;QACxB,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC;SAAE;QAE5D,MAAM,MAAM,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAE3C,kDAAkD;QAClD,cAAc,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,+BAA+B,CAAC,IAAI,MAAM,KAAK,OAAO,EAChF,sBAAsB,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAEhD,OAAO,MAAM,CAAC;KACjB;IAED,4CAA4C;IAC5C,IAAI,OAAO,CAAC,KAAK,CAAC,gCAAgC,CAAC,EAAE;QACjD,4CAA4C;QAC5C,cAAc,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;QAE3G,IAAI,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC3D,OAAO,MAAM,CAAC,MAAM,GAAG,EAAE,EAAE;YAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC;SAAE;QACrD,OAAQ,kBAAkB,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;KAC7C;IAED,cAAc,CAAC,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe;IAC1C,2EAA2E;IAC3E,IAAI,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IACpE,OAAO,MAAM,CAAC,MAAM,GAAG,EAAE,EAAE;QAAE,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC;KAAE;IACrD,OAAO,IAAI,GAAG,YAAY,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC;AACzD,CAAC"}

hl_helper/node_modules/ethers/lib.esm/address/checks.d.ts

@@ -0,0 +1,81 @@
+import type { Addressable, AddressLike, NameResolver } from "./index.js";
+/**
+ *  Returns true if %%value%% is an object which implements the
+ *  [[Addressable]] interface.
+ *
+ *  @example:
+ *    // Wallets and AbstractSigner sub-classes
+ *    isAddressable(Wallet.createRandom())
+ *    //_result:
+ *
+ *    // Contracts
+ *    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
+ *    isAddressable(contract)
+ *    //_result:
+ */
+export declare function isAddressable(value: any): value is Addressable;
+/**
+ *  Returns true if %%value%% is a valid address.
+ *
+ *  @example:
+ *    // Valid address
+ *    isAddress("0x8ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Valid ICAP address
+ *    isAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36")
+ *    //_result:
+ *
+ *    // Invalid checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBa72")
+ *    //_result:
+ *
+ *    // Invalid ICAP checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Not an address (an ENS name requires a provided and an
+ *    // asynchronous API to access)
+ *    isAddress("ricmoo.eth")
+ *    //_result:
+ */
+export declare function isAddress(value: any): value is string;
+/**
+ *  Resolves to an address for the %%target%%, which may be any
+ *  supported address type, an [[Addressable]] or a Promise which
+ *  resolves to an address.
+ *
+ *  If an ENS name is provided, but that name has not been correctly
+ *  configured a [[UnconfiguredNameError]] is thrown.
+ *
+ *  @example:
+ *    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+ *
+ *    // Addresses are return synchronously
+ *    resolveAddress(addr, provider)
+ *    //_result:
+ *
+ *    // Address promises are resolved asynchronously
+ *    resolveAddress(Promise.resolve(addr))
+ *    //_result:
+ *
+ *    // ENS names are resolved asynchronously
+ *    resolveAddress("dai.tokens.ethers.eth", provider)
+ *    //_result:
+ *
+ *    // Addressable objects are resolved asynchronously
+ *    contract = new Contract(addr, [ ])
+ *    resolveAddress(contract, provider)
+ *    //_result:
+ *
+ *    // Unconfigured ENS names reject
+ *    resolveAddress("nothing-here.ricmoo.eth", provider)
+ *    //_error:
+ *
+ *    // ENS names require a NameResolver object passed in
+ *    // (notice the provider was omitted)
+ *    resolveAddress("nothing-here.ricmoo.eth")
+ *    //_error:
+ */
+export declare function resolveAddress(target: AddressLike, resolver?: null | NameResolver): string | Promise<string>;
+//# sourceMappingURL=checks.d.ts.map

hl_helper/node_modules/ethers/lib.esm/address/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../src.ts/address/checks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAGzE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,WAAW,CAE9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,MAAM,CAMrD;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,IAAI,GAAG,YAAY,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkB5G"}

hl_helper/node_modules/ethers/lib.esm/address/checks.js

@@ -0,0 +1,114 @@
+import { assert, assertArgument } from "../utils/index.js";
+import { getAddress } from "./address.js";
+/**
+ *  Returns true if %%value%% is an object which implements the
+ *  [[Addressable]] interface.
+ *
+ *  @example:
+ *    // Wallets and AbstractSigner sub-classes
+ *    isAddressable(Wallet.createRandom())
+ *    //_result:
+ *
+ *    // Contracts
+ *    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
+ *    isAddressable(contract)
+ *    //_result:
+ */
+export function isAddressable(value) {
+    return (value && typeof (value.getAddress) === "function");
+}
+/**
+ *  Returns true if %%value%% is a valid address.
+ *
+ *  @example:
+ *    // Valid address
+ *    isAddress("0x8ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Valid ICAP address
+ *    isAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36")
+ *    //_result:
+ *
+ *    // Invalid checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBa72")
+ *    //_result:
+ *
+ *    // Invalid ICAP checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Not an address (an ENS name requires a provided and an
+ *    // asynchronous API to access)
+ *    isAddress("ricmoo.eth")
+ *    //_result:
+ */
+export function isAddress(value) {
+    try {
+        getAddress(value);
+        return true;
+    }
+    catch (error) { }
+    return false;
+}
+async function checkAddress(target, promise) {
+    const result = await promise;
+    if (result == null || result === "0x0000000000000000000000000000000000000000") {
+        assert(typeof (target) !== "string", "unconfigured name", "UNCONFIGURED_NAME", { value: target });
+        assertArgument(false, "invalid AddressLike value; did not resolve to a value address", "target", target);
+    }
+    return getAddress(result);
+}
+/**
+ *  Resolves to an address for the %%target%%, which may be any
+ *  supported address type, an [[Addressable]] or a Promise which
+ *  resolves to an address.
+ *
+ *  If an ENS name is provided, but that name has not been correctly
+ *  configured a [[UnconfiguredNameError]] is thrown.
+ *
+ *  @example:
+ *    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+ *
+ *    // Addresses are return synchronously
+ *    resolveAddress(addr, provider)
+ *    //_result:
+ *
+ *    // Address promises are resolved asynchronously
+ *    resolveAddress(Promise.resolve(addr))
+ *    //_result:
+ *
+ *    // ENS names are resolved asynchronously
+ *    resolveAddress("dai.tokens.ethers.eth", provider)
+ *    //_result:
+ *
+ *    // Addressable objects are resolved asynchronously
+ *    contract = new Contract(addr, [ ])
+ *    resolveAddress(contract, provider)
+ *    //_result:
+ *
+ *    // Unconfigured ENS names reject
+ *    resolveAddress("nothing-here.ricmoo.eth", provider)
+ *    //_error:
+ *
+ *    // ENS names require a NameResolver object passed in
+ *    // (notice the provider was omitted)
+ *    resolveAddress("nothing-here.ricmoo.eth")
+ *    //_error:
+ */
+export function resolveAddress(target, resolver) {
+    if (typeof (target) === "string") {
+        if (target.match(/^0x[0-9a-f]{40}$/i)) {
+            return getAddress(target);
+        }
+        assert(resolver != null, "ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
+        return checkAddress(target, resolver.resolveName(target));
+    }
+    else if (isAddressable(target)) {
+        return checkAddress(target, target.getAddress());
+    }
+    else if (target && typeof (target.then) === "function") {
+        return checkAddress(target, target);
+    }
+    assertArgument(false, "unsupported addressable value", "target", target);
+}
+//# sourceMappingURL=checks.js.map

hl_helper/node_modules/ethers/lib.esm/address/checks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.js","sourceRoot":"","sources":["../../src.ts/address/checks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAK1C;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,aAAa,CAAC,KAAU;IACpC,OAAO,CAAC,KAAK,IAAI,OAAM,CAAC,KAAK,CAAC,UAAU,CAAC,KAAK,UAAU,CAAC,CAAC;AAC9D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,SAAS,CAAC,KAAU;IAChC,IAAI;QACA,UAAU,CAAC,KAAK,CAAC,CAAC;QAClB,OAAO,IAAI,CAAC;KACf;IAAC,OAAO,KAAK,EAAE,GAAG;IACnB,OAAO,KAAK,CAAC;AACjB,CAAC;AAED,KAAK,UAAU,YAAY,CAAC,MAAW,EAAE,OAA+B;IACpE,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC;IAC7B,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,KAAK,4CAA4C,EAAE;QAC3E,MAAM,CAAC,OAAM,CAAC,MAAM,CAAC,KAAK,QAAQ,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QACjG,cAAc,CAAC,KAAK,EAAE,+DAA+D,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;KAC5G;IACD,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;AAC9B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,UAAU,cAAc,CAAC,MAAmB,EAAE,QAA8B;IAE9E,IAAI,OAAM,CAAC,MAAM,CAAC,KAAK,QAAQ,EAAE;QAC7B,IAAI,MAAM,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE;YAAE,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;SAAE;QAErE,MAAM,CAAC,QAAQ,IAAI,IAAI,EAAE,oCAAoC,EACzD,uBAAuB,EAAE,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC;QAE3D,OAAO,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;KAE7D;SAAM,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE;QAC9B,OAAO,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC;KAEpD;SAAM,IAAI,MAAM,IAAI,OAAM,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,UAAU,EAAE;QACrD,OAAO,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACvC;IAED,cAAc,CAAC,KAAK,EAAE,+BAA+B,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AAC7E,CAAC"}

hl_helper/node_modules/ethers/lib.esm/address/contract-address.d.ts

@@ -0,0 +1,48 @@
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+/**
+ *  Returns the address that would result from a ``CREATE`` for %%tx%%.
+ *
+ *  This can be used to compute the address a contract will be
+ *  deployed to by an EOA when sending a deployment transaction (i.e.
+ *  when the ``to`` address is ``null``).
+ *
+ *  This can also be used to compute the address a contract will be
+ *  deployed to by a contract, by using the contract's address as the
+ *  ``to`` and the contract's nonce.
+ *
+ *  @example
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
+ *    nonce = 5;
+ *
+ *    getCreateAddress({ from, nonce });
+ *    //_result:
+ */
+export declare function getCreateAddress(tx: {
+    from: string;
+    nonce: BigNumberish;
+}): string;
+/**
+ *  Returns the address that would result from a ``CREATE2`` operation
+ *  with the given %%from%%, %%salt%% and %%initCodeHash%%.
+ *
+ *  To compute the %%initCodeHash%% from a contract's init code, use
+ *  the [[keccak256]] function.
+ *
+ *  For a quick overview and example of ``CREATE2``, see [[link-ricmoo-wisps]].
+ *
+ *  @example
+ *    // The address of the contract
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
+ *
+ *    // The salt
+ *    salt = id("HelloWorld")
+ *
+ *    // The hash of the initCode
+ *    initCode = "0x6394198df16000526103ff60206004601c335afa6040516060f3";
+ *    initCodeHash = keccak256(initCode)
+ *
+ *    getCreate2Address(from, salt, initCodeHash)
+ *    //_result:
+ */
+export declare function getCreate2Address(_from: string, _salt: BytesLike, _initCodeHash: BytesLike): string;
+//# sourceMappingURL=contract-address.d.ts.map

hl_helper/node_modules/ethers/lib.esm/address/contract-address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-address.d.ts","sourceRoot":"","sources":["../../src.ts/address/contract-address.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAKjE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,GAAG,MAAM,CAclF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,GAAG,MAAM,CAUnG"}

hl_helper/node_modules/ethers/lib.esm/address/contract-address.js

@@ -0,0 +1,69 @@
+import { keccak256 } from "../crypto/index.js";
+import { concat, dataSlice, getBigInt, getBytes, encodeRlp, assertArgument } from "../utils/index.js";
+import { getAddress } from "./address.js";
+// http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed
+/**
+ *  Returns the address that would result from a ``CREATE`` for %%tx%%.
+ *
+ *  This can be used to compute the address a contract will be
+ *  deployed to by an EOA when sending a deployment transaction (i.e.
+ *  when the ``to`` address is ``null``).
+ *
+ *  This can also be used to compute the address a contract will be
+ *  deployed to by a contract, by using the contract's address as the
+ *  ``to`` and the contract's nonce.
+ *
+ *  @example
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
+ *    nonce = 5;
+ *
+ *    getCreateAddress({ from, nonce });
+ *    //_result:
+ */
+export function getCreateAddress(tx) {
+    const from = getAddress(tx.from);
+    const nonce = getBigInt(tx.nonce, "tx.nonce");
+    let nonceHex = nonce.toString(16);
+    if (nonceHex === "0") {
+        nonceHex = "0x";
+    }
+    else if (nonceHex.length % 2) {
+        nonceHex = "0x0" + nonceHex;
+    }
+    else {
+        nonceHex = "0x" + nonceHex;
+    }
+    return getAddress(dataSlice(keccak256(encodeRlp([from, nonceHex])), 12));
+}
+/**
+ *  Returns the address that would result from a ``CREATE2`` operation
+ *  with the given %%from%%, %%salt%% and %%initCodeHash%%.
+ *
+ *  To compute the %%initCodeHash%% from a contract's init code, use
+ *  the [[keccak256]] function.
+ *
+ *  For a quick overview and example of ``CREATE2``, see [[link-ricmoo-wisps]].
+ *
+ *  @example
+ *    // The address of the contract
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
+ *
+ *    // The salt
+ *    salt = id("HelloWorld")
+ *
+ *    // The hash of the initCode
+ *    initCode = "0x6394198df16000526103ff60206004601c335afa6040516060f3";
+ *    initCodeHash = keccak256(initCode)
+ *
+ *    getCreate2Address(from, salt, initCodeHash)
+ *    //_result:
+ */
+export function getCreate2Address(_from, _salt, _initCodeHash) {
+    const from = getAddress(_from);
+    const salt = getBytes(_salt, "salt");
+    const initCodeHash = getBytes(_initCodeHash, "initCodeHash");
+    assertArgument(salt.length === 32, "salt must be 32 bytes", "salt", _salt);
+    assertArgument(initCodeHash.length === 32, "initCodeHash must be 32 bytes", "initCodeHash", _initCodeHash);
+    return getAddress(dataSlice(keccak256(concat(["0xff", from, salt, initCodeHash])), 12));
+}
+//# sourceMappingURL=contract-address.js.map

hl_helper/node_modules/ethers/lib.esm/address/contract-address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-address.js","sourceRoot":"","sources":["../../src.ts/address/contract-address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EACH,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EACpE,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAK1C,sGAAsG;AAEtG;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAyC;IACtE,MAAM,IAAI,GAAG,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,KAAK,GAAG,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IAE9C,IAAI,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAClC,IAAI,QAAQ,KAAK,GAAG,EAAE;QAClB,QAAQ,GAAG,IAAI,CAAC;KACnB;SAAM,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;QAC5B,QAAQ,GAAG,KAAK,GAAG,QAAQ,CAAC;KAC/B;SAAM;QACH,QAAQ,GAAG,IAAI,GAAG,QAAQ,CAAC;KAC9B;IAED,OAAO,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,SAAS,CAAC,CAAE,IAAI,EAAE,QAAQ,CAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAa,EAAE,KAAgB,EAAE,aAAwB;IACvF,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAC/B,MAAM,IAAI,GAAG,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACrC,MAAM,YAAY,GAAG,QAAQ,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;IAE7D,cAAc,CAAC,IAAI,CAAC,MAAM,KAAK,EAAE,EAAE,uBAAuB,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAE3E,cAAc,CAAC,YAAY,CAAC,MAAM,KAAK,EAAE,EAAE,+BAA+B,EAAE,cAAc,EAAE,aAAa,CAAC,CAAC;IAE3G,OAAO,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,CAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,YAAY,CAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;AAC7F,CAAC"}

hl_helper/node_modules/ethers/lib.esm/address/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ *  Addresses are a fundamental part of interacting with Ethereum. They
+ *  represent the global identity of Externally Owned Accounts (accounts
+ *  backed by a private key) and contracts.
+ *
+ *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
+ *  of contracts, standards and libraries which enable looking up an
+ *  address for an ENS name.
+ *
+ *  These functions help convert between various formats, validate
+ *  addresses and safely resolve ENS names.
+ *
+ *  @_section: api/address:Addresses  [about-addresses]
+ */
+/**
+ *  An interface for objects which have an address, and can
+ *  resolve it asyncronously.
+ *
+ *  This allows objects such as [[Signer]] or [[Contract]] to
+ *  be used most places an address can be, for example getting
+ *  the [balance](Provider-getBalance).
+ */
+export interface Addressable {
+    /**
+     *  Get the object address.
+     */
+    getAddress(): Promise<string>;
+}
+/**
+ *  Anything that can be used to return or resolve an address.
+ */
+export type AddressLike = string | Promise<string> | Addressable;
+/**
+ *  An interface for any object which can resolve an ENS name.
+ */
+export interface NameResolver {
+    /**
+     *  Resolve to the address for the ENS %%name%%.
+     *
+     *  Resolves to ``null`` if the name is unconfigued. Use
+     *  [[resolveAddress]] (passing this object as %%resolver%%) to
+     *  throw for names that are unconfigured.
+     */
+    resolveName(name: string): Promise<null | string>;
+}
+export { getAddress, getIcapAddress } from "./address.js";
+export { getCreateAddress, getCreate2Address } from "./contract-address.js";
+export { isAddressable, isAddress, resolveAddress } from "./checks.js";
+//# sourceMappingURL=index.d.ts.map

hl_helper/node_modules/ethers/lib.esm/address/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src.ts/address/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IACxB;;OAEG;IACH,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC;AAEjE;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB;;;;;;OAMG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC;CACrD;AAED,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG5E,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

hl_helper/node_modules/ethers/lib.esm/address/index.js

@@ -0,0 +1,19 @@
+/**
+ *  Addresses are a fundamental part of interacting with Ethereum. They
+ *  represent the global identity of Externally Owned Accounts (accounts
+ *  backed by a private key) and contracts.
+ *
+ *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
+ *  of contracts, standards and libraries which enable looking up an
+ *  address for an ENS name.
+ *
+ *  These functions help convert between various formats, validate
+ *  addresses and safely resolve ENS names.
+ *
+ *  @_section: api/address:Addresses  [about-addresses]
+ */
+null;
+export { getAddress, getIcapAddress } from "./address.js";
+export { getCreateAddress, getCreate2Address } from "./contract-address.js";
+export { isAddressable, isAddress, resolveAddress } from "./checks.js";
+//# sourceMappingURL=index.js.map

hl_helper/node_modules/ethers/lib.esm/address/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src.ts/address/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,IAAI,CAAC;AAoCL,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG5E,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

hl_helper/node_modules/ethers/lib.esm/constants/addresses.d.ts

@@ -0,0 +1,7 @@
+/**
+ *  A constant for the zero address.
+ *
+ *  (**i.e.** ``"0x0000000000000000000000000000000000000000"``)
+ */
+export declare const ZeroAddress: string;
+//# sourceMappingURL=addresses.d.ts.map

hl_helper/node_modules/ethers/lib.esm/constants/addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.d.ts","sourceRoot":"","sources":["../../src.ts/constants/addresses.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,eAAO,MAAM,WAAW,EAAE,MAAqD,CAAC"}

hl_helper/node_modules/ethers/lib.esm/constants/addresses.js

@@ -0,0 +1,7 @@
+/**
+ *  A constant for the zero address.
+ *
+ *  (**i.e.** ``"0x0000000000000000000000000000000000000000"``)
+ */
+export const ZeroAddress = "0x0000000000000000000000000000000000000000";
+//# sourceMappingURL=addresses.js.map

hl_helper/node_modules/ethers/lib.esm/constants/addresses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"addresses.js","sourceRoot":"","sources":["../../src.ts/constants/addresses.ts"],"names":[],"mappings":"AACA;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAW,4CAA4C,CAAC"}

hl_helper/node_modules/ethers/lib.esm/constants/hashes.d.ts

@@ -0,0 +1,7 @@
+/**
+ *  A constant for the zero hash.
+ *
+ *  (**i.e.** ``"0x0000000000000000000000000000000000000000000000000000000000000000"``)
+ */
+export declare const ZeroHash: string;
+//# sourceMappingURL=hashes.d.ts.map

hl_helper/node_modules/ethers/lib.esm/constants/hashes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.d.ts","sourceRoot":"","sources":["../../src.ts/constants/hashes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAA6E,CAAC"}

hl_helper/node_modules/ethers/lib.esm/constants/hashes.js

@@ -0,0 +1,7 @@
+/**
+ *  A constant for the zero hash.
+ *
+ *  (**i.e.** ``"0x0000000000000000000000000000000000000000000000000000000000000000"``)
+ */
+export const ZeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
+//# sourceMappingURL=hashes.js.map

hl_helper/node_modules/ethers/lib.esm/constants/hashes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashes.js","sourceRoot":"","sources":["../../src.ts/constants/hashes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAW,oEAAoE,CAAC"}

hl_helper/node_modules/ethers/lib.esm/constants/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ *  Some common constants useful for Ethereum.
+ *
+ *  @_section: api/constants: Constants  [about-constants]
+ */
+export { ZeroAddress } from "./addresses.js";
+export { ZeroHash } from "./hashes.js";
+export { N, WeiPerEther, MaxUint256, MinInt256, MaxInt256 } from "./numbers.js";
+export { EtherSymbol, MessagePrefix } from "./strings.js";
+//# sourceMappingURL=index.d.ts.map

hl_helper/node_modules/ethers/lib.esm/constants/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src.ts/constants/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EACH,CAAC,EACD,WAAW,EACX,UAAU,EACV,SAAS,EACT,SAAS,EACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

hl_helper/node_modules/ethers/lib.esm/constants/index.js

@@ -0,0 +1,10 @@
+/**
+ *  Some common constants useful for Ethereum.
+ *
+ *  @_section: api/constants: Constants  [about-constants]
+ */
+export { ZeroAddress } from "./addresses.js";
+export { ZeroHash } from "./hashes.js";
+export { N, WeiPerEther, MaxUint256, MinInt256, MaxInt256 } from "./numbers.js";
+export { EtherSymbol, MessagePrefix } from "./strings.js";
+//# sourceMappingURL=index.js.map