phantasma-sdk-ts 0.1.71

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

@@ -0,0 +1 @@
+{"version":3,"file":"Base16.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/Base16.ts"],"names":[],"mappings":"AAEA,qBAAa,MAAM;IACjB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM;IASzB,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,UAAU;IAOvC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM;IAWzB,MAAM,CAAC,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;CAKjD"}

package/core/types/Extensions/Base16.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Base16 = void 0;
+var utils_1 = require("../../utils");
+var Base16 = /** @class */ (function () {
+    function Base16() {
+    }
+    Base16.encode = function (str) {
+        if (!str)
+            return "";
+        return str
+            .split("")
+            .map(function (c) { return c.charCodeAt(0).toString(16).padStart(2, "0"); })
+            .join("");
+    };
+    Base16.encodeUint8Array = function (arr) {
+        return Array.from(arr)
+            .map(function (c) { return c.toString(16).padStart(2, "0"); })
+            .join("")
+            .toUpperCase();
+    };
+    Base16.decode = function (str) {
+        var _a, _b;
+        if (!str || str.length % 2 !== 0)
+            return "";
+        return ((_b = (_a = str
+            .match(/.{1,2}/g)) === null || _a === void 0 ? void 0 : _a.map(function (c) { return String.fromCharCode(parseInt(c, 16)); }).join("")) !== null && _b !== void 0 ? _b : "");
+    };
+    Base16.decodeUint8Array = function (str) {
+        if (!str || str.length % 2 !== 0)
+            return new Uint8Array(0);
+        return new Uint8Array((0, utils_1.stringToUint8Array)(this.decode(str)));
+    };
+    return Base16;
+}());
+exports.Base16 = Base16;

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

@@ -0,0 +1,17 @@
+import { BinaryReader } from "csharp-binary-stream";
+import { ISignature } from "../../interfaces";
+import { Timestamp } from "../Timestamp";
+export declare class PBinaryReader extends BinaryReader {
+    constructor(Uint8Array: Uint8Array);
+    read(numBytes: number): string;
+    readString(): string;
+    readStringBytes(numBytes: number): string;
+    readBigInteger(): BigInt;
+    readBigIntAccurate(): string;
+    readSignature(): ISignature;
+    readByteArray(): any;
+    readTimestamp(): Timestamp;
+    readVarInt(): number;
+    readVmObject(): {};
+}
+//# sourceMappingURL=BinaryReader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryReader.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/BinaryReader.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,YAAY,EAAY,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAiB,MAAM,kBAAkB,CAAC;AAG7D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,qBAAa,aAAc,SAAQ,YAAY;gBACjC,UAAU,EAAE,UAAU;IAS3B,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM9B,UAAU,IAAI,MAAM;IAKpB,eAAe,CAAC,QAAQ,EAAE,MAAM;IAQhC,cAAc,IAAI,MAAM;IAaxB,kBAAkB;IAUlB,aAAa;IAwBb,aAAa;IASb,aAAa,IAAI,SAAS;IAa1B,UAAU,IAAI,MAAM;IAsBpB,YAAY;CA8BpB"}

package/core/types/Extensions/BinaryReader.js

@@ -0,0 +1,192 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 Timestamp_1 = require("../Timestamp");
+var PBinaryReader = /** @class */ (function (_super) {
+    __extends(PBinaryReader, _super);
+    function PBinaryReader(buffer) {
+        var _this = this;
+        if (Buffer.isBuffer(arguments[0])) {
+            _this = _super.call(this, arguments[0]) || this;
+        }
+        else if (Uint8Array.prototype.isPrototypeOf(arguments[0])) {
+            _this = _super.call(this, arguments[0]) || this;
+        }
+        return _this;
+    }
+    PBinaryReader.prototype.read = function (numBytes) {
+        var res = (0, utils_1.byteArrayToHex)(this.readBytes(numBytes)).substr(0, numBytes * 2);
+        this.position += numBytes * 2;
+        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.readSignature = function () {
+        var kind = this.readByte();
+        var signature = new interfaces_1.ISignature();
+        var curve;
+        signature.kind = kind;
+        switch (kind) {
+            case interfaces_1.SignatureKind.None:
+                return null;
+            case interfaces_1.SignatureKind.Ed25519:
+                var len = this.readVarInt();
+                signature.signature = this.read(len);
+                break;
+            case interfaces_1.SignatureKind.ECDSA:
+                curve = this.readByte();
+                signature.signature = 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)
+            .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.readVmObject = function () {
+        var type = this.readByte();
+        console.log("type", type);
+        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();
+                    console.log("  key", key);
+                    var value = this.readVmObject();
+                    console.log("  value", value);
+                    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;
+}(csharp_binary_stream_1.BinaryReader));
+exports.PBinaryReader = PBinaryReader;

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

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { BinaryWriter } from "csharp-binary-stream";
+import { Timestamp } from "../Timestamp";
+type byte = number;
+export declare class Example extends BinaryWriter {
+    constructor(arg1?: undefined | Buffer | Uint8Array | null);
+    appendByte(value: number): this;
+}
+export declare class PBinaryWriter extends BinaryWriter {
+    constructor(arg1?: undefined | Buffer | Uint8Array | null);
+    appendByte(value: number): this;
+    appendBytes(bytes: byte[]): void;
+    writeBytes(bytes: byte[]): this;
+    writeVarInt(value: number): this;
+    writeTimestamp(obj: Timestamp): this;
+    writeDateTime(obj: Date): this;
+    rawString(value: string): any[];
+    writeByteArray(bytes: number[]): this;
+    writeString(text: string): this;
+    emitUInt32(value: number): this;
+    writeBigInteger(value: BigInt): this;
+    writeBigIntegerString(value: string): this;
+}
+export {};
+//# sourceMappingURL=BinaryWriter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryWriter.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/BinaryWriter.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,KAAK,IAAI,GAAG,MAAM,CAAC;AAqBnB,qBAAa,OAAQ,SAAQ,YAAY;gBAC3B,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI;IAIlD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;CAIvC;AACD,qBAAa,aAAc,SAAQ,YAAY;gBACjC,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI;IAGlD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK/B,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE;IAMhC,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;IAQhB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE;IAM9B,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;CAsB3C"}

package/core/types/Extensions/BinaryWriter.js

@@ -0,0 +1,191 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PBinaryWriter = exports.Example = void 0;
+//import { BinaryWriter, BinaryReader, Encoding } from "csharp-binary-stream";
+var csharp_binary_stream_1 = require("csharp-binary-stream");
+/*BinaryWriter.prototype.appendByte = function (value: number): this {};
+
+/*
+
+Object.defineProperty(
+  BinaryWriter,
+  "appendByte",
+  (value: number): BinaryWriter => {
+    (this as unknown as BinaryWriter).writeByte(value);
+    return this as unknown as BinaryWriter;
+  }
+);
+
+BinaryWriter.prototype.writeBytes = function (bytes: number[]): this {
+  for (let i = 0; i < bytes.length; i++) this.appendByte(bytes[i]);
+  return this;
+};
+*/
+var Example = /** @class */ (function (_super) {
+    __extends(Example, _super);
+    function Example(arg1) {
+        return _super.call(this, arg1) || this;
+    }
+    Example.prototype.appendByte = function (value) {
+        this.writeByte(value);
+        return this;
+    };
+    return Example;
+}(csharp_binary_stream_1.BinaryWriter));
+exports.Example = Example;
+var PBinaryWriter = /** @class */ (function (_super) {
+    __extends(PBinaryWriter, _super);
+    function PBinaryWriter(arg1) {
+        return _super.call(this, arg1) || this;
+    }
+    PBinaryWriter.prototype.appendByte = function (value) {
+        _super.prototype.writeByte.call(this, value);
+        return this;
+    };
+    PBinaryWriter.prototype.appendBytes = function (bytes) {
+        for (var i = 0; i < bytes.length; i++) {
+            this.appendByte(bytes[i]);
+        }
+    };
+    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() + obj.getTimezoneOffset() * 60 * 1000) / 1000;
+        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) {
+        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);
+    };
+    return PBinaryWriter;
+}(csharp_binary_stream_1.BinaryWriter));
+exports.PBinaryWriter = PBinaryWriter;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"Describer.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/Describer.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;CAczD"}

package/core/types/Extensions/Describer.js

@@ -0,0 +1,25 @@
+"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) || []);
+        /*.filter((x) => {
+            x.replace("this.", "");
+          })*/
+        return result;
+    };
+    Describer.FRegEx = new RegExp(/(?:this\.)(.+?(?= ))/g);
+    return Describer;
+}());
+exports.Describer = Describer;

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

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+import { BinaryReader, Encoding } from "csharp-binary-stream";
+import { Signature } from "../../interfaces";
+import { Timestamp } from "../Timestamp";
+export declare class PBinaryReader {
+    reader: BinaryReader;
+    get length(): number;
+    get position(): number;
+    set position(value: number);
+    get isEndOfStream(): boolean;
+    readBoolean(): boolean;
+    readByte(): number;
+    readBytes(bytesToRead: number): number[];
+    readSignedByte(): number;
+    readShort(): number;
+    readUnsignedShort(): number;
+    readInt(): number;
+    readUnsignedInt(): number;
+    readLongString(): string;
+    readLong(): number;
+    readUnsignedLongString(): string;
+    readUnsignedLong(): number;
+    readFloat(): number;
+    readDouble(): number;
+    readChar(encoding: Encoding): string;
+    readChars(charactersToRead: number, encoding: Encoding): string;
+    readCharBytes(bytesToRead: number, encoding: Encoding): string;
+    constructor(arg1: Buffer | Uint8Array);
+    read(numBytes: number): string;
+    readString(): string;
+    readStringBytes(numBytes: number): string;
+    readBigInteger(): BigInt;
+    readBigIntAccurate(): string;
+    readSignatureV2(): Signature;
+    readSignature(): Signature;
+    readByteArray(): any;
+    readTimestamp(): Timestamp;
+    readVarInt(): number;
+    readVarString(): string;
+    readVmObject(): {};
+}
+//# sourceMappingURL=PBinaryReader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PBinaryReader.d.ts","sourceRoot":"","sources":["../../../src/core/types/Extensions/PBinaryReader.ts"],"names":[],"mappings":";AACA,OAAO,EAAgB,YAAY,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAA6B,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAIxE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,qBAAa,aAAa;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD,IAAI,QAAQ,IAAI,MAAM,CAErB;IACD,IAAI,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEzB;IACD,IAAI,aAAa,IAAI,OAAO,CAE3B;IACD,WAAW,IAAI,OAAO;IAGtB,QAAQ,IAAI,MAAM;IAGlB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE;IAGxC,cAAc,IAAI,MAAM;IAGxB,SAAS,IAAI,MAAM;IAGnB,iBAAiB,IAAI,MAAM;IAG3B,OAAO,IAAI,MAAM;IAGjB,eAAe,IAAI,MAAM;IAGzB,cAAc,IAAI,MAAM;IAGxB,QAAQ,IAAI,MAAM;IAGlB,sBAAsB,IAAI,MAAM;IAGhC,gBAAgB,IAAI,MAAM;IAG1B,SAAS,IAAI,MAAM;IAGnB,UAAU,IAAI,MAAM;IAGpB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAGpC,SAAS,CAAC,gBAAgB,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAG/D,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM;gBAIlD,IAAI,EAAE,MAAM,GAAG,UAAU;IAI9B,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAM9B,UAAU,IAAI,MAAM;IAKpB,eAAe,CAAC,QAAQ,EAAE,MAAM;IAQhC,cAAc,IAAI,MAAM;IAaxB,kBAAkB;IAUlB,eAAe,IAAI,SAAS;IAwB5B,aAAa,IAAI,SAAS;IAwB1B,aAAa;IASb,aAAa,IAAI,SAAS;IAc1B,UAAU,IAAI,MAAM;IAsBpB,aAAa,IAAI,MAAM;IAMvB,YAAY;CA2BpB"}