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

package/dist/core/types/PhantasmaBigIntSerialization.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Phantasma BigInt serialization (VarBytes-style)
+ *
+ * This module implements Phantasma serialization for signed big integers (bigint):
+ * - Representation is two's complement, little-endian (LE)
+ * - On the wire it follows the historical Phantasma/C# behavior:
+ *   1) Build a C#-compatible LE byte array for the integer (two's complement)
+ *      * Positive numbers get a leading 0x00 guard byte at the most significant side if needed
+ *      * Negative numbers get a two's complement form with MSB sign bit set (0x80) at the most significant byte
+ *   2) Apply Phantasma-specific trailing rule (aka tail guard):
+ *      * For positives: append 0x00 if the last byte is not already 0x00
+ *      * For negatives: append 0xFF to preserve sign extension (for -1 expects [FF,FF,FF])
+ *
+ * Reading (deserialization) reverses the process:
+ * - Decode two's complement from LE payload
+ * - For positives: treat the payload as a plain LE magnitude
+ * - For negatives: invert and add 1, then negate the resulting magnitude
+ *
+ * Notes
+ * - Little-endian (LE) means the least-significant byte comes first
+ * - Two's complement guarantees a unique representation for zero and correct ordering for negatives
+ * - This file intentionally mirrors Go/C# reference behavior for byte-for-byte compatibility
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigIntFromTwosComplementLE_phantasma = exports.bigIntToTwosComplementLE_phantasma = exports.bigIntToCsharpLE = void 0;
+/**
+ * Build a C#-compatible two's complement (LE) byte array for a signed bigint
+ * Steps:
+ * 1) Handle zero early as [0x00]
+ * 2) For positives:
+ *    - Extract magnitude bytes in LE order
+ *    - If the most significant byte (MSB) would imply a negative (bit 7 set), append 0x00 guard
+ * 3) For negatives:
+ *    - Start from magnitude of |n|, invert all bytes and add 1 (two's complement in LE)
+ *    - Ensure MSB has sign bit set (append 0xFF if needed)
+ * Result: a minimal LE two's complement array compatible with C# BigInteger byte layout
+ */
+function bigIntToCsharpLE(n) {
+    // Zero has a single-byte canonical representation in C# BigInteger: [0x00]
+    if (n === 0n) {
+        return new Uint8Array([0x00]);
+    }
+    // Determine the sign once; all subsequent steps depend on it
+    const negative = n < 0n;
+    // Work with magnitude |n|; two’s complement for negative values will be applied later
+    let x = negative ? -n : n;
+    const bytes = [];
+    // Extract magnitude in little-endian order: push least-significant byte first
+    while (x > 0n) {
+        bytes.push(Number(x & 0xffn));
+        x >>= 8n;
+    }
+    // Positive value path
+    if (!negative) {
+        // Ensure non-negative sign
+        // If MSB would set the sign bit, append 0x00 so the value stays non-negative in two’s complement
+        if ((bytes[bytes.length - 1] & 0x80) !== 0) {
+            bytes.push(0x00);
+        }
+        return Uint8Array.from(bytes);
+    }
+    // Negative value path: build two’s complement directly in little-endian representation
+    // Two's complement in LE
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = ~bytes[i] & 0xff;
+    }
+    // Step 2: add 1 to complete two’s complement (propagate carry across bytes)
+    // Step 2: add 1 to obtain the magnitude in LE (two’s complement reversal)
+    let carry = 1;
+    for (let i = 0; i < bytes.length; i++) {
+        const s = bytes[i] + carry;
+        bytes[i] = s & 0xff;
+        carry = s >> 8;
+        if (!carry)
+            break;
+    }
+    // If an extra carry remains, append it as a new most-significant byte
+    if (carry) {
+        bytes.push(carry);
+    }
+    // Ensure negative sign bit at MSB
+    // Ensure the resulting most-significant byte has the sign bit set to mark the value as negative
+    if ((bytes[bytes.length - 1] & 0x80) === 0) {
+        bytes.push(0xff);
+    }
+    return Uint8Array.from(bytes);
+}
+exports.bigIntToCsharpLE = bigIntToCsharpLE;
+/**
+ * Serialize bigint to Phantasma byte array (LE two's complement with trailing tail guard)
+ * Process:
+ * - First, build the C#-style two's complement bytes (LE) via toCsharpLE
+ * - Then apply Phantasma tail rule:
+ *   * Positive: ensure the last byte is 0x00 by appending one if necessary
+ *   * Negative: append 0xFF to keep sign-extension stable; for -1 specifically
+ *     expectation is [FF, FF, FF] (single-byte 0xFF followed by two 0xFF guard bytes)
+ * The resulting array matches historical Go/C# Phantasma serialization byte-for-byte
+ */
+// Serialize to Phantasma wire format: start from C# bytes then apply trailing-byte rule
+function bigIntToTwosComplementLE_phantasma(n) {
+    // 1) Build C#-compatible bytes (LE + sign-guard)
+    // Build C#-style LE two’s complement bytes first (minimal, sign-correct)
+    const cs = Array.from(bigIntToCsharpLE(n));
+    // 2) Apply Phantasma tail rules
+    // Phantasma trailing rule for negative values
+    if (n < 0n) {
+        // Historical special-case: single-byte negative values (like -1) must be extended to [FF, FF, FF] on the wire
+        if (cs.length === 1) {
+            cs.push(0xff, 0xff); // -1 → [FF,FF,FF]
+        }
+        else if (cs[cs.length - 1] === 0xff) {
+            cs.push(0xff);
+        }
+        // Phantasma trailing rule for non-negative values
+    }
+    else {
+        // Ensure a terminating 0x00 guard exists at the most-significant side for positives
+        if (cs[cs.length - 1] !== 0x00) {
+            cs.push(0x00);
+        }
+    }
+    return Uint8Array.from(cs);
+}
+exports.bigIntToTwosComplementLE_phantasma = bigIntToTwosComplementLE_phantasma;
+/**
+ * Deserialize Phantasma two's complement (LE) byte array back to bigint
+ * Logic:
+ * - Determine sign from the most significant byte's sign bit (bit 7)
+ * - For non-negative payloads:
+ *   * Interpret as a plain LE magnitude (ignore trailing 0x00 guard if present)
+ * - For negative payloads:
+ *   * Compute two's complement back in LE (invert bytes, add 1) and negate the magnitude
+ * This matches Go/C# reader behavior and roundtrips values produced by the serializer
+ */
+// Deserialize from Phantasma wire format: interpret two’s complement in LE
+function bigIntFromTwosComplementLE_phantasma(data) {
+    if (data.length === 0)
+        return 0n;
+    // Sign is determined by the most significant byte’s bit 7 (1 → negative)
+    const neg = (data[data.length - 1] & 0x80) !== 0;
+    // Positive path: interpret as plain little-endian magnitude; trailing 0x00 is benign
+    if (!neg) {
+        // positive: plain LE magnitude (leading zero bytes are fine)
+        let x = 0n;
+        // Reconstruct BigInt by shifting left 8 and OR-ing each byte from MSB to LSB
+        for (let i = data.length - 1; i >= 0; i--) {
+            x = (x << 8n) | BigInt(data[i]);
+        }
+        return x;
+    }
+    // Negative path: compute two’s complement back (invert and add 1), then negate the magnitude
+    // negative: two's complement back (LE)
+    const a = new Uint8Array(data);
+    for (let i = 0; i < a.length; i++)
+        a[i] = ~a[i] & 0xff;
+    let carry = 1;
+    for (let i = 0; i < a.length; i++) {
+        const s = a[i] + carry;
+        a[i] = s & 0xff;
+        carry = s >> 8;
+        if (!carry)
+            break;
+    }
+    let x = 0n;
+    // Fold bytes back into a positive magnitude and then apply the negative sign
+    for (let i = a.length - 1; i >= 0; i--) {
+        x = (x << 8n) | BigInt(a[i]);
+    }
+    return -x;
+}
+exports.bigIntFromTwosComplementLE_phantasma = bigIntFromTwosComplementLE_phantasma;

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

@@ -1,6 +1,6 @@
-import { IKeyPair } from "../interfaces/IKeyPair";
-import { Address } from "./Address";
-import { Signature } from "../interfaces/Signature";
+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;

package/dist/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;AAcpD,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"}

package/dist/core/types/PhantasmaKeys.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhantasmaKeys = void 0;
+const Address_1 = require("./Address");
+const bs58_1 = __importDefault(require("bs58"));
+const wif_1 = __importDefault(require("wif"));
+const utils_1 = require("../utils");
+const Ed25519Signature_1 = require("./Ed25519Signature");
+const elliptic_1 = __importDefault(require("elliptic"));
+const Entropy_1 = require("./Entropy");
+const tx_1 = require("../tx");
+const { eddsa } = elliptic_1.default;
+const ed25519 = new eddsa('ed25519');
+class PhantasmaKeys {
+    get PrivateKey() {
+        return this._privateKey;
+    }
+    get PublicKey() {
+        return this._publicKey;
+    }
+    constructor(privateKey) {
+        if (privateKey.length == 64) {
+            privateKey = privateKey.slice(0, 32);
+        }
+        if (privateKey.length != PhantasmaKeys.PrivateKeyLength) {
+            throw new Error(`privateKey should have length ${PhantasmaKeys.PrivateKeyLength} but has ${privateKey.length}`);
+        }
+        this._privateKey = new Uint8Array(PhantasmaKeys.PrivateKeyLength);
+        this._privateKey.set(privateKey);
+        let wif = (0, tx_1.getWifFromPrivateKey)((0, utils_1.bytesToHex)(privateKey));
+        const privateKeyString = (0, utils_1.bytesToHex)(this._privateKey);
+        const privateKeyBuffer = Buffer.from(privateKeyString, 'hex');
+        const publicKey = ed25519.keyFromSecret(privateKeyBuffer).getPublic();
+        this._publicKey = publicKey;
+        this.Address = Address_1.Address.FromKey(this);
+    }
+    toString() {
+        return this.Address.Text;
+    }
+    static generate() {
+        const privateKey = Entropy_1.Entropy.GetRandomBytes(PhantasmaKeys.PrivateKeyLength);
+        const pair = new PhantasmaKeys(privateKey);
+        return pair;
+    }
+    static fromWIF(wif) {
+        if (!wif) {
+            throw new Error('WIF required');
+        }
+        let data = bs58_1.default.decode(wif); // checkdecode
+        if (data.length == 38) {
+            data = data.slice(0, 34);
+        }
+        if (data.length != 34 || data[0] != 0x80 || data[33] != 0x01) {
+            throw new Error('Invalid WIF format');
+        }
+        const privateKey = data.slice(1, 33);
+        return new PhantasmaKeys(privateKey);
+    }
+    toWIF() {
+        const privateKeyString = (0, utils_1.bytesToHex)(this._privateKey);
+        const privatekeyBuffer = Buffer.from(privateKeyString, 'hex');
+        const wif = wif_1.default.encode(128, privatekeyBuffer, true); //uint8ArrayToHex(data); // .base58CheckEncode();
+        return wif;
+    }
+    static xor(x, y) {
+        if (x.length != y.length) {
+            throw new Error('x and y should have the same length');
+        }
+        const result = new Uint8Array(x.length);
+        for (let i = 0; i < x.length; i++) {
+            result[i] = x[i] ^ y[i];
+        }
+        return result;
+    }
+    Sign(msg, customSignFunction) {
+        return Ed25519Signature_1.Ed25519Signature.Generate(this, msg);
+    }
+}
+exports.PhantasmaKeys = PhantasmaKeys;
+PhantasmaKeys.PrivateKeyLength = 32;

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

@@ -0,0 +1 @@
+{"version":3,"file":"Serialization.d.ts","sourceRoot":"","sources":["../../../src/core/types/Serialization.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,aAAa,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAKpE,MAAM,WAAW,YAAY;IAC3B,CAAC,MAAM,EAAE,aAAa,GAAG,GAAG,CAAC;CAC9B;AACD,MAAM,WAAW,YAAY;IAC3B,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAAC;CACzC;AAID,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;gBACjB,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY;CAIvD;AAED,qBAAa,aAAa,CAAC,CAAC;IAC1B,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAG7B;IAEJ,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY;IAO1E,MAAM,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU;IAc1C,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,UAAU;IAgBtC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,GAAG,IAAI;IAmExE,MAAM,CAAC,WAAW,CAAC,CAAC,EAClB,YAAY,EAAE,UAAU,GAAG,aAAa,EACxC,IAAI,CAAC,EAAE,GAAG,GACT,CAAC;IAYJ,MAAM,CAAC,iBAAiB,CAAC,CAAC,SAAS,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,GAAG,CAAC;CA6D7E"}

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

@@ -1,37 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Serialization = exports.CustomSerializer = void 0;
-var Extensions_1 = require("./Extensions");
-var Timestamp_1 = require("./Timestamp");
-var utils_1 = require("../utils");
+const Extensions_1 = require("./Extensions");
+const Timestamp_1 = require("./Timestamp");
+const utils_1 = require("../utils");
 //function CustomWriter(writer: PBinaryWriter, obj: any): void;
 //function CustomReader(reader: PBinaryReader): any;
-var CustomSerializer = /** @class */ (function () {
-    function CustomSerializer(reader, writer) {
+class CustomSerializer {
+    constructor(reader, writer) {
         this.Read = reader;
         this.Write = writer;
     }
-    return CustomSerializer;
-}());
+}
 exports.CustomSerializer = CustomSerializer;
-var Serialization = /** @class */ (function () {
-    function Serialization() {
-    }
-    Serialization.RegisterType = function (type, reader, writer) {
+class Serialization {
+    static RegisterType(type, reader, writer) {
         Serialization._customSerializers[typeof type] = new CustomSerializer(reader, writer);
-    };
-    Serialization.SerializeEnum = function (obj) {
+    }
+    static SerializeEnum(obj) {
         if (!obj) {
             return new Uint8Array();
         }
         if (obj instanceof Uint8Array) {
             return obj;
         }
-        var writer = new Extensions_1.PBinaryWriter();
+        let writer = new Extensions_1.PBinaryWriter();
         writer.writeEnum(obj);
         return writer.toUint8Array();
-    };
-    Serialization.Serialize = function (obj) {
+    }
+    static Serialize(obj) {
         if (!obj) {
             return new Uint8Array();
         }
@@ -39,13 +36,12 @@ var Serialization = /** @class */ (function () {
             return obj;
         }
         //let jsonString = JSON.stringify(obj);
-        var writer = new Extensions_1.PBinaryWriter();
+        let writer = new Extensions_1.PBinaryWriter();
         this.SerializeObject(writer, obj, typeof obj);
         //let jsonAsUint8 = new TextEncoder().encode(jsonString);
         return writer.toUint8Array();
-    };
-    Serialization.SerializeObject = function (writer, obj, type) {
-        var _this = this;
+    }
+    static SerializeObject(writer, obj, type) {
         if (type == null || type == undefined) {
             type = typeof obj;
             this.SerializeObject(writer, obj, type);
@@ -59,9 +55,9 @@ var Serialization = /** @class */ (function () {
         /*if (typeof obj == "void") {
           return;
         }*/
-        var structType = Object.getPrototypeOf(obj).constructor.name;
-        var result = Object.apply(structType);
-        var localType = Object.apply(typeof type);
+        const structType = Object.getPrototypeOf(obj).constructor.name;
+        const result = Object.apply(structType);
+        let localType = Object.apply(typeof type);
         //console.log(localType);
         if (obj instanceof Boolean || typeof obj == "boolean") {
             writer.writeByte(obj ? 1 : 0);
@@ -94,8 +90,8 @@ var Serialization = /** @class */ (function () {
         }
         else if (Array.isArray(obj)) {
             writer.writeVarInt(obj.length);
-            obj.forEach(function (entry) {
-                _this.SerializeObject(writer, entry, typeof entry);
+            obj.forEach((entry) => {
+                this.SerializeObject(writer, entry, typeof entry);
             });
             return;
         }
@@ -109,14 +105,14 @@ var Serialization = /** @class */ (function () {
         else {
             // TODO: Add support for other types
             // Get the keys of the object
-            var fields = Object.keys(obj);
-            fields.forEach(function (field) {
-                var value = obj[field];
-                _this.SerializeObject(writer, value, typeof value);
+            const fields = Object.keys(obj);
+            fields.forEach((field) => {
+                let value = obj[field];
+                this.SerializeObject(writer, value, typeof value);
             });
         }
-    };
-    Serialization.Unserialize = function (bytesOrBytes, type) {
+    }
+    static Unserialize(bytesOrBytes, type) {
         if (bytesOrBytes instanceof Extensions_1.PBinaryReader) {
             return Serialization.UnserializeObject(bytesOrBytes, type);
         }
@@ -124,10 +120,10 @@ var Serialization = /** @class */ (function () {
             return null;
         }
         //let type = Object.prototype.propertyIsEnumerable(T);
-        var stream = new Extensions_1.PBinaryReader(bytesOrBytes);
+        let stream = new Extensions_1.PBinaryReader(bytesOrBytes);
         return Serialization.UnserializeObject(stream, type);
-    };
-    Serialization.UnserializeObject = function (reader, type) {
+    }
+    static UnserializeObject(reader, type) {
         if (Serialization._customSerializers.has(typeof type)) {
             var serializer = Serialization._customSerializers[typeof type];
             return serializer.Read(reader);
@@ -135,9 +131,9 @@ var Serialization = /** @class */ (function () {
         if (type == null || type == undefined) {
             return null;
         }
-        var localType; //: typeof type;
+        let localType; //: typeof type;
         if (type.name != undefined) {
-            var className = type.name;
+            let className = type.name;
             localType = Object.apply(className);
         }
         else {
@@ -162,14 +158,14 @@ var Serialization = /** @class */ (function () {
         }
         else if (typeof localType.UnserializeData === "function" &&
             typeof localType.SerializeData === "function") {
-            var obj = localType;
+            let obj = localType;
             obj.UnserializeData(reader);
             return obj;
         }
         else if (Array.isArray(type)) {
             var len = reader.readByte();
             var arr = new Array(len);
-            for (var i = 0; i < len; i++) {
+            for (let i = 0; i < len; i++) {
                 arr[i] = this.UnserializeObject(reader, type[i]);
             }
             return arr;
@@ -178,7 +174,7 @@ var Serialization = /** @class */ (function () {
             return reader.readByte();
         }
         else {
-            var fields = Object.keys(localType);
+            const fields = Object.keys(localType);
             /*console.log(fields);
             fields.forEach((field) => {
               localType[field] = this.UnserializeObject(
@@ -188,8 +184,7 @@ var Serialization = /** @class */ (function () {
             });
             return localType as T;*/
         }
-    };
-    Serialization._customSerializers = new Map(); //: { [key: string]: CustomSerializer };
-    return Serialization;
-}());
+    }
+}
 exports.Serialization = Serialization;
+Serialization._customSerializers = new Map(); //: { [key: string]: CustomSerializer };

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

@@ -0,0 +1 @@
+{"version":3,"file":"Stack.d.ts","sourceRoot":"","sources":["../../../src/core/types/Stack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,qBAAa,KAAK,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC;IAG5B,OAAO,CAAC,QAAQ;IAF5B,OAAO,CAAC,OAAO,CAAW;gBAEN,QAAQ,GAAE,MAAiB;IAE/C,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAOnB,GAAG,IAAI,CAAC,GAAG,SAAS;IAIpB,IAAI,IAAI,CAAC,GAAG,SAAS;IAIrB,IAAI,IAAI,MAAM;IAId,OAAO,IAAI,OAAO;IAIlB,OAAO,IAAI,CAAC,EAAE;IAId,KAAK,IAAI,IAAI;IAIb,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,OAAO;CAGlB"}

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

@@ -1,42 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Stack = void 0;
-var Stack = /** @class */ (function () {
-    function Stack(capacity) {
-        if (capacity === void 0) { capacity = Infinity; }
+class Stack {
+    constructor(capacity = Infinity) {
         this.capacity = capacity;
         this.storage = [];
     }
-    Stack.prototype.push = function (item) {
+    push(item) {
         if (this.size() === this.capacity) {
             throw Error("Stack has reached max capacity, you cannot add more items");
         }
         this.storage.push(item);
-    };
-    Stack.prototype.pop = function () {
+    }
+    pop() {
         return this.storage.pop();
-    };
-    Stack.prototype.peek = function () {
+    }
+    peek() {
         return this.storage[this.size() - 1];
-    };
-    Stack.prototype.size = function () {
+    }
+    size() {
         return this.storage.length;
-    };
-    Stack.prototype.isEmpty = function () {
+    }
+    isEmpty() {
         return this.size() === 0;
-    };
-    Stack.prototype.toArray = function () {
+    }
+    toArray() {
         return this.storage;
-    };
-    Stack.prototype.clear = function () {
+    }
+    clear() {
         this.storage = [];
-    };
-    Stack.prototype.toString = function () {
+    }
+    toString() {
         return this.storage.toString();
-    };
-    Stack.prototype.isFull = function () {
+    }
+    isFull() {
         return this.capacity === this.size();
-    };
-    return Stack;
-}());
+    }
+}
 exports.Stack = Stack;

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

@@ -0,0 +1 @@
+{"version":3,"file":"Timestamp.d.ts","sourceRoot":"","sources":["../../../src/core/types/Timestamp.ts"],"names":[],"mappings":"AAAA,qBAAa,SAAS;IACb,KAAK,EAAE,MAAM,CAAC;gBAET,KAAK,EAAE,MAAM;IAIlB,QAAQ;IAIR,cAAc,CAAC,MAAM,EAAE,MAAM;IAIpC,OAAc,GAAG,SAAc;IAC/B,OAAc,IAAI,YAAoB;IAE/B,SAAS,CAAC,KAAK,EAAE,SAAS;IAY1B,MAAM,CAAC,GAAG,EAAE,GAAG;IAQf,WAAW;IAIX,OAAO;WAIA,KAAK,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAIhC,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAInC,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAInC,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAItC,eAAe,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAI1C,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAI7C,QAAQ,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS;WAInC,UAAU,CAAC,KAAK,EAAE,MAAM;WAIxB,QAAQ,CAAC,IAAI,EAAE,IAAI;WAInB,WAAW,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM;WAGnC,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM;WAIxC,SAAS;WAET,WAAW;CAC1B"}

package/dist/core/types/Timestamp.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timestamp = void 0;
+class Timestamp {
+    constructor(value) {
+        this.value = value;
+    }
+    toString() {
+        return new Date(this.value * 1000).toUTCString();
+    }
+    toStringFormat(format) {
+        return new Date(this.value * 1000).toUTCString();
+    }
+    compareTo(other) {
+        if (other.value === this.value) {
+            return 0;
+        }
+        if (this.value < other.value) {
+            return -1;
+        }
+        return 1;
+    }
+    equals(obj) {
+        if (!(obj instanceof Timestamp)) {
+            return false;
+        }
+        return this.value === obj.value;
+    }
+    getHashCode() {
+        return this.value;
+    }
+    getSize() {
+        return 4;
+    }
+    static equal(A, B) {
+        return A.value === B.value;
+    }
+    static notEqual(A, B) {
+        return !(A.value === B.value);
+    }
+    static lessThan(A, B) {
+        return A.value < B.value;
+    }
+    static greaterThan(A, B) {
+        return A.value > B.value;
+    }
+    static lessThanOrEqual(A, B) {
+        return A.value <= B.value;
+    }
+    static greaterThanOrEqual(A, B) {
+        return A.value >= B.value;
+    }
+    static subtract(A, B) {
+        return A.value - B.value;
+    }
+    static fromNumber(ticks) {
+        return new Timestamp(ticks);
+    }
+    static fromDate(time) {
+        return new Timestamp(time.getTime() / 1000);
+    }
+    static addTimeSpan(A, B) {
+        return A.value + B;
+    }
+    static subtractTimeSpan(A, B) {
+        return A.value - B;
+    }
+    static Serialize() { }
+    static Unserialize() { }
+}
+exports.Timestamp = Timestamp;
+Timestamp.now = Date.now();
+Timestamp.null = new Timestamp(0);

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

@@ -1,3 +1,5 @@
+export * from "./Carbon";
+export * from "./CarbonSerialization";
 export * from "./Consensus";
 export * from "./Timestamp";
 export * from "./Stack";

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC"}

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

@@ -14,6 +14,8 @@ 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("./Carbon"), exports);
+__exportStar(require("./CarbonSerialization"), exports);
 __exportStar(require("./Consensus"), exports);
 __exportStar(require("./Timestamp"), exports);
 __exportStar(require("./Stack"), exports);

package/dist/core/utils/Hex.d.ts

@@ -0,0 +1,5 @@
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function bytesToHex(bytes: readonly number[]): string;
+export declare function bytesToHex(bytes: ArrayLike<number>): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+//# sourceMappingURL=Hex.d.ts.map

package/dist/core/utils/Hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hex.d.ts","sourceRoot":"","sources":["../../../src/core/utils/Hex.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAAC;AACtD,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAAC;AAC7D,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAc7D,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAYlD"}

package/dist/core/utils/Hex.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hexToBytes = exports.bytesToHex = void 0;
+const HEX_LUT = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+function bytesToHex(bytes) {
+    const len = bytes.length >>> 0;
+    let out = '';
+    for (let i = 0; i < len; i++) {
+        const v = Number(bytes[i]);
+        if (!Number.isInteger(v) || v < 0 || v > 255) {
+            throw new Error(`Invalid byte at index ${i}: ${v}`);
+        }
+        out += HEX_LUT[v];
+    }
+    return out;
+}
+exports.bytesToHex = bytesToHex;
+function hexToBytes(hex) {
+    if (hex.startsWith('0x')) {
+        hex = hex.slice(2);
+    }
+    if (hex.length % 2 !== 0) {
+        throw new Error(`Invalid hex string length ${hex.length} hex: ${hex}`);
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+exports.hexToBytes = hexToBytes;