refactor SigmaByteWriter and SigmaByteReader

Author: arobsn

packages/serializer/src/coders/sigmaByteReader.ts

@@ -18,7 +18,7 @@ export class SigmaByteReader {
     this.#cursor = 0;
   }
 
-  public readBoolean(): boolean {
+  public readBool(): boolean {
     return this.readByte() === 0x01;
   }
 
@@ -53,25 +53,24 @@ export class SigmaByteReader {
     return readVLQ(this);
   }
 
-  public readShort(): number {
-    return zigZag32.decode(readBigVLQ(this));
-  }
-
   public readI8(): number {
     const byte = this.readByte();
-
     return byte > MAX_I8 ? byte - (MAX_U8 + 1) : byte;
   }
 
-  public readInt(): number {
+  public readI16(): number {
+    return zigZag32.decode(readBigVLQ(this));
+  }
+
+  public readI32(): number {
     return zigZag32.decode(readBigVLQ(this));
   }
 
-  public readLong(): bigint {
+  public readI64(): bigint {
     return zigZag64.decode(readBigVLQ(this));
   }
 
-  public readBigInt(): bigint {
+  public readI256(): bigint {
     const len = readVLQ(this);
     return hexToBigInt(hex.encode(this.readBytes(len)));
   }

packages/serializer/src/coders/sigmaByteWriter.spec.ts

@@ -48,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]));
@@ -81,8 +81,8 @@ 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
       );
     }
@@ -95,23 +95,23 @@ describe("Sigma Writer", () => {
 
     // Short
     const i16Err = "out of range for a 16-bit integer";
-    expect(() => sigmaBuffer.writeShort(MIN_I16 - 1)).to.throw(i16Err);
-    expect(() => sigmaBuffer.writeShort(MAX_I16 + 1)).to.throw(i16Err);
+    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.writeInt(MIN_I32 - 1)).to.throw(i32Err);
-    expect(() => sigmaBuffer.writeInt(MAX_I32 + 1)).to.throw(i32Err);
+    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.writeLong(MIN_I64 - 1n)).to.throw(i64Err);
-    expect(() => sigmaBuffer.writeLong(MAX_I64 + 1n)).to.throw(i64Err);
+    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.writeBigInt(MIN_I256 - 1n)).to.throw(i256Err);
-    expect(() => sigmaBuffer.writeBigInt(MAX_I256 + 1n)).to.throw(i256Err);
+    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", () => {

packages/serializer/src/coders/sigmaByteWriter.ts

@@ -26,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;
@@ -40,7 +40,7 @@ export class SigmaByteWriter {
     return writeBigVLQ(this, value);
   }
 
-  public writeShort(value: number): SigmaByteWriter {
+  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`);
     }
@@ -49,22 +49,31 @@ export class SigmaByteWriter {
     return this;
   }
 
-  public writeInt(value: number): SigmaByteWriter {
+  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 {
+  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 {
     this.#bytes[this.#cursor++] = byte;
     return this;
@@ -101,15 +110,6 @@ export class SigmaByteWriter {
     return this;
   }
 
-  public writeBigInt(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 writeChecksum(length = 4, hashFn = blake2b256): SigmaByteWriter {
     const hash = hashFn(this.toBytes());
     return this.writeBytes(length ? hash.subarray(0, length) : hash);

packages/serializer/src/serializers/dataSerializer.ts

@@ -12,17 +12,17 @@ export const dataSerializer = {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
-          return writer.writeBoolean(data as boolean);
+          return writer.writeBool(data as boolean);
         case descriptors.byte.code:
           return writer.write(data as number);
         case descriptors.short.code:
-          return writer.writeShort(data as number);
+          return writer.writeI16(data as number);
         case descriptors.int.code:
-          return writer.writeInt(data as number);
+          return writer.writeI32(data as number);
         case descriptors.long.code:
-          return writer.writeLong(data as bigint);
+          return writer.writeI64(data as bigint);
         case descriptors.bigInt.code:
-          return writer.writeBigInt(data as bigint);
+          return writer.writeI256(data as bigint);
         case descriptors.groupElement.code:
           return writer.writeBytes(data as Uint8Array);
         case descriptors.sigmaProp.code: {
@@ -90,17 +90,17 @@ export const dataSerializer = {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
-          return reader.readBoolean();
+          return reader.readBool();
         case descriptors.byte.code:
           return reader.readI8();
         case descriptors.short.code:
-          return reader.readShort();
+          return reader.readI16();
         case descriptors.int.code:
-          return reader.readInt();
+          return reader.readI32();
         case descriptors.long.code:
-          return reader.readLong();
+          return reader.readI64();
         case descriptors.bigInt.code:
-          return reader.readBigInt();
+          return reader.readI256();
         case descriptors.groupElement.code:
           return reader.readBytes(GROUP_ELEMENT_LENGTH);
         case descriptors.sigmaProp.code: {