refactor: move brother_node development artifact to dev/test-nodes subdirectory

Development Artifact Cleanup:
✅ BROTHER_NODE REORGANIZATION: Moved development test node to appropriate location
- dev/test-nodes/brother_node/: Moved from root directory for better organization
- Contains development configuration, test logs, and test chain data
- No impact on production systems - purely development/testing artifact

✅ DEVELOPMENT ARTIFACTS IDENTIFIED:
- Chain ID: aitbc-brother-chain (test/development chain)
- Ports: 8010 (P2P) and 8011 (RPC) - different from production
- Environment: .env file with test configuration
- Logs: rpc.log and node.log from development testing session (March 15, 2026)

✅ ROOT DIRECTORY CLEANUP: Removed development clutter from production directory
- brother_node/ moved to dev/test-nodes/brother_node/
- Root directory now contains only production-ready components
- Development artifacts properly organized in dev/ subdirectory

DIRECTORY STRUCTURE IMPROVEMENT:
📁 dev/test-nodes/: Development and testing node configurations
🏗️ Root Directory: Clean production structure with only essential components
🧪 Development Isolation: Test environments separated from production

BENEFITS:
✅ Clean Production Directory: No development artifacts in root
✅ Better Organization: Development nodes grouped in dev/ subdirectory
✅ Clear Separation: Production vs development environments clearly distinguished
✅ Maintainability: Easier to identify and manage development components

RESULT: Successfully moved brother_node development artifact to dev/test-nodes/ subdirectory, cleaning up the root directory while preserving development testing environment for future use.

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}

dev/env/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

dev/env/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"}