phantasma-sdk-ts 0.2.11 → 0.3.0

package/dist/cjs/core/types/Carbon/IntX.js

@@ -59,41 +59,36 @@ class IntX {
     // Deserialization (must match C# IntX.Read)
     read(r) {
         const header = r.read1();
-        if (header === 0) {
-            // Zero in compact format
-            this.isBig = false;
-            this.small = 0n;
-            return;
-        }
         const len = header & 0x3f;
-        const signBit = (header & 0x80) !== 0;
+        if (len < 8) {
+            throw new Error('invalid intx packing');
+        }
         if (len === 8) {
-            // Fast int64 path
-            this.isBig = false;
-            this.small = r.read8();
-            const valueIsNegative = this.small < 0;
-            if (valueIsNegative !== signBit) {
-                throw new Error('invalid intx sign header');
+            // IntX keeps the 8-byte fast path, but the header sign bit still refers to the reconstructed
+            // 256-bit value. If those signs disagree, this payload is not an int64; it is a wider IntX
+            // whose compact validator encoding happens to fit in 8 serialized bytes.
+            const value = r.read8();
+            const headerIsNegative = (header & 0x80) !== 0;
+            const valueIsNegative = value < 0n;
+            if (headerIsNegative === valueIsNegative) {
+                this.isBig = false;
+                this.small = value;
+                return;
             }
+            // Rebuild the full 256-bit word using the header sign bit as the omitted fill byte.
+            const rawBytes = new Uint8Array(8);
+            new DataView(rawBytes.buffer).setBigInt64(0, value, true);
+            const fill = headerIsNegative ? 0xff : 0x00;
+            const word = new Uint8Array(32);
+            word.set(rawBytes, 0);
+            word.fill(fill, rawBytes.length);
+            this.isBig = true;
+            this.big = (0, CarbonSerialization_js_1.twosComplementLEToBigInt)(word);
             return;
         }
-        // Compact BigInt path - we already consumed header, so read payload manually
-        // and convert LE two’s complement to bigint
-        if (len > 32) {
-            throw new Error('BigInt too big');
-        }
-        let bytes = r.readExactly(len);
-        // Ensure sign extension byte matches header sign
-        const inherentNegative = (bytes[bytes.length - 1] & 0x80) !== 0;
-        if (inherentNegative !== signBit) {
-            const ext = signBit ? 0xff : 0x00;
-            const tmp = new Uint8Array(bytes.length + 1);
-            tmp.set(bytes, 0);
-            tmp[tmp.length - 1] = ext;
-            bytes = tmp;
-        }
+        // Wider IntX values reuse the exact validator BigInt reader contract with the already-consumed header.
         this.isBig = true;
-        this.big = (0, CarbonSerialization_js_1.twosComplementLEToBigInt)(bytes);
+        this.big = r.readBigInt(header);
     }
     static read(r) {
         const v = new IntX();

package/dist/cjs/core/types/CarbonSerialization.js

@@ -4,8 +4,8 @@
  * - 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
+ *   header: 0 -> zero; otherwise lower 6 bits = payload length (0..32), bit7 = sign fill
+ *   payload: the low-order bytes of the validator/runtime 256-bit word after trailing fill trimming
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readBlob = exports.writeBlob = exports.twosComplementLEToBigInt = exports.bigIntToTwosComplementLE = exports.CarbonBinaryReader = exports.CarbonBinaryWriter = exports.Throw = void 0;
@@ -105,32 +105,25 @@ class CarbonBinaryWriter {
             t.write(this);
         }
     }
-    // BigInt compact format (<= 32 bytes)
+    // BigInt compact format (<= 32 payload bytes after validator trimming)
     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;
+        // Carbon wire bytes follow the validator/runtime contract, not JS BigInt's sign-safe minimal form.
+        // We therefore rebuild the full 256-bit two's-complement word first and only then trim high fill bytes.
+        const word = normalizeBigIntWord(bigIntToTwosComplementLE(value));
+        // The sign bit in the reconstructed 256-bit word determines which fill byte the validator would omit.
+        const fill = (word[31] & 0x80) !== 0 ? 0xff : 0x00;
+        // Validator trimming is intentionally simple: drop every trailing fill byte from the 256-bit word.
+        const length = computeBigIntSerializedLength(word, fill);
+        // The header stores the sign of the reconstructed 256-bit word, even when the payload is empty.
+        const header = (length & 0x3f) | (fill & 0x80);
         this.write1(header);
-        this.writeExactly(bytes, length);
+        if (length > 0) {
+            this.write(word.subarray(0, length));
+        }
     }
     writeArrayBigInt(items) {
         this.write4(items.length);
@@ -280,32 +273,27 @@ class CarbonBinaryReader {
         }
         return arr;
     }
-    // BigInt compact format
-    readBigInt() {
-        const header = this.read1();
+    // BigInt compact format.
+    // `preReadHeader` lets IntX reuse the exact same validator reader after consuming its own framing byte.
+    readBigInt(preReadHeader = -1) {
+        const header = preReadHeader < 0 ? this.read1() : preReadHeader & 0xff;
         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;
+        Throw.If((header & 0x40) !== 0 || length > 32, 'BigInt too big');
+        // The header sign bit defines the bytes that were omitted from the high side of the 256-bit word.
+        const fill = (header & 0x80) !== 0 ? 0xff : 0x00;
+        // Rebuild the full validator/runtime 256-bit word before decoding two's complement.
+        // This is what makes shortest negative forms like `0x80` decode to `-1` instead of `0`.
+        const word = new Uint8Array(32);
+        if (length > 0) {
+            word.set(this.readExactly(length), 0);
         }
-        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;
+        word.fill(fill, length);
+        // If the reconstructed sign bit disagrees with the header, the payload is not a valid validator word.
+        Throw.Assert((word[31] & 0x80) === (header & 0x80), 'non-standard BigInt header');
+        return twosComplementLEToBigInt(word);
     }
     readArrayBigInt() {
         const len = this.read4();
@@ -417,6 +405,45 @@ function bigIntToTwosComplementLE(value) {
     return Uint8Array.from(out);
 }
 exports.bigIntToTwosComplementLE = bigIntToTwosComplementLE;
+/**
+ * Rebuild the validator/runtime 256-bit word from a sign-safe minimal two's-complement payload.
+ *
+ * The Carbon protocol does not serialize JS/.NET style sign-guard bytes directly.
+ * Instead it reconstructs the full 256-bit two's-complement word first, then trims all high fill bytes.
+ * This helper performs the "reconstruct the word" half of that contract.
+ */
+function normalizeBigIntWord(bytes) {
+    if (bytes.length === 0) {
+        return new Uint8Array(32);
+    }
+    const sourceFill = (bytes[bytes.length - 1] & 0x80) !== 0 ? 0xff : 0x00;
+    let normalized = bytes;
+    if (normalized.length > 32) {
+        // Any bytes above 256 bits must be pure sign extension. If not, the value does not fit Carbon Int256.
+        for (let i = 32; i < normalized.length; i++) {
+            Throw.Assert(normalized[i] === sourceFill, 'BigInt overflow');
+        }
+        normalized = normalized.slice(0, 32);
+    }
+    const word = new Uint8Array(32);
+    word.set(normalized, 0);
+    // Shorter sign-safe encodings are expanded back to the full 256-bit two's-complement word.
+    word.fill(sourceFill, normalized.length);
+    return word;
+}
+/**
+ * Compute the validator/runtime payload length for a reconstructed 256-bit word.
+ *
+ * The validator does not keep an extra guard byte once the word is expanded.
+ * It simply removes every contiguous high fill byte from the full word.
+ */
+function computeBigIntSerializedLength(word, fill) {
+    let length = word.length;
+    while (length > 0 && word[length - 1] === fill) {
+        length--;
+    }
+    return length;
+}
 /** Convert little-endian two's complement bytes to bigint */
 function twosComplementLEToBigInt(bytes) {
     if (bytes.length === 0)

package/dist/esm/core/types/Carbon/IntX.js

@@ -56,41 +56,36 @@ export class IntX {
     // Deserialization (must match C# IntX.Read)
     read(r) {
         const header = r.read1();
-        if (header === 0) {
-            // Zero in compact format
-            this.isBig = false;
-            this.small = 0n;
-            return;
-        }
         const len = header & 0x3f;
-        const signBit = (header & 0x80) !== 0;
+        if (len < 8) {
+            throw new Error('invalid intx packing');
+        }
         if (len === 8) {
-            // Fast int64 path
-            this.isBig = false;
-            this.small = r.read8();
-            const valueIsNegative = this.small < 0;
-            if (valueIsNegative !== signBit) {
-                throw new Error('invalid intx sign header');
+            // IntX keeps the 8-byte fast path, but the header sign bit still refers to the reconstructed
+            // 256-bit value. If those signs disagree, this payload is not an int64; it is a wider IntX
+            // whose compact validator encoding happens to fit in 8 serialized bytes.
+            const value = r.read8();
+            const headerIsNegative = (header & 0x80) !== 0;
+            const valueIsNegative = value < 0n;
+            if (headerIsNegative === valueIsNegative) {
+                this.isBig = false;
+                this.small = value;
+                return;
             }
+            // Rebuild the full 256-bit word using the header sign bit as the omitted fill byte.
+            const rawBytes = new Uint8Array(8);
+            new DataView(rawBytes.buffer).setBigInt64(0, value, true);
+            const fill = headerIsNegative ? 0xff : 0x00;
+            const word = new Uint8Array(32);
+            word.set(rawBytes, 0);
+            word.fill(fill, rawBytes.length);
+            this.isBig = true;
+            this.big = twosComplementLEToBigInt(word);
             return;
         }
-        // Compact BigInt path - we already consumed header, so read payload manually
-        // and convert LE two’s complement to bigint
-        if (len > 32) {
-            throw new Error('BigInt too big');
-        }
-        let bytes = r.readExactly(len);
-        // Ensure sign extension byte matches header sign
-        const inherentNegative = (bytes[bytes.length - 1] & 0x80) !== 0;
-        if (inherentNegative !== signBit) {
-            const ext = signBit ? 0xff : 0x00;
-            const tmp = new Uint8Array(bytes.length + 1);
-            tmp.set(bytes, 0);
-            tmp[tmp.length - 1] = ext;
-            bytes = tmp;
-        }
+        // Wider IntX values reuse the exact validator BigInt reader contract with the already-consumed header.
         this.isBig = true;
-        this.big = twosComplementLEToBigInt(bytes);
+        this.big = r.readBigInt(header);
     }
     static read(r) {
         const v = new IntX();

package/dist/esm/core/types/CarbonSerialization.js

@@ -3,8 +3,8 @@
  * - 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
+ *   header: 0 -> zero; otherwise lower 6 bits = payload length (0..32), bit7 = sign fill
+ *   payload: the low-order bytes of the validator/runtime 256-bit word after trailing fill trimming
  */
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
@@ -101,32 +101,25 @@ export class CarbonBinaryWriter {
             t.write(this);
         }
     }
-    // BigInt compact format (<= 32 bytes)
+    // BigInt compact format (<= 32 payload bytes after validator trimming)
     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;
+        // Carbon wire bytes follow the validator/runtime contract, not JS BigInt's sign-safe minimal form.
+        // We therefore rebuild the full 256-bit two's-complement word first and only then trim high fill bytes.
+        const word = normalizeBigIntWord(bigIntToTwosComplementLE(value));
+        // The sign bit in the reconstructed 256-bit word determines which fill byte the validator would omit.
+        const fill = (word[31] & 0x80) !== 0 ? 0xff : 0x00;
+        // Validator trimming is intentionally simple: drop every trailing fill byte from the 256-bit word.
+        const length = computeBigIntSerializedLength(word, fill);
+        // The header stores the sign of the reconstructed 256-bit word, even when the payload is empty.
+        const header = (length & 0x3f) | (fill & 0x80);
         this.write1(header);
-        this.writeExactly(bytes, length);
+        if (length > 0) {
+            this.write(word.subarray(0, length));
+        }
     }
     writeArrayBigInt(items) {
         this.write4(items.length);
@@ -275,32 +268,27 @@ export class CarbonBinaryReader {
         }
         return arr;
     }
-    // BigInt compact format
-    readBigInt() {
-        const header = this.read1();
+    // BigInt compact format.
+    // `preReadHeader` lets IntX reuse the exact same validator reader after consuming its own framing byte.
+    readBigInt(preReadHeader = -1) {
+        const header = preReadHeader < 0 ? this.read1() : preReadHeader & 0xff;
         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;
+        Throw.If((header & 0x40) !== 0 || length > 32, 'BigInt too big');
+        // The header sign bit defines the bytes that were omitted from the high side of the 256-bit word.
+        const fill = (header & 0x80) !== 0 ? 0xff : 0x00;
+        // Rebuild the full validator/runtime 256-bit word before decoding two's complement.
+        // This is what makes shortest negative forms like `0x80` decode to `-1` instead of `0`.
+        const word = new Uint8Array(32);
+        if (length > 0) {
+            word.set(this.readExactly(length), 0);
         }
-        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;
+        word.fill(fill, length);
+        // If the reconstructed sign bit disagrees with the header, the payload is not a valid validator word.
+        Throw.Assert((word[31] & 0x80) === (header & 0x80), 'non-standard BigInt header');
+        return twosComplementLEToBigInt(word);
     }
     readArrayBigInt() {
         const len = this.read4();
@@ -410,6 +398,45 @@ export function bigIntToTwosComplementLE(value) {
     }
     return Uint8Array.from(out);
 }
+/**
+ * Rebuild the validator/runtime 256-bit word from a sign-safe minimal two's-complement payload.
+ *
+ * The Carbon protocol does not serialize JS/.NET style sign-guard bytes directly.
+ * Instead it reconstructs the full 256-bit two's-complement word first, then trims all high fill bytes.
+ * This helper performs the "reconstruct the word" half of that contract.
+ */
+function normalizeBigIntWord(bytes) {
+    if (bytes.length === 0) {
+        return new Uint8Array(32);
+    }
+    const sourceFill = (bytes[bytes.length - 1] & 0x80) !== 0 ? 0xff : 0x00;
+    let normalized = bytes;
+    if (normalized.length > 32) {
+        // Any bytes above 256 bits must be pure sign extension. If not, the value does not fit Carbon Int256.
+        for (let i = 32; i < normalized.length; i++) {
+            Throw.Assert(normalized[i] === sourceFill, 'BigInt overflow');
+        }
+        normalized = normalized.slice(0, 32);
+    }
+    const word = new Uint8Array(32);
+    word.set(normalized, 0);
+    // Shorter sign-safe encodings are expanded back to the full 256-bit two's-complement word.
+    word.fill(sourceFill, normalized.length);
+    return word;
+}
+/**
+ * Compute the validator/runtime payload length for a reconstructed 256-bit word.
+ *
+ * The validator does not keep an extra guard byte once the word is expanded.
+ * It simply removes every contiguous high fill byte from the full word.
+ */
+function computeBigIntSerializedLength(word, fill) {
+    let length = word.length;
+    while (length > 0 && word[length - 1] === fill) {
+        length--;
+    }
+    return length;
+}
 /** Convert little-endian two's complement bytes to bigint */
 export function twosComplementLEToBigInt(bytes) {
     if (bytes.length === 0)

package/dist/types/core/types/Carbon/IntX.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntX.d.ts","sourceRoot":"","sources":["../../../../../src/core/types/Carbon/IntX.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AACrE,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,IAAK,YAAW,WAAW;IACtC,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,KAAK,CAAS;IAGtB,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOxC,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAKlB,WAAW,IAAI,OAAO;IAQtB,KAAK,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAwBlC,IAAI,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI;IA4CjC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI;CAKzC"}
+{"version":3,"file":"IntX.d.ts","sourceRoot":"","sources":["../../../../../src/core/types/Carbon/IntX.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AACrE,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,2BAA2B,CAAC;AAEnC,qBAAa,IAAK,YAAW,WAAW;IACtC,OAAO,CAAC,GAAG,CAAc;IACzB,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,KAAK,CAAS;IAGtB,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAOlC,MAAM,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAOxC,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAKlB,WAAW,IAAI,OAAO;IAQtB,KAAK,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAwBlC,IAAI,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI;IAuCjC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,kBAAkB,GAAG,IAAI;CAKzC"}

package/dist/types/core/types/CarbonSerialization.d.ts

@@ -3,8 +3,8 @@
  * - 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
+ *   header: 0 -> zero; otherwise lower 6 bits = payload length (0..32), bit7 = sign fill
+ *   payload: the low-order bytes of the validator/runtime 256-bit word after trailing fill trimming
  */
 import { ICarbonBlob } from '../interfaces/Carbon/ICarbonBlob.js';
 import { Bytes16 } from './Carbon/Bytes16.js';
@@ -33,7 +33,6 @@ export declare class CarbonBinaryWriter {
     writeBlob<T extends ICarbonBlob>(data: T): void;
     writeArrayBlob<T extends ICarbonBlob>(arr: T[]): void;
     writeBigInt(value: bigint): void;
-    private writeBigIntRaw;
     writeArrayBigInt(items: bigint[]): void;
     writeSz(s: string): void;
     writeArraySz(arr: string[]): void;
@@ -67,7 +66,7 @@ export declare class CarbonBinaryReader {
     readInto64(out: Bytes64): void;
     readBlob<T extends ICarbonBlob>(ctor: new () => T): T;
     readArrayBlob<T extends ICarbonBlob>(ctor: new () => T): T[];
-    readBigInt(): bigint;
+    readBigInt(preReadHeader?: number): bigint;
     readArrayBigInt(): bigint[];
     readSz(): string;
     readArraySz(): string[];

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phantasma-sdk-ts",
-  "version": "0.2.11",
+  "version": "0.3.0",
   "description": "Typescript SDK for interacting with the Phantasma Chain",
   "author": "Phantasma Team",
   "main": "dist/cjs/index.js",
@@ -64,8 +64,8 @@
   },
   "homepage": "https://github.com/phantasma-io/phantasma-ts#readme",
   "dependencies": {
-    "@ledgerhq/hw-transport-node-hid": "^6.29.13",
-    "@ledgerhq/hw-transport-webusb": "^6.29.12",
+    "@ledgerhq/hw-transport-node-hid": "^6.31.0",
+    "@ledgerhq/hw-transport-webusb": "^6.31.0",
     "big-integer": "^1.6.52",
     "bip32": "^3.1.0",
     "bip39": "^3.1.0",
@@ -84,13 +84,13 @@
     "@types/jest": "^30.0.0",
     "@types/wif": "^2.0.5",
     "browserify": "^17.0.1",
-    "eslint": "^9.36.0",
+    "eslint": "^9.39.4",
     "eslint-config-prettier": "^10.1.8",
-    "globals": "^16.4.0",
-    "jest": "^30.2.0",
-    "prettier": "^3.6.2",
-    "ts-jest": "^29.4.4",
+    "globals": "^16.5.0",
+    "jest": "^30.3.0",
+    "prettier": "^3.8.1",
+    "ts-jest": "^29.4.6",
     "typescript": "^4.9.5",
-    "typescript-eslint": "^8.46.1"
+    "typescript-eslint": "^8.57.0"
   }
 }