phantasma-sdk-ts 0.1.76 → 0.2.0-rc.1

package/dist/core/types/CarbonSerialization.js

@@ -0,0 +1,447 @@
+"use strict";
+/**
+ * Binary serialization helpers matching Carbon's Serialization.cs
+ * - Little-endian for all integers
+ * - Zero-terminated UTF-8 strings
+ * - BigInt compact format:
+ *   header: 0 -> zero; otherwise lower 6 bits = length (1..32), bit7 = sign (1 for negative)
+ *   payload: little-endian two's complement without extra sign byte
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBlob = exports.writeBlob = exports.twosComplementLEToBigInt = exports.bigIntToTwosComplementLE = exports.CarbonBinaryReader = exports.CarbonBinaryWriter = exports.Throw = void 0;
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+class Throw {
+    static If(cond, msg) {
+        if (cond) {
+            throw new Error(msg);
+        }
+    }
+    static Assert(cond, msg = 'assertion failed') {
+        if (!cond) {
+            throw new Error(msg);
+        }
+    }
+}
+exports.Throw = Throw;
+class CarbonBinaryWriter {
+    constructor() {
+        this.chunks = [];
+        this.size = 0;
+    }
+    push(data) {
+        this.chunks.push(data);
+        this.size += data.length;
+    }
+    toUint8Array() {
+        const out = new Uint8Array(this.size);
+        let offset = 0;
+        for (const c of this.chunks) {
+            out.set(c, offset);
+            offset += c.length;
+        }
+        return out;
+    }
+    // Raw write helpers
+    write(data) {
+        this.push(data);
+    }
+    write1(v) {
+        const b = new Uint8Array(1);
+        b[0] = v & 0xff;
+        this.push(b);
+    }
+    write2(v) {
+        const b = new Uint8Array(2);
+        new DataView(b.buffer).setInt16(0, v, true);
+        this.push(b);
+    }
+    write4(v) {
+        const b = new Uint8Array(4);
+        new DataView(b.buffer).setInt32(0, v | 0, true);
+        this.push(b);
+    }
+    write4u(v) {
+        const b = new Uint8Array(4);
+        new DataView(b.buffer).setUint32(0, v >>> 0, true);
+        this.push(b);
+    }
+    write8(v) {
+        const b = new Uint8Array(8);
+        const dv = new DataView(b.buffer);
+        dv.setBigInt64(0, v, true);
+        this.push(b);
+    }
+    write8u(v) {
+        const b = new Uint8Array(8);
+        const dv = new DataView(b.buffer);
+        dv.setBigUint64(0, v, true);
+        this.push(b);
+    }
+    // Fixed-size blobs
+    writeExactly(data, count) {
+        Throw.If(data.length !== count, 'incorrect input size');
+        this.push(data);
+    }
+    write16(data) {
+        const bytes = data instanceof Uint8Array ? data : data.bytes;
+        this.writeExactly(bytes, 16);
+    }
+    write32(data) {
+        const bytes = data instanceof Uint8Array ? data : data.bytes;
+        this.writeExactly(bytes, 32);
+    }
+    write64(data) {
+        const bytes = data instanceof Uint8Array ? data : data.bytes;
+        this.writeExactly(bytes, 64);
+    }
+    // Blobs (ICarbonBlob)
+    writeBlob(data) {
+        data.write(this);
+    }
+    writeArrayBlob(arr) {
+        this.write4(arr.length);
+        for (const t of arr) {
+            t.write(this);
+        }
+    }
+    // BigInt compact format (<= 32 bytes)
+    writeBigInt(value) {
+        if (value === 0n) {
+            this.write1(0);
+            return;
+        }
+        // Convert to minimal little-endian two's complement
+        let bytes = bigIntToTwosComplementLE(value);
+        // If longer than 32 and is only sign extension to 33, trim to 32 and recurse (mimics C#)
+        if (bytes.length > 32) {
+            Throw.Assert(bytes.length === 33 && (bytes[32] === 0x00 || bytes[32] === 0xff), 'BigInt overflow');
+            bytes = bytes.slice(0, 32);
+            this.writeBigInt(twosComplementLEToBigInt(bytes));
+            return;
+        }
+        this.writeBigIntRaw(bytes);
+    }
+    writeBigIntRaw(bytes) {
+        const length = bytes.length;
+        Throw.Assert(length > 0 && length <= 32, 'BigInt too big');
+        // infer sign from inherent top bit
+        const signFromBytes = (bytes[length - 1] & 0x80) !== 0 ? -1 : 1;
+        const signBit = signFromBytes < 0 ? 0x80 : 0;
+        const header = (length & 0x3f) | signBit;
+        this.write1(header);
+        this.writeExactly(bytes, length);
+    }
+    writeArrayBigInt(items) {
+        this.write4(items.length);
+        for (const x of items) {
+            this.writeBigInt(x);
+        }
+    }
+    // Strings (zero-terminated UTF-8)
+    writeSz(s) {
+        const bytes = textEncoder.encode(s);
+        for (const b of bytes) {
+            Throw.Assert(b !== 0, 'string contains zero byte');
+        }
+        this.write(bytes);
+        this.write1(0);
+    }
+    writeArraySz(arr) {
+        this.write4(arr.length);
+        for (const s of arr) {
+            this.writeSz(s);
+        }
+    }
+    // Variable-length byte arrays
+    writeArray(bytes) {
+        this.write4(bytes.length);
+        this.write(bytes);
+    }
+    writeArray64u(arr) {
+        this.write4(arr.length);
+        for (const v of arr) {
+            this.write8u(v);
+        }
+    }
+    writeArray64(arr) {
+        this.write4(arr.length);
+        for (const v of arr) {
+            this.write8(v);
+        }
+    }
+    writeArray32(arr) {
+        this.write4(arr.length);
+        for (const v of arr) {
+            this.write4(v);
+        }
+    }
+    writeArray16(arr) {
+        this.write4(arr.length);
+        for (const v of arr) {
+            this.write2(v);
+        }
+    }
+    writeArray8(arr) {
+        this.write4(arr.length);
+        for (const v of arr) {
+            this.write1(v);
+        }
+    }
+    writeArrayOfArrays(arr) {
+        this.write4(arr.length);
+        for (const a of arr) {
+            this.writeArray(a);
+        }
+    }
+}
+exports.CarbonBinaryWriter = CarbonBinaryWriter;
+class CarbonBinaryReader {
+    constructor(buffer) {
+        this.offset = 0;
+        this.bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+        this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    }
+    take(count) {
+        Throw.If(this.offset + count > this.bytes.length, 'end of stream reached');
+        const out = this.bytes.subarray(this.offset, this.offset + count);
+        this.offset += count;
+        return out;
+    }
+    readRemaining() {
+        return this.take(this.bytes.length - this.offset);
+    }
+    // Raw reads
+    read1() {
+        const b = this.bytes[this.offset];
+        this.offset += 1;
+        return b;
+    }
+    read2() {
+        const v = this.view.getInt16(this.offset, true);
+        this.offset += 2;
+        return v;
+    }
+    read4() {
+        const v = this.view.getInt32(this.offset, true);
+        this.offset += 4;
+        return v;
+    }
+    read4u() {
+        const v = this.view.getUint32(this.offset, true);
+        this.offset += 4;
+        return v;
+    }
+    read8() {
+        const v = this.view.getBigInt64(this.offset, true);
+        this.offset += 8;
+        return v;
+    }
+    read8u() {
+        const v = this.view.getBigUint64(this.offset, true);
+        this.offset += 8;
+        return v;
+    }
+    // Fixed-size blobs
+    readExactly(count) {
+        return this.take(count);
+    }
+    read16() {
+        return this.take(16);
+    }
+    read32() {
+        return this.take(32);
+    }
+    read64() {
+        return this.take(64);
+    }
+    readInto16(out) {
+        out.bytes = this.read16();
+    }
+    readInto32(out) {
+        out.bytes = this.read32();
+    }
+    readInto64(out) {
+        out.bytes = this.read64();
+    }
+    // Blobs (ICarbonBlob)
+    readBlob(ctor) {
+        const t = new ctor();
+        t.read(this);
+        return t;
+    }
+    readArrayBlob(ctor) {
+        const len = this.read4();
+        const arr = new Array(len);
+        for (let i = 0; i < len; i++) {
+            const t = new ctor();
+            t.read(this);
+            arr[i] = t;
+        }
+        return arr;
+    }
+    // BigInt compact format
+    readBigInt() {
+        const header = this.read1();
+        if (header === 0) {
+            return 0n;
+        }
+        const sign = (header & 0x80) !== 0 ? -1 : 1;
+        const length = header & 0x3f;
+        Throw.If(length > 32, 'BigInt too big');
+        if (length === 0) {
+            return 0n;
+        }
+        let bytes = this.readExactly(length);
+        // Ensure inherent sign matches header by adding explicit sign extension byte if needed
+        const inherentSign = (bytes[bytes.length - 1] & 0x80) !== 0 ? -1 : 1;
+        if (inherentSign !== sign) {
+            const ext = sign >= 0 ? 0x00 : 0xff;
+            const tmp = new Uint8Array(bytes.length + 1);
+            tmp.set(bytes, 0);
+            tmp[tmp.length - 1] = ext;
+            bytes = tmp;
+        }
+        const bi = twosComplementLEToBigInt(bytes);
+        // Sanity check: signs must match
+        Throw.Assert((bi < 0n ? -1 : bi > 0n ? 1 : 0) === sign || bi === 0n, 'BigInt sign mismatch');
+        return bi;
+    }
+    readArrayBigInt() {
+        const len = this.read4();
+        const arr = new Array(len);
+        for (let i = 0; i < len; i++)
+            arr[i] = this.readBigInt();
+        return arr;
+    }
+    // Strings (zero-terminated UTF-8)
+    readSz() {
+        const start = this.offset;
+        while (true) {
+            Throw.If(this.offset >= this.bytes.length, 'end of stream reached');
+            if (this.bytes[this.offset] === 0)
+                break;
+            this.offset++;
+        }
+        const slice = this.bytes.subarray(start, this.offset);
+        this.offset++; // skip zero
+        return textDecoder.decode(slice);
+    }
+    readArraySz() {
+        const len = this.read4();
+        const out = new Array(len);
+        for (let i = 0; i < len; i++)
+            out[i] = this.readSz();
+        return out;
+    }
+    // Variable-length byte arrays
+    readArray() {
+        const len = this.read4();
+        return this.readExactly(len);
+    }
+    readArrayOfArrays() {
+        const len = this.read4();
+        const arr = new Array(len);
+        for (let i = 0; i < len; i++)
+            arr[i] = this.readArray();
+        return arr;
+    }
+    readArray64u() {
+        const len = this.read4();
+        const out = new Array(len);
+        for (let i = 0; i < len; i++)
+            out[i] = this.read8u();
+        return out;
+    }
+    readArray64() {
+        const len = this.read4();
+        const out = new Array(len);
+        for (let i = 0; i < len; i++)
+            out[i] = this.read8();
+        return out;
+    }
+    readArray32() {
+        const len = this.read4();
+        const out = new Array(len);
+        for (let i = 0; i < len; i++)
+            out[i] = this.read4();
+        return out;
+    }
+    readArray16() {
+        const len = this.read4();
+        const out = new Array(len);
+        for (let i = 0; i < len; i++)
+            out[i] = this.read2();
+        return out;
+    }
+    readArray8() {
+        const len = this.read4();
+        const out = new Array(len);
+        for (let i = 0; i < len; i++)
+            out[i] = this.read1();
+        return out;
+    }
+}
+exports.CarbonBinaryReader = CarbonBinaryReader;
+/**
+ * Convert bigint to minimal little-endian two's complement bytes
+ * Behavior mirrors .NET BigInteger.ToByteArray() but never returns 0-length
+ */
+function bigIntToTwosComplementLE(value) {
+    if (value === 0n)
+        return new Uint8Array([0]);
+    const negative = value < 0n;
+    let v = value;
+    // Extract bytes little-endian
+    const out = [];
+    if (!negative) {
+        while (v > 0n) {
+            out.push(Number(v & 0xffn));
+            v >>= 8n;
+        }
+        // If the highest byte would imply negative (bit7 set), append a 0x00 sign byte
+        if ((out[out.length - 1] & 0x80) !== 0)
+            out.push(0x00);
+    }
+    else {
+        // For negative numbers, two's complement infinite ones; emulate via loop
+        // We repeatedly take (v & 0xFF) then arithmetic shift
+        while (v !== -1n && v !== 0n) {
+            out.push(Number(v & 0xffn));
+            v >>= 8n;
+        }
+        // Ensure top byte has MSB set to keep negative sign
+        if (out.length === 0 || (out[out.length - 1] & 0x80) === 0)
+            out.push(0xff);
+    }
+    return Uint8Array.from(out);
+}
+exports.bigIntToTwosComplementLE = bigIntToTwosComplementLE;
+/** Convert little-endian two's complement bytes to bigint */
+function twosComplementLEToBigInt(bytes) {
+    if (bytes.length === 0)
+        return 0n;
+    const negative = (bytes[bytes.length - 1] & 0x80) !== 0;
+    let result = 0n;
+    for (let i = bytes.length - 1; i >= 0; i--) {
+        result = (result << 8n) | BigInt(bytes[i]);
+    }
+    if (negative) {
+        const bitLen = BigInt(bytes.length * 8);
+        const mod = 1n << bitLen;
+        result = result - mod;
+    }
+    return result;
+}
+exports.twosComplementLEToBigInt = twosComplementLEToBigInt;
+// Convenience helpers to mirror C# generic methods
+function writeBlob(w, data) {
+    data.write(w);
+}
+exports.writeBlob = writeBlob;
+function readBlob(r, ctor) {
+    const t = new ctor();
+    t.read(r);
+    return t;
+}
+exports.readBlob = readBlob;

package/{core → dist/core}/types/Consensus.d.ts

@@ -1,6 +1,6 @@
-import { ISerializable } from "../interfaces";
-import { PBinaryReader, PBinaryWriter } from "./Extensions";
-import { Timestamp } from "./Timestamp";
+import { ISerializable } from '../interfaces';
+import { PBinaryReader, PBinaryWriter } from './Extensions';
+import { Timestamp } from './Timestamp';
 export declare enum ConsensusMode {
     Unanimity = 0,
     Majority = 1,

package/dist/core/types/Consensus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Consensus.d.ts","sourceRoot":"","sources":["../../../src/core/types/Consensus.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EAAU,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,oBAAY,aAAa;IACvB,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,UAAU,IAAA;IACV,OAAO,IAAA;CACR;AAED,oBAAY,SAAS;IACnB,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,SAAS,IAAA;IACT,OAAO,IAAA;CACR;AAED,qBAAa,UAAW,YAAW,aAAa;IACvC,KAAK,EAAE,MAAM,CAAC;gBAEF,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAK3C,aAAa,CAAC,MAAM,EAAE,aAAa;IAInC,eAAe,CAAC,MAAM,EAAE,aAAa;IAIrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,UAAU;CAKtD;AAED,qBAAa,SAAU,YAAW,aAAa;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IAErB,aAAa,CAAC,MAAM,EAAE,aAAa;IAMnC,eAAe,CAAC,MAAM,EAAE,aAAa;IAMrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS;CAKrD;AAED,qBAAa,QAAS,YAAW,aAAa;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IAE1B,aAAa,CAAC,MAAM,EAAE,aAAa;IAInC,eAAe,CAAC,MAAM,EAAE,aAAa;IAKrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,QAAQ;CAKpD;AAED,qBAAa,aAAc,YAAW,aAAa;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,SAAS,CAAC;IACrB,OAAO,EAAE,SAAS,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;;IAe1B,aAAa,CAAC,MAAM,EAAE,aAAa;IAiBnC,eAAe,CAAC,MAAM,EAAE,aAAa;IAmBrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,aAAa;CAKzD;AAED,qBAAa,YAAa,YAAW,aAAa;IACzC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IAErB,aAAa,CAAC,MAAM,EAAE,aAAa;IAInC,eAAe,CAAC,MAAM,EAAE,aAAa;IAKrC,MAAM,CAAC,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,YAAY;CAKxD"}

package/{core → dist/core}/types/Consensus.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollPresence = exports.ConsensusPoll = exports.PollVote = exports.PollValue = exports.PollChoice = exports.PollState = exports.ConsensusMode = void 0;
-var utils_1 = require("../utils");
-var Extensions_1 = require("./Extensions");
-var Timestamp_1 = require("./Timestamp");
+const utils_1 = require("../utils");
+const Extensions_1 = require("./Extensions");
+const Timestamp_1 = require("./Timestamp");
 var ConsensusMode;
 (function (ConsensusMode) {
     ConsensusMode[ConsensusMode["Unanimity"] = 0] = "Unanimity";
@@ -18,71 +18,64 @@ var PollState;
     PollState[PollState["Consensus"] = 2] = "Consensus";
     PollState[PollState["Failure"] = 3] = "Failure";
 })(PollState = exports.PollState || (exports.PollState = {}));
-var PollChoice = /** @class */ (function () {
-    function PollChoice(value) {
+class PollChoice {
+    constructor(value) {
         if (value instanceof Array)
-            this.value = Extensions_1.Base16.decode((0, utils_1.byteArrayToHex)(value));
+            this.value = Extensions_1.Base16.decode((0, utils_1.bytesToHex)(value));
         else
             this.value = value;
     }
-    PollChoice.prototype.SerializeData = function (writer) {
+    SerializeData(writer) {
         writer.writeByteArray((0, utils_1.stringToUint8Array)(this.value));
-    };
-    PollChoice.prototype.UnserializeData = function (reader) {
+    }
+    UnserializeData(reader) {
         this.value = Extensions_1.Base16.decode(reader.readByteArray());
-    };
-    PollChoice.Unserialize = function (reader) {
-        var pollChoice = new PollChoice("");
+    }
+    static Unserialize(reader) {
+        let pollChoice = new PollChoice('');
         pollChoice.UnserializeData(reader);
         return pollChoice;
-    };
-    return PollChoice;
-}());
-exports.PollChoice = PollChoice;
-var PollValue = /** @class */ (function () {
-    function PollValue() {
     }
-    PollValue.prototype.SerializeData = function (writer) {
+}
+exports.PollChoice = PollChoice;
+class PollValue {
+    SerializeData(writer) {
         writer.writeByteArray((0, utils_1.stringToUint8Array)(this.value));
         writer.writeBigInteger(this.ranking);
         writer.writeBigInteger(this.votes);
-    };
-    PollValue.prototype.UnserializeData = function (reader) {
+    }
+    UnserializeData(reader) {
         this.value = Extensions_1.Base16.decode(reader.readByteArray());
         this.ranking = reader.readBigInteger();
         this.votes = reader.readBigInteger();
-    };
-    PollValue.Unserialize = function (reader) {
-        var pollValue = new PollValue();
+    }
+    static Unserialize(reader) {
+        let pollValue = new PollValue();
         pollValue.UnserializeData(reader);
         return pollValue;
-    };
-    return PollValue;
-}());
-exports.PollValue = PollValue;
-var PollVote = /** @class */ (function () {
-    function PollVote() {
     }
-    PollVote.prototype.SerializeData = function (writer) {
+}
+exports.PollValue = PollValue;
+class PollVote {
+    SerializeData(writer) {
         writer.writeBigInteger(this.index);
         writer.writeBigInteger(this.percentage);
-    };
-    PollVote.prototype.UnserializeData = function (reader) {
+    }
+    UnserializeData(reader) {
         this.index = reader.readBigInteger();
         this.percentage = reader.readBigInteger();
-    };
-    PollVote.Unserialize = function (reader) {
-        var pollVote = new PollVote();
+    }
+    static Unserialize(reader) {
+        let pollVote = new PollVote();
         pollVote.UnserializeData(reader);
         return pollVote;
-    };
-    return PollVote;
-}());
+    }
+}
 exports.PollVote = PollVote;
-var ConsensusPoll = /** @class */ (function () {
-    function ConsensusPoll() {
-        this.subject = "";
-        this.organization = "";
+class ConsensusPoll {
+    constructor() {
+        this.subject = '';
+        this.organization = '';
         this.mode = ConsensusMode.Unanimity;
         this.state = PollState.Inactive;
         this.entries = [];
@@ -92,13 +85,13 @@ var ConsensusPoll = /** @class */ (function () {
         this.choicesPerUser = BigInt(0);
         this.totalVotes = BigInt(0);
     }
-    ConsensusPoll.prototype.SerializeData = function (writer) {
+    SerializeData(writer) {
         writer.writeString(this.subject);
         writer.writeString(this.organization);
         writer.writeByte(this.mode);
         writer.writeByte(this.state);
         writer.writeByte(this.entries.length);
-        this.entries.forEach(function (entry) {
+        this.entries.forEach((entry) => {
             entry.SerializeData(writer);
         });
         writer.writeBigInteger(this.round);
@@ -106,15 +99,15 @@ var ConsensusPoll = /** @class */ (function () {
         writer.writeTimestamp(this.endTime);
         writer.writeBigInteger(this.choicesPerUser);
         writer.writeBigInteger(this.totalVotes);
-    };
-    ConsensusPoll.prototype.UnserializeData = function (reader) {
+    }
+    UnserializeData(reader) {
         this.subject = reader.readString();
         this.organization = reader.readString();
         this.mode = reader.readByte();
         this.state = reader.readByte();
         this.entries = [];
-        var entriesLength = reader.readUnsignedInt();
-        for (var i = 0; i < entriesLength; i++) {
+        const entriesLength = reader.readUnsignedInt();
+        for (let i = 0; i < entriesLength; i++) {
             this.entries.push(PollValue.Unserialize(reader));
         }
         this.round = reader.readBigInteger();
@@ -122,30 +115,26 @@ var ConsensusPoll = /** @class */ (function () {
         this.endTime = reader.readTimestamp();
         this.choicesPerUser = reader.readBigInteger();
         this.totalVotes = reader.readBigInteger();
-    };
-    ConsensusPoll.Unserialize = function (reader) {
-        var consensusPoll = new ConsensusPoll();
+    }
+    static Unserialize(reader) {
+        let consensusPoll = new ConsensusPoll();
         consensusPoll.UnserializeData(reader);
         return consensusPoll;
-    };
-    return ConsensusPoll;
-}());
-exports.ConsensusPoll = ConsensusPoll;
-var PollPresence = /** @class */ (function () {
-    function PollPresence() {
     }
-    PollPresence.prototype.SerializeData = function (writer) {
+}
+exports.ConsensusPoll = ConsensusPoll;
+class PollPresence {
+    SerializeData(writer) {
         writer.writeString(this.subject);
-    };
-    PollPresence.prototype.UnserializeData = function (reader) {
+    }
+    UnserializeData(reader) {
         this.subject = reader.readString();
         this.round = reader.readBigInteger();
-    };
-    PollPresence.Unserialize = function (reader) {
-        var pollPresence = new PollPresence();
+    }
+    static Unserialize(reader) {
+        let pollPresence = new PollPresence();
         pollPresence.UnserializeData(reader);
         return pollPresence;
-    };
-    return PollPresence;
-}());
+    }
+}
 exports.PollPresence = PollPresence;

package/{core → dist/core}/types/Contract.d.ts

@@ -1,7 +1,7 @@
-import { ISerializable } from "../interfaces";
-import { VMType } from "../vm/VMType";
-import { TokenTrigger } from "./DomainSettings";
-import { PBinaryReader, PBinaryWriter } from "./Extensions";
+import { ISerializable } from '../interfaces';
+import { VMType } from '../vm/VMType';
+import { TokenTrigger } from './DomainSettings';
+import { PBinaryReader, PBinaryWriter } from './Extensions';
 export declare class ContractParameter {
     name: string;
     type: VMType;

package/dist/core/types/Contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Contract.d.ts","sourceRoot":"","sources":["../../../src/core/types/Contract.ts"],"names":[],"mappings":"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"}