@qevm/abi 5.7.1

package/src.ts/coders/bytes.ts

@@ -0,0 +1,38 @@
+"use strict";
+
+import { arrayify, hexlify } from "@qevm/bytes";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class DynamicBytesCoder extends Coder {
+    constructor(type: string, localName: string) {
+       super(type, type, localName, true);
+    }
+
+    defaultValue(): string {
+        return "0x";
+    }
+
+    encode(writer: Writer, value: any): number {
+        value = arrayify(value);
+        let length = writer.writeValue(value.length);
+        length += writer.writeBytes(value);
+        return length;
+    }
+
+    decode(reader: Reader): any {
+        return reader.readBytes(reader.readValue().toNumber(), true);
+    }
+}
+
+export class BytesCoder extends DynamicBytesCoder {
+    constructor(localName: string) {
+        super("bytes", localName);
+    }
+
+    decode(reader: Reader): any {
+        return reader.coerce(this.name, hexlify(super.decode(reader)));
+    }
+}
+
+

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

@@ -0,0 +1,30 @@
+"use strict";
+
+import { arrayify, BytesLike, hexlify } from "@qevm/bytes";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+// @TODO: Merge this with bytes
+export class FixedBytesCoder extends Coder {
+    readonly size: number;
+
+    constructor(size: number, localName: string) {
+        let name = "bytes" + String(size);
+        super(name, name, localName, false);
+        this.size = size;
+    }
+
+    defaultValue(): string {
+        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); }
+        return writer.writeBytes(data);
+    }
+
+    decode(reader: Reader): any {
+        return reader.coerce(this.name, hexlify(reader.readBytes(this.size)));
+    }
+}

package/src.ts/coders/null.ts

@@ -0,0 +1,24 @@
+"use strict";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class NullCoder extends Coder {
+
+    constructor(localName: string) {
+        super("null", "", localName, false);
+    }
+
+    defaultValue(): null {
+        return null;
+    }
+
+    encode(writer: Writer, value: any): number {
+        if (value != null) { this._throwError("not null", value); }
+        return writer.writeBytes([ ]);
+    }
+
+    decode(reader: Reader): any {
+        reader.readBytes(0);
+        return reader.coerce(this.name, null);
+    }
+}

package/src.ts/coders/number.ts

@@ -0,0 +1,57 @@
+"use strict";
+
+import { BigNumber, BigNumberish } from "@qevm/bignumber";
+import { MaxUint256, NegativeOne, One, Zero } from "@qevm/constants";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+
+export class NumberCoder extends Coder {
+    readonly size: number;
+    readonly signed: boolean;
+
+    constructor(size: number, signed: boolean, localName: string) {
+        const name = ((signed ? "int": "uint") + (size * 8));
+        super(name, name, localName, false);
+
+        this.size = size;
+        this.signed = signed;
+    }
+
+    defaultValue(): number {
+        return 0;
+    }
+
+    encode(writer: Writer, value: BigNumberish): number {
+        let v = BigNumber.from(value);
+
+        // Check bounds are safe for encoding
+        let maxUintValue = MaxUint256.mask(writer.wordSize * 8);
+        if (this.signed) {
+            let bounds = maxUintValue.mask(this.size * 8 - 1);
+            if (v.gt(bounds) || v.lt(bounds.add(One).mul(NegativeOne))) {
+                this._throwError("value out-of-bounds", value);
+            }
+        } else if (v.lt(Zero) || v.gt(maxUintValue.mask(this.size * 8))) {
+            this._throwError("value out-of-bounds", value);
+        }
+
+        v = v.toTwos(this.size * 8).mask(this.size * 8);
+
+        if (this.signed) {
+            v = v.fromTwos(this.size * 8).toTwos(8 * writer.wordSize);
+        }
+
+        return writer.writeValue(v);
+    }
+
+    decode(reader: Reader): any {
+        let value = reader.readValue().mask(this.size * 8);
+
+        if (this.signed) {
+            value = value.fromTwos(this.size * 8);
+        }
+
+        return reader.coerce(this.name, value);
+    }
+}
+

package/src.ts/coders/string.ts

@@ -0,0 +1,25 @@
+"use strict";
+
+import { toUtf8Bytes, toUtf8String } from "@ethersproject/strings";
+
+import { Reader, Writer } from "./abstract-coder";
+import { DynamicBytesCoder } from "./bytes";
+
+export class StringCoder extends DynamicBytesCoder {
+
+    constructor(localName: string) {
+        super("string", localName);
+    }
+
+    defaultValue(): string {
+        return "";
+    }
+
+    encode(writer: Writer, value: any): number {
+        return super.encode(writer, toUtf8Bytes(value));
+    }
+
+    decode(reader: Reader): any {
+        return toUtf8String(super.decode(reader));
+    }
+}

package/src.ts/coders/tuple.ts

@@ -0,0 +1,61 @@
+"use strict";
+
+import { Coder, Reader, Writer } from "./abstract-coder";
+import { pack, unpack } from "./array";
+
+export class TupleCoder extends Coder {
+    readonly coders: Array<Coder>;
+
+    constructor(coders: Array<Coder>, localName: string) {
+        let dynamic = false;
+        const types: Array<string> = [];
+        coders.forEach((coder) => {
+            if (coder.dynamic) { dynamic = true; }
+            types.push(coder.type);
+        });
+        const type = ("tuple(" + types.join(",") + ")");
+
+        super("tuple", type, localName, dynamic);
+        this.coders = coders;
+    }
+
+    defaultValue(): 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 }>{ });
+
+        // Add named values
+        this.coders.forEach((coder: Coder, index: number) => {
+            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: Writer, value: Array<any> | { [ name: string ]: any }): number {
+        return pack(writer, this.coders, value);
+    }
+
+    decode(reader: Reader): any {
+        return reader.coerce(this.name, unpack(reader, this.coders));
+    }
+}
+