Merge pull request #164 from fleet-sdk/arobsn/i163

arobsn · web-flow · commit c18b8e5ef50e · 2025-01-24T10:50:57.000-03:00
Fix `SInt` serialization
diff --git a/.changeset/angry-pumpkins-itch.md b/.changeset/angry-pumpkins-itch.md
@@ -0,0 +1,5 @@
+---
+"@fleet-sdk/serializer": patch
+---
+
+Fix `ZigZag` encoding for 32-big integers
diff --git a/.changeset/perfect-cycles-battle.md b/.changeset/perfect-cycles-battle.md
@@ -0,0 +1,5 @@
+---
+"@fleet-sdk/serializer": patch
+---
+
+Fix signed `SByte` parsing
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -2,5 +2,8 @@
   "explorer.fileNesting.enabled": true,
   "explorer.fileNesting.patterns": {
     "*.ts": "${capture}.*.ts, ${capture}.js"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "biomejs.biome"
   }
 }
diff --git a/packages/serializer/src/_test-vectors/constantVectors.ts b/packages/serializer/src/_test-vectors/constantVectors.ts
@@ -33,13 +33,17 @@ export const boolVectors: ConstantTestVector<boolean>[] = [
 export const byteVectors: ConstantTestVector<number>[] = [
   { hex: "0201", value: 1 },
   { hex: "0202", value: 2 },
-  { hex: "024c", value: 76 }
+  { hex: "024c", value: 76 },
+  { hex: "027f", value: 127 }, // max i8
+  { hex: "0280", value: -128 } // min i8
 ];
 
 export const shortVectors: ConstantTestVector<number>[] = [
   { hex: "0302", value: 1 },
   { hex: "0303", value: -2 },
-  { hex: "0322", value: 17 }
+  { hex: "0322", value: 17 },
+  { hex: "03feff03", value: 32767 }, // max i16
+  { hex: "03ffff03", value: -32768 } // min i16
 ];
 
 export const intVectors: ConstantTestVector<number>[] = [
@@ -51,7 +55,9 @@ export const intVectors: ConstantTestVector<number>[] = [
   { hex: "042d", value: -23 },
   { hex: "04800f", value: 960 },
   { hex: "04808008", value: 65536 },
-  { hex: "04808023", value: 286720 }
+  { hex: "04808023", value: 286720 },
+  { hex: "04feffffffffffffffff01", value: 2147483647 }, // max i32
+  { hex: "04ffffffffffffffffff01", value: -2147483648 } // min i32
 ];
 
 export const longVectors: ConstantTestVector<bigint | string>[] = [
@@ -75,7 +81,9 @@ export const longVectors: ConstantTestVector<bigint | string>[] = [
   { hex: "0580809d80d0bf9901", value: 337543627513856n },
   { hex: "058080cba684a68201", value: 286526435581952n },
   { hex: "058080b4ccd4dfc603", value: 1000000000000000n },
-  { hex: "058080a0f6f4acdbe01b", value: 1000000000000000000n }
+  { hex: "058080a0f6f4acdbe01b", value: 1000000000000000000n },
+  { hex: "05feffffffffffffffff01", value: 9223372036854775807n }, // max i64
+  { hex: "05ffffffffffffffffff01", value: -9223372036854775808n } // min i64
 ];
 
 export const bigintVectors: ConstantTestVector<string>[] = [
diff --git a/packages/serializer/src/coders/numRanges.ts b/packages/serializer/src/coders/numRanges.ts
@@ -0,0 +1,22 @@
+export const MIN_U8 = 0x00;
+export const MAX_U8 = 0xff;
+
+export const MIN_I8 = -0x80;
+export const MAX_I8 = 0x7f;
+
+export const MIN_I16 = -0x8000;
+export const MAX_I16 = 0x7fff;
+
+export const MIN_I32 = -0x80000000;
+export const MAX_I32 = 0x7fffffff;
+
+export const MIN_I64 = -BigInt("0x8000000000000000");
+export const MAX_I64 = BigInt("0x7fffffffffffffff");
+
+export const MIN_I256 = -BigInt(
+  "0x8000000000000000000000000000000000000000000000000000000000000000"
+);
+
+export const MAX_I256 = BigInt(
+  "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+);
diff --git a/packages/serializer/src/coders/sigmaByteReader.ts b/packages/serializer/src/coders/sigmaByteReader.ts
@@ -2,7 +2,8 @@ import { isEmpty } from "@fleet-sdk/common";
 import { type ByteInput, ensureBytes, hex } from "@fleet-sdk/crypto";
 import { hexToBigInt } from "./bigint";
 import { readBigVLQ, readVLQ } from "./vlq";
-import { zigZagDecode, zigZagDecodeBigInt } from "./zigZag";
+import { zigZag32, zigZag64 } from "./zigZag";
+import { MAX_I8, MAX_U8 } from "./numRanges";
 
 export class SigmaByteReader {
   readonly #bytes: Uint8Array;
@@ -17,7 +18,7 @@ export class SigmaByteReader {
     this.#cursor = 0;
   }
 
-  public readBoolean(): boolean {
+  public readBool(): boolean {
     return this.readByte() === 0x01;
   }
 
@@ -52,19 +53,24 @@ export class SigmaByteReader {
     return readVLQ(this);
   }
 
-  public readShort(): number {
-    return Number(zigZagDecode(readVLQ(this)));
+  public readI8(): number {
+    const byte = this.readByte();
+    return byte > MAX_I8 ? byte - (MAX_U8 + 1) : byte;
   }
 
-  public readInt(): number {
-    return Number(this.readLong());
+  public readI16(): number {
+    return zigZag32.decode(readBigVLQ(this));
   }
 
-  public readLong(): bigint {
-    return zigZagDecodeBigInt(readBigVLQ(this));
+  public readI32(): number {
+    return zigZag32.decode(readBigVLQ(this));
   }
 
-  public readBigInt(): bigint {
+  public readI64(): bigint {
+    return zigZag64.decode(readBigVLQ(this));
+  }
+
+  public readI256(): bigint {
     const len = readVLQ(this);
     return hexToBigInt(hex.encode(this.readBytes(len)));
   }
diff --git a/packages/serializer/src/coders/sigmaByteWriter.spec.ts b/packages/serializer/src/coders/sigmaByteWriter.spec.ts
@@ -3,6 +3,16 @@ import { blake2b256, hex, sha256 } from "@fleet-sdk/crypto";
 import { describe, expect, it } from "vitest";
 import { MAX_CONSTANT_LENGTH } from "../sigmaConstant";
 import { SigmaByteWriter } from "./sigmaByteWriter";
+import {
+  MIN_I16,
+  MAX_I16,
+  MIN_I32,
+  MAX_I32,
+  MIN_I64,
+  MAX_I64,
+  MIN_I256,
+  MAX_I256
+} from "./numRanges";
 
 describe("Sigma Writer", () => {
   it("Should put a single byte at time", () => {
@@ -38,8 +48,8 @@ describe("Sigma Writer", () => {
 
   it("Should put a boolean", () => {
     const sigmaBuffer = new SigmaByteWriter(MAX_CONSTANT_LENGTH);
-    sigmaBuffer.writeBoolean(true);
-    sigmaBuffer.writeBoolean(false);
+    sigmaBuffer.writeBool(true);
+    sigmaBuffer.writeBool(false);
 
     expect(sigmaBuffer).toHaveLength(2);
     expect(sigmaBuffer.toBytes()).toEqual(Uint8Array.from([0x01, 0x00]));
@@ -71,15 +81,39 @@ describe("Sigma Writer", () => {
 
     const all = new SigmaByteWriter(MAX_CONSTANT_LENGTH);
     for (const tv of testVectors) {
-      all.writeShort(tv.int);
-      expect(new SigmaByteWriter(tv.hex.length).writeShort(tv.int).encode(hex)).toBe(
+      all.writeI16(tv.int);
+      expect(new SigmaByteWriter(tv.hex.length).writeI16(tv.int).encode(hex)).toBe(
         tv.hex
       );
     }
 
     expect(all.encode(hex)).toEqual(testVectors.map((x) => x.hex).join(""));
   });
 
+  it("Should fail for out of range values", () => {
+    const sigmaBuffer = new SigmaByteWriter(MAX_CONSTANT_LENGTH);
+
+    // Short
+    const i16Err = "out of range for a 16-bit integer";
+    expect(() => sigmaBuffer.writeI16(MIN_I16 - 1)).to.throw(i16Err);
+    expect(() => sigmaBuffer.writeI16(MAX_I16 + 1)).to.throw(i16Err);
+
+    // Int
+    const i32Err = "out of range for a 32-bit integer";
+    expect(() => sigmaBuffer.writeI32(MIN_I32 - 1)).to.throw(i32Err);
+    expect(() => sigmaBuffer.writeI32(MAX_I32 + 1)).to.throw(i32Err);
+
+    // Long
+    const i64Err = "out of range for a 64-bit integer";
+    expect(() => sigmaBuffer.writeI64(MIN_I64 - 1n)).to.throw(i64Err);
+    expect(() => sigmaBuffer.writeI64(MAX_I64 + 1n)).to.throw(i64Err);
+
+    // BigInt
+    const i256Err = "out of range for a 256-bit integer";
+    expect(() => sigmaBuffer.writeI256(MIN_I256 - 1n)).to.throw(i256Err);
+    expect(() => sigmaBuffer.writeI256(MAX_I256 + 1n)).to.throw(i256Err);
+  });
+
   it("Should write a checksum based on the current stream content", () => {
     const bytes = Uint8Array.from([0x00, 0x00, 0x21, 0xff, 0x15, 0x0c]);
     const blakeHash = blake2b256(bytes);
diff --git a/packages/serializer/src/coders/sigmaByteWriter.ts b/packages/serializer/src/coders/sigmaByteWriter.ts
@@ -1,7 +1,17 @@
 import { blake2b256, type Coder, hex } from "@fleet-sdk/crypto";
 import { bigIntToHex } from "./bigint";
 import { writeBigVLQ, writeVLQ } from "./vlq";
-import { zigZagEncode, zigZagEncodeBigInt } from "./zigZag";
+import { zigZag32, zigZag64 } from "./zigZag";
+import {
+  MIN_I16,
+  MAX_I16,
+  MIN_I32,
+  MAX_I32,
+  MIN_I64,
+  MAX_I64,
+  MIN_I256,
+  MAX_I256
+} from "./numRanges";
 
 export class SigmaByteWriter {
   readonly #bytes: Uint8Array;
@@ -16,7 +26,7 @@ export class SigmaByteWriter {
     this.#cursor = 0;
   }
 
-  public writeBoolean(value: boolean): SigmaByteWriter {
+  public writeBool(value: boolean): SigmaByteWriter {
     this.write(value === true ? 0x01 : 0x00);
 
     return this;
@@ -30,19 +40,38 @@ export class SigmaByteWriter {
     return writeBigVLQ(this, value);
   }
 
-  public writeShort(value: number): SigmaByteWriter {
-    this.writeVLQ(zigZagEncode(value));
+  public writeI16(value: number): SigmaByteWriter {
+    if (value < MIN_I16 || value > MAX_I16) {
+      throw new RangeError(`Value ${value} is out of range for a 16-bit integer`);
+    }
+
+    this.writeBigVLQ(zigZag32.encode(value));
     return this;
   }
 
-  public writeInt(value: number): SigmaByteWriter {
-    this.writeLong(BigInt(value));
-    return this;
+  public writeI32(value: number): SigmaByteWriter {
+    if (value < MIN_I32 || value > MAX_I32) {
+      throw new RangeError(`Value ${value} is out of range for a 32-bit integer`);
+    }
+
+    return this.writeBigVLQ(zigZag32.encode(value));
   }
 
-  public writeLong(value: bigint): SigmaByteWriter {
-    this.writeBigVLQ(zigZagEncodeBigInt(value));
-    return this;
+  public writeI64(value: bigint): SigmaByteWriter {
+    if (value < MIN_I64 || value > MAX_I64) {
+      throw new RangeError(`Value ${value} is out of range for a 64-bit integer`);
+    }
+
+    return this.writeBigVLQ(zigZag64.encode(value));
+  }
+
+  public writeI256(value: bigint): SigmaByteWriter {
+    if (value < MIN_I256 || value > MAX_I256) {
+      throw new RangeError(`Value ${value} is out of range for a 256-bit integer`);
+    }
+
+    const hex = bigIntToHex(value);
+    return this.writeVLQ(hex.length / 2).writeHex(hex);
   }
 
   public write(byte: number): SigmaByteWriter {
@@ -81,11 +110,6 @@ export class SigmaByteWriter {
     return this;
   }
 
-  public writeBigInt(value: bigint): SigmaByteWriter {
-    const hex = bigIntToHex(value);
-    return this.writeVLQ(hex.length / 2).writeHex(hex);
-  }
-
   public writeChecksum(length = 4, hashFn = blake2b256): SigmaByteWriter {
     const hash = hashFn(this.toBytes());
     return this.writeBytes(length ? hash.subarray(0, length) : hash);
diff --git a/packages/serializer/src/coders/zigZag.spec.ts b/packages/serializer/src/coders/zigZag.spec.ts
diff --git a/packages/serializer/src/coders/zigZag.ts b/packages/serializer/src/coders/zigZag.ts
diff --git a/packages/serializer/src/serializers/dataSerializer.ts b/packages/serializer/src/serializers/dataSerializer.ts
diff --git a/packages/serializer/src/sigmaConstant.spec.ts b/packages/serializer/src/sigmaConstant.spec.ts

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"@fleet-sdk/serializer": patch
 +---
++
 +Fix `ZigZag` encoding for 32-big integers
Original file line number	Diff line number	Diff line change
`@@ -2,5 +2,8 @@`
`2`	`2`	`"explorer.fileNesting.enabled": true,`
`3`	`3`	`"explorer.fileNesting.patterns": {`
`4`	`4`	`".ts": "${capture}..ts, ${capture}.js"`
	`5`	`+ },`
	`6`	`+ "[typescript]": {`
	`7`	`+ "editor.defaultFormatter": "biomejs.biome"`
`5`	`8`	`}`
`6`	`9`	`}`