phantasma-sdk-ts 0.1.71

package/core/types/Extensions/PBinaryReader.js

@@ -0,0 +1,269 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBinaryReader = void 0;
+var big_integer_1 = __importDefault(require("big-integer"));
+var csharp_binary_stream_1 = require("csharp-binary-stream");
+var interfaces_1 = require("../../interfaces");
+var utils_1 = require("../../utils");
+var vm_1 = require("../../vm");
+var Ed25519Signature_1 = require("../Ed25519Signature");
+var Timestamp_1 = require("../Timestamp");
+var PBinaryReader = /** @class */ (function () {
+    function PBinaryReader(arg1) {
+        this.reader = new csharp_binary_stream_1.BinaryReader(arg1);
+    }
+    Object.defineProperty(PBinaryReader.prototype, "length", {
+        get: function () {
+            return this.reader.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PBinaryReader.prototype, "position", {
+        get: function () {
+            return this.reader.position;
+        },
+        set: function (value) {
+            this.reader.position = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PBinaryReader.prototype, "isEndOfStream", {
+        get: function () {
+            return this.reader.isEndOfStream;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PBinaryReader.prototype.readBoolean = function () {
+        return this.reader.readBoolean();
+    };
+    PBinaryReader.prototype.readByte = function () {
+        return this.reader.readByte();
+    };
+    PBinaryReader.prototype.readBytes = function (bytesToRead) {
+        return this.reader.readBytes(bytesToRead);
+    };
+    PBinaryReader.prototype.readSignedByte = function () {
+        return this.reader.readSignedByte();
+    };
+    PBinaryReader.prototype.readShort = function () {
+        return this.reader.readShort();
+    };
+    PBinaryReader.prototype.readUnsignedShort = function () {
+        return this.reader.readUnsignedShort();
+    };
+    PBinaryReader.prototype.readInt = function () {
+        return this.reader.readInt();
+    };
+    PBinaryReader.prototype.readUnsignedInt = function () {
+        return this.reader.readUnsignedInt();
+    };
+    PBinaryReader.prototype.readLongString = function () {
+        return this.reader.readLongString();
+    };
+    PBinaryReader.prototype.readLong = function () {
+        return this.reader.readLong();
+    };
+    PBinaryReader.prototype.readUnsignedLongString = function () {
+        return this.reader.readUnsignedLongString();
+    };
+    PBinaryReader.prototype.readUnsignedLong = function () {
+        return this.reader.readUnsignedLong();
+    };
+    PBinaryReader.prototype.readFloat = function () {
+        return this.reader.readFloat();
+    };
+    PBinaryReader.prototype.readDouble = function () {
+        return this.reader.readDouble();
+    };
+    PBinaryReader.prototype.readChar = function (encoding) {
+        return this.reader.readChar(encoding);
+    };
+    PBinaryReader.prototype.readChars = function (charactersToRead, encoding) {
+        return this.reader.readChars(charactersToRead, encoding);
+    };
+    PBinaryReader.prototype.readCharBytes = function (bytesToRead, encoding) {
+        return this.reader.readCharBytes(bytesToRead, encoding);
+    };
+    PBinaryReader.prototype.read = function (numBytes) {
+        var res = (0, utils_1.byteArrayToHex)(this.readBytes(numBytes)).substr(0, numBytes * 2);
+        //this.position += numBytes;
+        return res;
+    };
+    PBinaryReader.prototype.readString = function () {
+        var len = this.readVarInt();
+        return this.readStringBytes(len);
+    };
+    PBinaryReader.prototype.readStringBytes = function (numBytes) {
+        var res = "";
+        for (var i = 0; i < numBytes; ++i) {
+            res += String.fromCharCode(this.readByte());
+        }
+        return res;
+    };
+    PBinaryReader.prototype.readBigInteger = function () {
+        // TO DO: implement negative numbers
+        var len = this.readVarInt();
+        var res = 0;
+        var stringBytes = this.read(len);
+        __spreadArray([], __read(stringBytes.match(/.{1,2}/g)), false).reverse()
+            .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+        var bigInt = BigInt(res);
+        return bigInt;
+    };
+    PBinaryReader.prototype.readBigIntAccurate = function () {
+        var len = this.readVarInt();
+        var res = (0, big_integer_1.default)();
+        var stringBytes = this.read(len);
+        __spreadArray([], __read(stringBytes.match(/.{1,2}/g)), false).reverse().forEach(function (c) {
+            res = res.times(256).plus(parseInt(c, 16));
+        });
+        return res.toString();
+    };
+    PBinaryReader.prototype.readSignatureV2 = function () {
+        var kind = this.readByte();
+        var curve;
+        var signature = new Ed25519Signature_1.Ed25519Signature();
+        switch (kind) {
+            case interfaces_1.SignatureKind.None:
+                return null;
+            case interfaces_1.SignatureKind.Ed25519:
+                var len = this.readVarInt();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.read(len));
+                break;
+            case interfaces_1.SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.readString());
+                break;
+            default:
+                throw "read signature: " + kind;
+        }
+        return signature;
+    };
+    PBinaryReader.prototype.readSignature = function () {
+        var kind = this.readByte();
+        var signature = new Ed25519Signature_1.Ed25519Signature();
+        var curve;
+        signature.Kind = kind;
+        switch (kind) {
+            case interfaces_1.SignatureKind.None:
+                return null;
+            case interfaces_1.SignatureKind.Ed25519:
+                var len = this.readVarInt();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.read(len));
+                break;
+            case interfaces_1.SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.Bytes = (0, utils_1.stringToUint8Array)(this.readString());
+                break;
+            default:
+                throw "read signature: " + kind;
+        }
+        return signature;
+    };
+    PBinaryReader.prototype.readByteArray = function () {
+        var res;
+        var length = this.readVarInt();
+        if (length == 0)
+            return [];
+        res = this.read(length);
+        return res;
+    };
+    PBinaryReader.prototype.readTimestamp = function () {
+        //var len = this.readByte();
+        var result = 0;
+        var bytes = this.read(4);
+        //[...(bytes.match(/.{1,2}/g) as any)];
+        bytes
+            .match(/.{1,2}/g)
+            .reverse()
+            .forEach(function (c) { return (result = result * 256 + parseInt(c, 16)); });
+        var timestamp = new Timestamp_1.Timestamp(result);
+        return timestamp;
+    };
+    PBinaryReader.prototype.readVarInt = function () {
+        var len = this.readByte();
+        var res = 0;
+        if (len === 0xfd) {
+            __spreadArray([], __read(this.read(2).match(/.{1,2}/g)), false).reverse()
+                .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+            return res;
+        }
+        else if (len === 0xfe) {
+            __spreadArray([], __read(this.read(4).match(/.{1,2}/g)), false).reverse()
+                .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+            return res;
+        }
+        else if (len === 0xff) {
+            __spreadArray([], __read(this.read(8).match(/.{1,2}/g)), false).reverse()
+                .forEach(function (c) { return (res = res * 256 + parseInt(c, 16)); });
+            return res;
+        }
+        return len;
+    };
+    PBinaryReader.prototype.readVarString = function () {
+        var len = this.readVarInt();
+        if (len == 0)
+            return "";
+        return this.readStringBytes(len);
+    };
+    PBinaryReader.prototype.readVmObject = function () {
+        var type = this.readByte();
+        switch (type) {
+            case vm_1.VMType.String:
+                return this.readString();
+            case vm_1.VMType.Number:
+                return this.readBigIntAccurate();
+            case vm_1.VMType.Bool:
+                return this.readByte() != 0;
+            case vm_1.VMType.Struct:
+                var numFields = this.readVarInt();
+                var res = {};
+                for (var i = 0; i < numFields; ++i) {
+                    var key = this.readVmObject();
+                    var value = this.readVmObject();
+                    res[key] = value;
+                }
+                return res;
+            case vm_1.VMType.Enum:
+                return this.readVarInt();
+            case vm_1.VMType.Object:
+                var numBytes = this.readVarInt();
+                return this.read(numBytes);
+            default:
+                return "unsupported type " + type;
+        }
+    };
+    return PBinaryReader;
+}());
+exports.PBinaryReader = PBinaryReader;

package/core/types/Extensions/PBinaryWriter.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { Encoding } from "csharp-binary-stream";
+import { Signature } from "../../interfaces";
+import { Timestamp } from "../Timestamp";
+type byte = number;
+export declare class PBinaryWriter {
+    private writer;
+    _buffer: Buffer;
+    _position: number;
+    _length: number;
+    constructor(arg1?: undefined | Buffer | Uint8Array | null);
+    get length(): number;
+    get position(): number;
+    set position(value: number);
+    writeBoolean(value: boolean): void;
+    writeByte(value: number): void;
+    writeSameByte(value: number, repeats: number): void;
+    writeSignedByte(value: number): void;
+    writeShort(value: number): void;
+    writeUnsignedShort(value: number): void;
+    writeInt(value: number): void;
+    writeUnsignedInt(value: number): void;
+    writeLong(value: string | number): void;
+    writeUnsignedLong(value: string | number): void;
+    writeFloat(value: number): void;
+    writeDouble(value: number): void;
+    writeChar(character: string | number, encoding: Encoding): void;
+    writeChars(characters: string | number[], encoding: Encoding): void;
+    clear(): void;
+    toArray(): number[];
+    toUint8Array(): Uint8Array;
+    appendByte(value: number): this;
+    appendBytes(bytes: byte[]): void;
+    writeEnum(value: number): this;
+    writeBytes(bytes: byte[]): this;
+    writeVarInt(value: number): this;
+    writeTimestamp(obj: Timestamp): this;
+    writeDateTime(obj: Date): this;
+    rawString(value: string): number[];
+    writeByteArray(bytes: number[] | Uint8Array): this;
+    writeString(text: string): this;
+    emitUInt32(value: number): this;
+    writeBigInteger(value: BigInt): this;
+    writeBigIntegerString(value: string): this;
+    writeSignature(signature: Signature): this;
+    AppendHexEncoded(bytes: string): this;
+}
+export {};
+//# sourceMappingURL=PBinaryWriter.d.ts.map

package/core/types/Extensions/PBinaryWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PBinaryWriter.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/PBinaryWriter.ts"],"names":[],"mappings":";AAEA,OAAO,EAAgB,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAO9D,OAAO,EAAc,SAAS,EAAiB,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,KAAK,IAAI,GAAG,MAAM,CAAC;AAEnB,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;gBACJ,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI;IAIzD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEzB;IAED,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIlC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG9B,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAGnD,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGpC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG/B,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGvC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG7B,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGrC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAGvC,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAG/C,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAG/B,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAGhC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAG/D,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAGnE,KAAK,IAAI,IAAI;IAGb,OAAO,IAAI,MAAM,EAAE;IAGnB,YAAY,IAAI,UAAU;IAInB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK/B,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE;IAQzB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAarC,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAOxB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAuChC,cAAc,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI;IAapC,aAAa,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI;IAarC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAQ3B,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU;IAS3C,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAO/B,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAkB/B,eAAe,CAAC,KAAK,EAAE,MAAM;IAI7B,qBAAqB,CAAC,KAAK,EAAE,MAAM;IAuBnC,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAU1C,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAY7C"}

package/core/types/Extensions/PBinaryWriter.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBinaryWriter = void 0;
+var csharp_binary_stream_1 = require("csharp-binary-stream");
+var __1 = require("../..");
+var interfaces_1 = require("../../interfaces");
+var PBinaryWriter = /** @class */ (function () {
+    function PBinaryWriter(arg1) {
+        this.writer = new csharp_binary_stream_1.BinaryWriter(arg1);
+    }
+    Object.defineProperty(PBinaryWriter.prototype, "length", {
+        get: function () {
+            return this.writer.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PBinaryWriter.prototype, "position", {
+        get: function () {
+            return this.writer.position;
+        },
+        set: function (value) {
+            this.writer.position = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PBinaryWriter.prototype.writeBoolean = function (value) {
+        this.writer.writeBoolean(value);
+    };
+    PBinaryWriter.prototype.writeByte = function (value) {
+        this.writer.writeByte(value);
+    };
+    PBinaryWriter.prototype.writeSameByte = function (value, repeats) {
+        this.writer.writeSameByte(value, repeats);
+    };
+    PBinaryWriter.prototype.writeSignedByte = function (value) {
+        this.writer.writeSignedByte(value);
+    };
+    PBinaryWriter.prototype.writeShort = function (value) {
+        this.writer.writeShort(value);
+    };
+    PBinaryWriter.prototype.writeUnsignedShort = function (value) {
+        this.writer.writeUnsignedShort(value);
+    };
+    PBinaryWriter.prototype.writeInt = function (value) {
+        this.writer.writeInt(value);
+    };
+    PBinaryWriter.prototype.writeUnsignedInt = function (value) {
+        this.writer.writeUnsignedInt(value);
+    };
+    PBinaryWriter.prototype.writeLong = function (value) {
+        this.writer.writeLong(value);
+    };
+    PBinaryWriter.prototype.writeUnsignedLong = function (value) {
+        this.writer.writeUnsignedLong(value);
+    };
+    PBinaryWriter.prototype.writeFloat = function (value) {
+        this.writer.writeFloat(value);
+    };
+    PBinaryWriter.prototype.writeDouble = function (value) {
+        this.writer.writeDouble(value);
+    };
+    PBinaryWriter.prototype.writeChar = function (character, encoding) {
+        this.writer.writeChar(character, encoding);
+    };
+    PBinaryWriter.prototype.writeChars = function (characters, encoding) {
+        this.writer.writeChars(characters, encoding);
+    };
+    PBinaryWriter.prototype.clear = function () {
+        this.writer.clear();
+    };
+    PBinaryWriter.prototype.toArray = function () {
+        return this.writer.toArray();
+    };
+    PBinaryWriter.prototype.toUint8Array = function () {
+        return this.writer.toUint8Array();
+    };
+    PBinaryWriter.prototype.appendByte = function (value) {
+        this.writeByte(value);
+        return this;
+    };
+    PBinaryWriter.prototype.appendBytes = function (bytes) {
+        for (var i = 0; i < bytes.length; i++) {
+            if (!Number.isNaN(bytes[i])) {
+                this.appendByte(bytes[i]);
+            }
+        }
+    };
+    PBinaryWriter.prototype.writeEnum = function (value) {
+        //this.writeUnsignedInt(value);
+        var bytes = [0, 0, 0, 0];
+        for (var i = 0; i < bytes.length; i++) {
+            var byte = value & 0xff;
+            bytes[i] = byte;
+            value = (value - byte) / 256;
+        }
+        this.appendBytes(bytes);
+        return this;
+    };
+    PBinaryWriter.prototype.writeBytes = function (bytes) {
+        for (var i = 0; i < bytes.length; i++)
+            this.appendByte(bytes[i]);
+        // writer.Write(bytes);
+        return this;
+    };
+    PBinaryWriter.prototype.writeVarInt = function (value) {
+        if (value < 0)
+            throw "negative value invalid";
+        if (value < 0xfd) {
+            this.appendByte(value);
+        }
+        else if (value <= 0xffff) {
+            var B = (value & 0x0000ff00) >> 8;
+            var A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.appendByte(0xfd);
+            this.appendByte(A);
+            this.appendByte(B);
+        }
+        else if (value <= 0xffffffff) {
+            var C = (value & 0x00ff0000) >> 16;
+            var B = (value & 0x0000ff00) >> 8;
+            var A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.appendByte(0xfe);
+            this.appendByte(A);
+            this.appendByte(B);
+            this.appendByte(C);
+        }
+        else {
+            var D = (value & 0xff000000) >> 24;
+            var C = (value & 0x00ff0000) >> 16;
+            var B = (value & 0x0000ff00) >> 8;
+            var A = value & 0x000000ff;
+            // TODO check if the endianess is correct, might have to reverse order of appends
+            this.appendByte(0xff);
+            this.appendByte(A);
+            this.appendByte(B);
+            this.appendByte(C);
+            this.appendByte(D);
+        }
+        return this;
+    };
+    PBinaryWriter.prototype.writeTimestamp = function (obj) {
+        var num = obj.value;
+        var a = (num & 0xff000000) >> 24;
+        var b = (num & 0x00ff0000) >> 16;
+        var c = (num & 0x0000ff00) >> 8;
+        var d = num & 0x000000ff;
+        var bytes = [d, c, b, a];
+        this.appendBytes(bytes);
+        return this;
+    };
+    PBinaryWriter.prototype.writeDateTime = function (obj) {
+        var num = (obj.getTime() / 1000) | 0;
+        var a = (num & 0xff000000) >> 24;
+        var b = (num & 0x00ff0000) >> 16;
+        var c = (num & 0x0000ff00) >> 8;
+        var d = num & 0x000000ff;
+        var bytes = [d, c, b, a];
+        this.appendBytes(bytes);
+        return this;
+    };
+    PBinaryWriter.prototype.rawString = function (value) {
+        var data = [];
+        for (var i = 0; i < value.length; i++) {
+            data.push(value.charCodeAt(i));
+        }
+        return data;
+    };
+    PBinaryWriter.prototype.writeByteArray = function (bytes) {
+        if (bytes instanceof Uint8Array) {
+            bytes = Array.from(bytes);
+        }
+        this.writeVarInt(bytes.length);
+        this.writeBytes(bytes);
+        return this;
+    };
+    PBinaryWriter.prototype.writeString = function (text) {
+        var bytes = this.rawString(text);
+        this.writeVarInt(bytes.length);
+        this.writeBytes(bytes);
+        return this;
+    };
+    PBinaryWriter.prototype.emitUInt32 = function (value) {
+        if (value < 0)
+            throw "negative value invalid";
+        var D = (value & 0xff000000) >> 24;
+        var C = (value & 0x00ff0000) >> 16;
+        var B = (value & 0x0000ff00) >> 8;
+        var A = value & 0x000000ff;
+        // TODO check if the endianess is correct, might have to reverse order of appends
+        this.appendByte(0xff);
+        this.appendByte(A);
+        this.appendByte(B);
+        this.appendByte(C);
+        this.appendByte(D);
+        return this;
+    };
+    PBinaryWriter.prototype.writeBigInteger = function (value) {
+        return this.writeBigIntegerString(value.toString());
+    };
+    PBinaryWriter.prototype.writeBigIntegerString = function (value) {
+        var bytes = [];
+        if (value == "0") {
+            bytes = [0];
+        }
+        else if (value.startsWith("-1")) {
+            throw new Error("Unsigned bigint serialization not suppoted");
+        }
+        else {
+            var hex = BigInt(value).toString(16);
+            if (hex.length % 2)
+                hex = "0" + hex;
+            var len = hex.length / 2;
+            var i = 0;
+            var j = 0;
+            while (i < len) {
+                bytes.unshift(parseInt(hex.slice(j, j + 2), 16)); // little endian
+                i += 1;
+                j += 2;
+            }
+            bytes.push(0); // add sign at the end
+        }
+        return this.writeByteArray(bytes);
+    };
+    PBinaryWriter.prototype.writeSignature = function (signature) {
+        if (!signature) {
+            this.writeByte(interfaces_1.SignatureKind.None);
+            return this;
+        }
+        this.writeByte(signature.Kind);
+        signature.SerializeData(this);
+        return this;
+    };
+    PBinaryWriter.prototype.AppendHexEncoded = function (bytes) {
+        var localEncoded = (0, __1.hexStringToBytes)(bytes);
+        this.writeVarInt(localEncoded.length);
+        /*for (let i = 0; i < localEncoded.length; i++) {
+          if (!Number.isNaN(localEncoded[i])) {
+            this.appendByte(localEncoded[i]);
+          }
+        }*/
+        this.appendBytes(localEncoded);
+        return this;
+    };
+    return PBinaryWriter;
+}());
+exports.PBinaryWriter = PBinaryWriter;

package/core/types/Extensions/TableColumns.d.ts

@@ -0,0 +1,5 @@
+export declare class Describer {
+    private static FRegEx;
+    static describe(val: Function, parent?: boolean): string[];
+}
+//# sourceMappingURL=TableColumns.d.ts.map

package/core/types/Extensions/TableColumns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableColumns.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/TableColumns.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAuC;IAC5D,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,EAAE,MAAM,UAAQ,GAAG,MAAM,EAAE;CAWzD"}

package/core/types/Extensions/TableColumns.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Describer = void 0;
+var Describer = /** @class */ (function () {
+    function Describer() {
+    }
+    Describer.describe = function (val, parent) {
+        if (parent === void 0) { parent = false; }
+        var result = [];
+        if (parent) {
+            var proto = Object.getPrototypeOf(val.prototype);
+            if (proto) {
+                result = result.concat(this.describe(proto.constructor, parent));
+            }
+        }
+        result = result.concat(val.toString().match(this.FRegEx) || []);
+        return result;
+    };
+    Describer.FRegEx = new RegExp(/(?:this\.)(.+?(?= ))/g);
+    return Describer;
+}());
+exports.Describer = Describer;

package/core/types/Extensions/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./PBinaryReader";
+export * from "./PBinaryWriter";
+export * from "./Base16";
+export * from "./Describer";
+//# sourceMappingURL=index.d.ts.map

package/core/types/Extensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC"}

package/core/types/Extensions/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PBinaryReader"), exports);
+__exportStar(require("./PBinaryWriter"), exports);
+__exportStar(require("./Base16"), exports);
+__exportStar(require("./Describer"), exports);

package/core/types/PhantasmaKeys.d.ts

@@ -0,0 +1,19 @@
+import { IKeyPair } from "../interfaces/IKeyPair";
+import { Address } from "./Address";
+import { Signature } from "../interfaces/Signature";
+export declare class PhantasmaKeys implements IKeyPair {
+    private _privateKey;
+    get PrivateKey(): Uint8Array;
+    private _publicKey;
+    get PublicKey(): Uint8Array;
+    readonly Address: Address;
+    static readonly PrivateKeyLength = 32;
+    constructor(privateKey: Uint8Array);
+    toString(): string;
+    static generate(): PhantasmaKeys;
+    static fromWIF(wif: string): PhantasmaKeys;
+    toWIF(): string;
+    static xor(x: Uint8Array, y: Uint8Array): Uint8Array;
+    Sign(msg: Uint8Array, customSignFunction?: (msg: Uint8Array, privateKey: Uint8Array, publicKey: Uint8Array) => Uint8Array): Signature;
+}
+//# sourceMappingURL=PhantasmaKeys.d.ts.map

package/core/types/PhantasmaKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhantasmaKeys.d.ts","sourceRoot":"","sources":["../../src/core/types/PhantasmaKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAqBpD,qBAAa,aAAc,YAAW,QAAQ;IAC5C,OAAO,CAAC,WAAW,CAAa;IAChC,IAAW,UAAU,eAEpB;IACD,OAAO,CAAC,UAAU,CAAa;IAC/B,IAAW,SAAS,eAEnB;IACD,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC,gBAAuB,gBAAgB,MAAM;gBAEjC,UAAU,EAAE,UAAU;IAuB3B,QAAQ;WAID,QAAQ,IAAI,aAAa;WAOzB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;IAkB1C,KAAK,IAAI,MAAM;WAOR,GAAG,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,UAAU;IAWpD,IAAI,CACT,GAAG,EAAE,UAAU,EACf,kBAAkB,CAAC,EAAE,CACnB,GAAG,EAAE,UAAU,EACf,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,UAAU,KAClB,UAAU,GACd,SAAS;CAGb"}