quantumcoin 6.14.5 → 7.0.2

package/src.ts/abi/coders/array.ts

@@ -1,199 +0,0 @@
-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";
-
-import type { Reader } from "./abstract-coder.js";
-
-/**
- *  @_ignore
- */
-export function pack(writer: Writer, coders: ReadonlyArray<Coder>, values: Array<any> | { [ name: string ]: any }): number {
-    let arrayValues: Array<any> = [ ];
-
-    if (Array.isArray(values)) {
-       arrayValues = values;
-
-    } else if (values && typeof(values) === "object") {
-        let unique: { [ name: string ]: boolean } = { };
-
-        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: Array<(baseOffset: number) => void> = [];
-    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: 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); });
-
-    let length = writer.appendWriter(staticWriter);
-    length += writer.appendWriter(dynamicWriter);
-    return length;
-}
-
-/**
- *  @_ignore
- */
-export function unpack(reader: Reader, coders: ReadonlyArray<Coder>): Result {
-    let values: Array<any> = [];
-    let keys: Array<null | string> = [ ];
-
-    // A reader anchored to this base
-    let baseReader = reader.subReader(0);
-
-    coders.forEach((coder) => {
-        let value: any = null;
-
-        if (coder.dynamic) {
-            let offset = reader.readIndex();
-            let offsetReader = baseReader.subReader(offset);
-            try {
-                value = coder.decode(offsetReader);
-            } catch (error: any) {
-                // 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: any) {
-                // 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 {
-    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);
-        super("array", type, localName, dynamic);
-        defineProperties<ArrayCoder>(this, { coder, length });
-    }
-
-    defaultValue(): Array<any> {
-        // Verifies the child coder is valid (even if the array is dynamic or 0-length)
-        const defaultChild = this.coder.defaultValue();
-
-        const result: Array<any> = [];
-        for (let i = 0; i < this.length; i++) {
-            result.push(defaultChild);
-        }
-        return result;
-    }
-
-    encode(writer: Writer, _value: Array<any> | Typed): number {
-        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: Array<Coder> = [ ];
-        for (let i = 0; i < value.length; i++) { coders.push(this.coder); }
-
-        return pack(writer, coders, value);
-    }
-
-    decode(reader: Reader): any {
-        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: Array<Coder> = [];
-        for (let i = 0; i < count; i++) { coders.push(new AnonymousCoder(this.coder)); }
-
-        return unpack(reader, coders);
-    }
-}
-

package/src.ts/abi/coders/boolean.ts

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

package/src.ts/abi/coders/bytes.ts

@@ -1,43 +0,0 @@
-import { getBytesCopy, hexlify } from "../../utils/index.js";
-
-import { Coder } from "./abstract-coder.js";
-
-import type { Reader, Writer } from "./abstract-coder.js";
-
-
-/**
- *  @_ignore
- */
-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 = getBytesCopy(value);
-        let length = writer.writeValue(value.length);
-        length += writer.writeBytes(value);
-        return length;
-    }
-
-    decode(reader: Reader): any {
-        return reader.readBytes(reader.readIndex(), true);
-    }
-}
-
-/**
- *  @_ignore
- */
-export class BytesCoder extends DynamicBytesCoder {
-    constructor(localName: string) {
-        super("bytes", localName);
-    }
-
-    decode(reader: Reader): any {
-        return hexlify(super.decode(reader));
-    }
-}

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

@@ -1,37 +0,0 @@
-
-import { defineProperties, getBytesCopy, hexlify } from "../../utils/index.js";
-
-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 class FixedBytesCoder extends Coder {
-    readonly size!: number;
-
-    constructor(size: number, localName: string) {
-        let name = "bytes" + String(size);
-        super(name, name, localName, false);
-        defineProperties<FixedBytesCoder>(this, { size }, { size: "number" });
-    }
-
-    defaultValue(): string {
-        return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2);
-    }
-
-    encode(writer: Writer, _value: BytesLike | Typed): number {
-        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: Reader): any {
-        return hexlify(reader.readBytes(this.size));
-    }
-}

package/src.ts/abi/coders/null.ts

@@ -1,28 +0,0 @@
-import { Coder } from "./abstract-coder.js";
-import type { Reader, Writer } from "./abstract-coder.js";
-
-const Empty = new Uint8Array([ ]);
-
-/**
- *  @_ignore
- */
-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(Empty);
-    }
-
-    decode(reader: Reader): any {
-        reader.readBytes(0);
-        return null;
-    }
-}

package/src.ts/abi/coders/number.ts

@@ -1,63 +0,0 @@
-import {
-    defineProperties, fromTwos, getBigInt, mask, toTwos
-} from "../../utils/index.js";
-
-import { Typed } from "../typed.js";
-import { Coder, WordSize } from "./abstract-coder.js";
-
-import type { BigNumberish } from "../../utils/index.js";
-
-import type { Reader, Writer } 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 {
-    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);
-
-        defineProperties<NumberCoder>(this, { size, signed }, { size: "number", signed: "boolean" });
-    }
-
-    defaultValue(): number {
-        return 0;
-    }
-
-    encode(writer: Writer, _value: BigNumberish | Typed): number {
-        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: Reader): any {
-        let value = mask(reader.readValue(), this.size * 8);
-
-        if (this.signed) {
-            value = fromTwos(value, this.size * 8);
-        }
-
-        return value;
-    }
-}
-

package/src.ts/abi/coders/string.ts

@@ -1,29 +0,0 @@
-import { toUtf8Bytes, toUtf8String } from "../../utils/utf8.js";
-
-import { Typed } from "../typed.js";
-import { DynamicBytesCoder } from "./bytes.js";
-
-import type { Reader, Writer } from "./abstract-coder.js";
-
-
-/**
- *  @_ignore
- */
-export class StringCoder extends DynamicBytesCoder {
-
-    constructor(localName: string) {
-        super("string", localName);
-    }
-
-    defaultValue(): string {
-        return "";
-    }
-
-    encode(writer: Writer, _value: string | Typed): number {
-        return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string")));
-    }
-
-    decode(reader: Reader): any {
-        return toUtf8String(super.decode(reader));
-    }
-}

package/src.ts/abi/coders/tuple.ts

@@ -1,69 +0,0 @@
-import { defineProperties } from "../../utils/properties.js";
-
-import { Typed } from "../typed.js";
-import { Coder } from "./abstract-coder.js";
-
-import { pack, unpack } from "./array.js";
-
-import type { Reader, Writer } from "./abstract-coder.js";
-
-/**
- *  @_ignore
- */
-export class TupleCoder extends Coder {
-    readonly coders!: ReadonlyArray<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);
-        defineProperties<TupleCoder>(this, { coders: Object.freeze(coders.slice()) });
-    }
-
-    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 } | Typed): number {
-        const value = Typed.dereference(_value, "tuple");
-        return pack(writer, this.coders, value);
-    }
-
-    decode(reader: Reader): any {
-        return unpack(reader, this.coders);
-    }
-}
-