@qevm/abi 5.7.1 → 5.7.3

package/src.ts/coders/array.ts

@@ -1,50 +1,64 @@
 "use strict";
 
-import { Logger } from "@ethersproject/logger";
+import { Logger } from "@qevm/logger";
 import { version } from "../_version";
 const logger = new Logger(version);
 
 import { Coder, Reader, Result, Writer } from "./abstract-coder";
 import { AnonymousCoder } from "./anonymous";
 
-export function pack(writer: Writer, coders: ReadonlyArray<Coder>, values: Array<any> | { [ name: string ]: any }): number {
+export function pack(
+    writer: Writer,
+    coders: ReadonlyArray<Coder>,
+    values: Array<any> | { [name: string]: any },
+): number {
     let arrayValues: Array<any> = null;
 
     if (Array.isArray(values)) {
-       arrayValues = values;
-
-    } else if (values && typeof(values) === "object") {
-        let unique: { [ name: string ]: boolean } = { };
+        arrayValues = values;
+    } else if (values && typeof values === "object") {
+        let unique: { [name: string]: boolean } = {};
 
         arrayValues = coders.map((coder) => {
             const name = coder.localName;
             if (!name) {
-                logger.throwError("cannot encode object for signature with missing names", Logger.errors.INVALID_ARGUMENT, {
-                    argument: "values",
-                    coder: coder,
-                    value: values
-                });
+                logger.throwError(
+                    "cannot encode object for signature with missing names",
+                    Logger.errors.INVALID_ARGUMENT,
+                    {
+                        argument: "values",
+                        coder: coder,
+                        value: values,
+                    },
+                );
             }
 
             if (unique[name]) {
-                logger.throwError("cannot encode object for signature with duplicate names", Logger.errors.INVALID_ARGUMENT, {
-                    argument: "values",
-                    coder: coder,
-                    value: values
-                });
+                logger.throwError(
+                    "cannot encode object for signature with duplicate names",
+                    Logger.errors.INVALID_ARGUMENT,
+                    {
+                        argument: "values",
+                        coder: coder,
+                        value: values,
+                    },
+                );
             }
 
             unique[name] = true;
 
             return values[name];
         });
-
     } else {
         logger.throwArgumentError("invalid tuple value", "tuple", values);
     }
 
     if (coders.length !== arrayValues.length) {
-        logger.throwArgumentError("types/value length mismatch", "tuple", values);
+        logger.throwArgumentError(
+            "types/value length mismatch",
+            "tuple",
+            values,
+        );
     }
 
     let staticWriter = new Writer(writer.wordSize);
@@ -66,14 +80,15 @@ export function pack(writer: Writer, coders: ReadonlyArray<Coder>, values: Array
             updateFuncs.push((baseOffset: number) => {
                 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); });
+    updateFuncs.forEach((func) => {
+        func(staticWriter.length);
+    });
 
     let length = writer.appendWriter(staticWriter);
     length += writer.appendWriter(dynamicWriter);
@@ -96,19 +111,22 @@ export function unpack(reader: Reader, coders: Array<Coder>): Result {
                 value = coder.decode(offsetReader);
             } catch (error) {
                 // Cannot recover from this
-                if (error.code === Logger.errors.BUFFER_OVERRUN) { throw error; }
+                if (error.code === Logger.errors.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 (error.code === Logger.errors.BUFFER_OVERRUN) { throw error; }
+                if (error.code === Logger.errors.BUFFER_OVERRUN) {
+                    throw error;
+                }
                 value = error;
                 value.baseType = coder.name;
                 value.name = coder.localName;
@@ -122,30 +140,43 @@ export function unpack(reader: Reader, coders: Array<Coder>): Result {
     });
 
     // We only output named properties for uniquely named coders
-    const uniqueNames = coders.reduce((accum, coder) => {
-        const name = coder.localName;
-        if (name) {
-            if (!accum[name]) { accum[name] = 0; }
-            accum[name]++;
-        }
-        return accum;
-    }, <{ [ name: string ]: number }>{ });
+    const uniqueNames = coders.reduce(
+        (accum, coder) => {
+            const name = coder.localName;
+            if (name) {
+                if (!accum[name]) {
+                    accum[name] = 0;
+                }
+                accum[name]++;
+            }
+            return accum;
+        },
+        <{ [name: string]: number }>{},
+    );
 
     // Add any named parameters (i.e. tuples)
     coders.forEach((coder: Coder, index: number) => {
         let name = coder.localName;
-        if (!name || uniqueNames[name] !== 1) { return; }
+        if (!name || uniqueNames[name] !== 1) {
+            return;
+        }
 
-        if (name === "length") { name = "_length"; }
+        if (name === "length") {
+            name = "_length";
+        }
 
-        if (values[name] != null) { return; }
+        if (values[name] != null) {
+            return;
+        }
 
         const value = values[index];
 
         if (value instanceof Error) {
             Object.defineProperty(values, name, {
                 enumerable: true,
-                get: () => { throw value; }
+                get: () => {
+                    throw value;
+                },
             });
         } else {
             values[name] = value;
@@ -157,7 +188,9 @@ export function unpack(reader: Reader, coders: Array<Coder>): Result {
         if (value instanceof Error) {
             Object.defineProperty(values, i, {
                 enumerable: true,
-                get: () => { throw value; }
+                get: () => {
+                    throw value;
+                },
             });
         }
     }
@@ -165,14 +198,13 @@ export function unpack(reader: Reader, coders: Array<Coder>): Result {
     return Object.freeze(values);
 }
 
-
 export class ArrayCoder extends Coder {
     readonly coder: Coder;
     readonly length: number;
 
     constructor(coder: Coder, length: number, localName: string) {
-        const type = (coder.type + "[" + (length >= 0 ? length: "") + "]");
-        const dynamic = (length === -1 || coder.dynamic);
+        const type = coder.type + "[" + (length >= 0 ? length : "") + "]";
+        const dynamic = length === -1 || coder.dynamic;
         super("array", type, localName, dynamic);
 
         this.coder = coder;
@@ -202,10 +234,16 @@ export class ArrayCoder extends Coder {
             writer.writeValue(value.length);
         }
 
-        logger.checkArgumentCount(value.length, count, "coder array" + (this.localName? (" "+ this.localName): ""));
+        logger.checkArgumentCount(
+            value.length,
+            count,
+            "coder array" + (this.localName ? " " + this.localName : ""),
+        );
 
         let coders = [];
-        for (let i = 0; i < value.length; i++) { coders.push(this.coder); }
+        for (let i = 0; i < value.length; i++) {
+            coders.push(this.coder);
+        }
 
         return pack(writer, coders, value);
     }
@@ -221,16 +259,21 @@ export class ArrayCoder extends Coder {
             // bytes as a link to the data). This could use a much
             // tighter bound, but we are erroring on the side of safety.
             if (count * 32 > reader._data.length) {
-                logger.throwError("insufficient data length", Logger.errors.BUFFER_OVERRUN, {
-                    length: reader._data.length,
-                    count: count
-                });
+                logger.throwError(
+                    "insufficient data length",
+                    Logger.errors.BUFFER_OVERRUN,
+                    {
+                        length: reader._data.length,
+                        count: count,
+                    },
+                );
             }
         }
         let coders = [];
-        for (let i = 0; i < count; i++) { coders.push(new AnonymousCoder(this.coder)); }
+        for (let i = 0; i < count; i++) {
+            coders.push(new AnonymousCoder(this.coder));
+        }
 
         return reader.coerce(this.name, unpack(reader, coders));
     }
 }
-

package/src.ts/coders/boolean.ts

@@ -3,7 +3,6 @@
 import { Coder, Reader, Writer } from "./abstract-coder";
 
 export class BooleanCoder extends Coder {
-
     constructor(localName: string) {
         super("bool", "bool", localName, false);
     }
@@ -13,11 +12,10 @@ export class BooleanCoder extends Coder {
     }
 
     encode(writer: Writer, value: boolean): number {
-        return writer.writeValue(value ? 1: 0);
+        return writer.writeValue(value ? 1 : 0);
     }
 
     decode(reader: Reader): any {
         return reader.coerce(this.type, !reader.readValue().isZero());
     }
 }
-

package/src.ts/coders/bytes.ts

@@ -6,7 +6,7 @@ import { Coder, Reader, Writer } from "./abstract-coder";
 
 export class DynamicBytesCoder extends Coder {
     constructor(type: string, localName: string) {
-       super(type, type, localName, true);
+        super(type, type, localName, true);
     }
 
     defaultValue(): string {
@@ -34,5 +34,3 @@ export class BytesCoder extends DynamicBytesCoder {
         return reader.coerce(this.name, hexlify(super.decode(reader)));
     }
 }
-
-

package/src.ts/coders/fixed-bytes.ts

@@ -15,12 +15,17 @@ export class FixedBytesCoder extends Coder {
     }
 
     defaultValue(): string {
-        return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
+        return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(
+            0,
+            2 + this.size * 2,
+        );
     }
 
     encode(writer: Writer, value: BytesLike): number {
         let data = arrayify(value);
-        if (data.length !== this.size) { this._throwError("incorrect data length", value); }
+        if (data.length !== this.size) {
+            this._throwError("incorrect data length", value);
+        }
         return writer.writeBytes(data);
     }
 

package/src.ts/coders/function.ts

@@ -0,0 +1,64 @@
+"use strict";
+
+import { hexZeroPad } from "@qevm/bytes";
+import { getAddress } from "@qevm/address";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class FunctionCoder extends Coder {
+    constructor(localName: string) {
+        // type "function" is NOT dynamic, occupies 64 bytes (2 words)
+        super("function", "function", localName, false);
+    }
+
+    defaultValue(): string {
+        // 32-byte zero address + 4-byte zero selector = 72 hex chars
+        return "0x" + "00".repeat(32) + "00000000";
+    }
+
+    encode(writer: Writer, value: string): number {
+        // Expected format: "0x" + 64 hex (address) + 8 hex (selector)
+        // Total: 74 chars including "0x"
+        let hex = value;
+        if (hex.startsWith("0x")) {
+            hex = hex.substring(2);
+        }
+
+        if (hex.length !== 72) {
+            this._throwError(
+                "invalid function value (expected 72 hex chars after 0x)",
+                value,
+            );
+        }
+
+        const addressHex = "0x" + hex.substring(0, 64);
+        const selectorHex = "0x" + hex.substring(64, 72);
+
+        // Validate address
+        getAddress(addressHex);
+
+        // Word 0: full 32-byte address (right-aligned = as uint256)
+        writer.writeValue(addressHex);
+
+        // Word 1: 4-byte selector right-aligned in 32-byte word
+        writer.writeValue(selectorHex);
+
+        return writer.length;
+    }
+
+    decode(reader: Reader): any {
+        // Read 2 words (64 bytes)
+        const addressValue = reader.readValue(); // word 0: address
+        const selectorValue = reader.readValue(); // word 1: selector (masked to 4 bytes)
+
+        const addressHex = hexZeroPad(addressValue.toHexString(), 32).substring(
+            2,
+        ); // 64 hex chars
+        const selectorHex = hexZeroPad(
+            selectorValue.mask(32).toHexString(),
+            4,
+        ).substring(2); // 8 hex chars
+
+        return reader.coerce(this.name, "0x" + addressHex + selectorHex);
+    }
+}

package/src.ts/coders/null.ts

@@ -3,7 +3,6 @@
 import { Coder, Reader, Writer } from "./abstract-coder";
 
 export class NullCoder extends Coder {
-
     constructor(localName: string) {
         super("null", "", localName, false);
     }
@@ -13,8 +12,10 @@ export class NullCoder extends Coder {
     }
 
     encode(writer: Writer, value: any): number {
-        if (value != null) { this._throwError("not null", value); }
-        return writer.writeBytes([ ]);
+        if (value != null) {
+            this._throwError("not null", value);
+        }
+        return writer.writeBytes([]);
     }
 
     decode(reader: Reader): any {

package/src.ts/coders/number.ts

@@ -10,7 +10,7 @@ export class NumberCoder extends Coder {
     readonly signed: boolean;
 
     constructor(size: number, signed: boolean, localName: string) {
-        const name = ((signed ? "int": "uint") + (size * 8));
+        const name = (signed ? "int" : "uint") + size * 8;
         super(name, name, localName, false);
 
         this.size = size;
@@ -54,4 +54,3 @@ export class NumberCoder extends Coder {
         return reader.coerce(this.name, value);
     }
 }
-

package/src.ts/coders/string.ts

@@ -1,12 +1,11 @@
 "use strict";
 
-import { toUtf8Bytes, toUtf8String } from "@ethersproject/strings";
+import { toUtf8Bytes, toUtf8String } from "@qevm/strings";
 
 import { Reader, Writer } from "./abstract-coder";
 import { DynamicBytesCoder } from "./bytes";
 
 export class StringCoder extends DynamicBytesCoder {
-
     constructor(localName: string) {
         super("string", localName);
     }

package/src.ts/coders/tuple.ts

@@ -10,39 +10,52 @@ export class TupleCoder extends Coder {
         let dynamic = false;
         const types: Array<string> = [];
         coders.forEach((coder) => {
-            if (coder.dynamic) { dynamic = true; }
+            if (coder.dynamic) {
+                dynamic = true;
+            }
             types.push(coder.type);
         });
-        const type = ("tuple(" + types.join(",") + ")");
+        const type = "tuple(" + types.join(",") + ")";
 
         super("tuple", type, localName, dynamic);
         this.coders = coders;
     }
 
     defaultValue(): any {
-        const values: any = [ ];
+        const values: any = [];
         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;
-        }, <{ [ name: string ]: number }>{ });
+        const uniqueNames = this.coders.reduce(
+            (accum, coder) => {
+                const name = coder.localName;
+                if (name) {
+                    if (!accum[name]) {
+                        accum[name] = 0;
+                    }
+                    accum[name]++;
+                }
+                return accum;
+            },
+            <{ [name: string]: number }>{},
+        );
 
         // Add named values
         this.coders.forEach((coder: Coder, index: number) => {
             let name = coder.localName;
-            if (!name || uniqueNames[name] !== 1) { return; }
+            if (!name || uniqueNames[name] !== 1) {
+                return;
+            }
 
-            if (name === "length") { name = "_length"; }
+            if (name === "length") {
+                name = "_length";
+            }
 
-            if (values[name] != null) { return; }
+            if (values[name] != null) {
+                return;
+            }
 
             values[name] = values[index];
         });
@@ -50,7 +63,10 @@ export class TupleCoder extends Coder {
         return Object.freeze(values);
     }
 
-    encode(writer: Writer, value: Array<any> | { [ name: string ]: any }): number {
+    encode(
+        writer: Writer,
+        value: Array<any> | { [name: string]: any },
+    ): number {
         return pack(writer, this.coders, value);
     }
 
@@ -58,4 +74,3 @@ export class TupleCoder extends Coder {
         return reader.coerce(this.name, unpack(reader, this.coders));
     }
 }
-