@fleet-sdk/serializer 0.7.0 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @fleet-sdk/serializer
 
+## 0.8.2
+
+### Patch Changes
+
+- 66d6fc9: Fix `ZigZag` encoding for 32-bit integers
+- 1c8541a: Fix signed `SByte` parsing
+- Updated dependencies [9a244b5]
+- Updated dependencies [1b07c4a]
+  - @fleet-sdk/crypto@0.8.2
+
+## 0.8.0
+
+### Patch Changes
+
+- a47a5fd: Fix types for nested `SColl[SBytes]` creation.
+- Updated dependencies [36adc61]
+- Updated dependencies [b2ce7aa]
+  - @fleet-sdk/common@0.8.0
+  - @fleet-sdk/crypto@0.8.0
+
 ## 0.7.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -5,32 +5,33 @@ declare class SigmaByteReader {
     #private;
     get isEmpty(): boolean;
     constructor(bytes: ByteInput$1);
-    readBoolean(): boolean;
+    readBool(): boolean;
     readBits(length: number): ArrayLike<boolean>;
     readByte(): number;
     readBytes(length: number): Uint8Array;
     readVlq(): number;
-    readShort(): number;
-    readInt(): number;
-    readLong(): bigint;
-    readBigInt(): bigint;
+    readI8(): number;
+    readI16(): number;
+    readI32(): number;
+    readI64(): bigint;
+    readI256(): bigint;
 }
 
 declare class SigmaByteWriter {
     #private;
     get length(): number;
     constructor(length: number);
-    writeBoolean(value: boolean): SigmaByteWriter;
+    writeBool(value: boolean): SigmaByteWriter;
     writeVLQ(value: number): SigmaByteWriter;
     writeBigVLQ(value: bigint): SigmaByteWriter;
-    writeShort(value: number): SigmaByteWriter;
-    writeInt(value: number): SigmaByteWriter;
-    writeLong(value: bigint): SigmaByteWriter;
+    writeI16(value: number): SigmaByteWriter;
+    writeI32(value: number): SigmaByteWriter;
+    writeI64(value: bigint): SigmaByteWriter;
+    writeI256(value: bigint): SigmaByteWriter;
     write(byte: number): SigmaByteWriter;
     writeBytes(bytes: ArrayLike<number>): SigmaByteWriter;
     writeHex(bytesHex: string): SigmaByteWriter;
     writeBits(bits: ArrayLike<boolean>): SigmaByteWriter;
-    writeBigInt(value: bigint): SigmaByteWriter;
     writeChecksum(length?: number, hashFn?: typeof blake2b256): SigmaByteWriter;
     encode<T>(coder: Coder<Uint8Array, T>): T;
     toBytes(): Uint8Array;
@@ -94,13 +95,14 @@ declare const SShort: SProxy<SShortType, number, number>;
 declare const SInt: SProxy<SIntType, number, number>;
 declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
 declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
-declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array>;
-declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array, SType<unknown, unknown>>, SConstant<Uint8Array, SType<unknown, unknown>>>;
+declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array<ArrayBufferLike>>;
+declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>>;
 type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
 declare const SUnit: SUnit;
 type SColl = {
-    <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;
     <D, T extends SByteType>(type: SConstructor<D, T>, elements: ByteInput | D[]): SConstant<Uint8Array, T>;
+    <D, T extends SByteType>(type: SConstructor<D, T>, elements: ByteInput[]): SConstant<Uint8Array[], T>;
+    <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;
     <D, T extends SType>(type: SConstructor<D, T>, elements: D[]): SConstant<D[], T>;
 };
 declare const SColl: SColl;

package/dist/index.d.ts

@@ -5,32 +5,33 @@ declare class SigmaByteReader {
     #private;
     get isEmpty(): boolean;
     constructor(bytes: ByteInput$1);
-    readBoolean(): boolean;
+    readBool(): boolean;
     readBits(length: number): ArrayLike<boolean>;
     readByte(): number;
     readBytes(length: number): Uint8Array;
     readVlq(): number;
-    readShort(): number;
-    readInt(): number;
-    readLong(): bigint;
-    readBigInt(): bigint;
+    readI8(): number;
+    readI16(): number;
+    readI32(): number;
+    readI64(): bigint;
+    readI256(): bigint;
 }
 
 declare class SigmaByteWriter {
     #private;
     get length(): number;
     constructor(length: number);
-    writeBoolean(value: boolean): SigmaByteWriter;
+    writeBool(value: boolean): SigmaByteWriter;
     writeVLQ(value: number): SigmaByteWriter;
     writeBigVLQ(value: bigint): SigmaByteWriter;
-    writeShort(value: number): SigmaByteWriter;
-    writeInt(value: number): SigmaByteWriter;
-    writeLong(value: bigint): SigmaByteWriter;
+    writeI16(value: number): SigmaByteWriter;
+    writeI32(value: number): SigmaByteWriter;
+    writeI64(value: bigint): SigmaByteWriter;
+    writeI256(value: bigint): SigmaByteWriter;
     write(byte: number): SigmaByteWriter;
     writeBytes(bytes: ArrayLike<number>): SigmaByteWriter;
     writeHex(bytesHex: string): SigmaByteWriter;
     writeBits(bits: ArrayLike<boolean>): SigmaByteWriter;
-    writeBigInt(value: bigint): SigmaByteWriter;
     writeChecksum(length?: number, hashFn?: typeof blake2b256): SigmaByteWriter;
     encode<T>(coder: Coder<Uint8Array, T>): T;
     toBytes(): Uint8Array;
@@ -94,13 +95,14 @@ declare const SShort: SProxy<SShortType, number, number>;
 declare const SInt: SProxy<SIntType, number, number>;
 declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
 declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
-declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array>;
-declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array, SType<unknown, unknown>>, SConstant<Uint8Array, SType<unknown, unknown>>>;
+declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array<ArrayBufferLike>>;
+declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>>;
 type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
 declare const SUnit: SUnit;
 type SColl = {
-    <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;
     <D, T extends SByteType>(type: SConstructor<D, T>, elements: ByteInput | D[]): SConstant<Uint8Array, T>;
+    <D, T extends SByteType>(type: SConstructor<D, T>, elements: ByteInput[]): SConstant<Uint8Array[], T>;
+    <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;
     <D, T extends SType>(type: SConstructor<D, T>, elements: D[]): SConstant<D[], T>;
 };
 declare const SColl: SColl;

package/dist/index.js

@@ -105,18 +105,45 @@ function estimateVLQSize(value) {
   } while (val > common._0n);
   return size;
 }
-function zigZagEncode(input) {
-  return input << 1 ^ input >> 63;
-}
-function zigZagDecode(input) {
-  return input >> 1 ^ -(input & 1);
-}
-function zigZagEncodeBigInt(input) {
-  return input << common._1n ^ input >> common._63n;
-}
-function zigZagDecodeBigInt(input) {
-  return input >> common._1n ^ -(input & common._1n);
-}
+var _31n = BigInt(31);
+var u64 = (v) => BigInt.asUintN(64, v);
+var i64 = (v) => BigInt.asIntN(64, v);
+var i32 = (v) => BigInt.asIntN(32, v);
+var u32 = (v) => BigInt.asUintN(32, v);
+var zigZag32 = {
+  encode: (input) => {
+    const v = i32(BigInt(input));
+    return u64(i32(v << common._1n) ^ i32(v >> _31n));
+  },
+  decode: (input) => {
+    const v = u32(input);
+    return Number(v >> common._1n ^ -(v & common._1n));
+  }
+};
+var zigZag64 = {
+  encode: (input) => {
+    return u64(input << common._1n ^ input >> common._63n);
+  },
+  decode: (input) => {
+    return i64(input >> common._1n ^ -(input & common._1n));
+  }
+};
+
+// src/coders/numRanges.ts
+var MAX_U8 = 255;
+var MAX_I8 = 127;
+var MIN_I16 = -32768;
+var MAX_I16 = 32767;
+var MIN_I32 = -2147483648;
+var MAX_I32 = 2147483647;
+var MIN_I64 = -BigInt("0x8000000000000000");
+var MAX_I64 = BigInt("0x7fffffffffffffff");
+var MIN_I256 = -BigInt(
+  "0x8000000000000000000000000000000000000000000000000000000000000000"
+);
+var MAX_I256 = BigInt(
+  "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+);
 
 // src/coders/sigmaByteReader.ts
 var SigmaByteReader = class {
@@ -129,7 +156,7 @@ var SigmaByteReader = class {
     this.#bytes = crypto.ensureBytes(bytes);
     this.#cursor = 0;
   }
-  readBoolean() {
+  readBool() {
     return this.readByte() === 1;
   }
   readBits(length) {
@@ -155,16 +182,20 @@ var SigmaByteReader = class {
   readVlq() {
     return readVLQ(this);
   }
-  readShort() {
-    return Number(zigZagDecode(readVLQ(this)));
+  readI8() {
+    const byte = this.readByte();
+    return byte > MAX_I8 ? byte - (MAX_U8 + 1) : byte;
+  }
+  readI16() {
+    return zigZag32.decode(readBigVLQ(this));
   }
-  readInt() {
-    return Number(this.readLong());
+  readI32() {
+    return zigZag32.decode(readBigVLQ(this));
   }
-  readLong() {
-    return zigZagDecodeBigInt(readBigVLQ(this));
+  readI64() {
+    return zigZag64.decode(readBigVLQ(this));
   }
-  readBigInt() {
+  readI256() {
     const len = readVLQ(this);
     return hexToBigInt(crypto.hex.encode(this.readBytes(len)));
   }
@@ -179,7 +210,7 @@ var SigmaByteWriter = class {
     this.#bytes = new Uint8Array(length);
     this.#cursor = 0;
   }
-  writeBoolean(value) {
+  writeBool(value) {
     this.write(value === true ? 1 : 0);
     return this;
   }
@@ -189,17 +220,31 @@ var SigmaByteWriter = class {
   writeBigVLQ(value) {
     return writeBigVLQ(this, value);
   }
-  writeShort(value) {
-    this.writeVLQ(zigZagEncode(value));
+  writeI16(value) {
+    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;
   }
-  writeInt(value) {
-    this.writeLong(BigInt(value));
-    return this;
+  writeI32(value) {
+    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));
   }
-  writeLong(value) {
-    this.writeBigVLQ(zigZagEncodeBigInt(value));
-    return this;
+  writeI64(value) {
+    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));
+  }
+  writeI256(value) {
+    if (value < MIN_I256 || value > MAX_I256) {
+      throw new RangeError(`Value ${value} is out of range for a 256-bit integer`);
+    }
+    const hex6 = bigIntToHex(value);
+    return this.writeVLQ(hex6.length / 2).writeHex(hex6);
   }
   write(byte) {
     this.#bytes[this.#cursor++] = byte;
@@ -229,10 +274,6 @@ var SigmaByteWriter = class {
     if (bitOffset > 0) this.#cursor++;
     return this;
   }
-  writeBigInt(value) {
-    const hex6 = bigIntToHex(value);
-    return this.writeVLQ(hex6.length / 2).writeHex(hex6);
-  }
   writeChecksum(length = 4, hashFn = crypto.blake2b256) {
     const hash = hashFn(this.toBytes());
     return this.writeBytes(length ? hash.subarray(0, length) : hash);
@@ -496,7 +537,7 @@ var SSigmaProp = monoProxy(
   SSigmaPropType,
   descriptors.sigmaProp
 );
-var SUnit = monoProxy(SUnitType, void 0, true);
+var SUnit = monoProxy(SUnitType, undefined, true);
 var SColl = genericProxy(SCollType, (target, _, args) => {
   const [type, elements] = args;
   const elementsType = type();
@@ -522,17 +563,17 @@ var dataSerializer = {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
-          return writer.writeBoolean(data);
+          return writer.writeBool(data);
         case descriptors.byte.code:
           return writer.write(data);
         case descriptors.short.code:
-          return writer.writeShort(data);
+          return writer.writeI16(data);
         case descriptors.int.code:
-          return writer.writeInt(data);
+          return writer.writeI32(data);
         case descriptors.long.code:
-          return writer.writeLong(data);
+          return writer.writeI64(data);
         case descriptors.bigInt.code:
-          return writer.writeBigInt(data);
+          return writer.writeI256(data);
         case descriptors.groupElement.code:
           return writer.writeBytes(data);
         case descriptors.sigmaProp.code: {
@@ -590,17 +631,17 @@ var dataSerializer = {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
-          return reader.readBoolean();
+          return reader.readBool();
         case descriptors.byte.code:
-          return reader.readByte();
+          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: {
@@ -635,7 +676,7 @@ var dataSerializer = {
           );
         }
         case descriptors.unit.code:
-          return void 0;
+          return undefined;
       }
     }
     throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);
@@ -795,7 +836,7 @@ var SConstant = class _SConstant {
   }
 };
 function decode(value) {
-  if (value === void 0) return;
+  if (value === undefined) return;
   try {
     return SConstant.from(value);
   } catch {
@@ -820,7 +861,7 @@ function parse(constant, mode = "strict") {
   }
 }
 var MAX_UINT16_VALUE = 65535;
-function serializeBox(box, writer = new SigmaByteWriter(5e4), distinctTokenIds) {
+function serializeBox(box, writer = new SigmaByteWriter(4096), distinctTokenIds) {
   writer.writeBigVLQ(common.ensureBigInt(box.value));
   writer.writeHex(box.ergoTree);
   writer.writeVLQ(box.creationHeight);
@@ -910,17 +951,14 @@ function writeExtension(writer, extension) {
   const keys = Object.keys(extension);
   let length = 0;
   for (const key of keys) {
-    const ext = extension[key];
-    if (common.isDefined(ext)) {
-      length++;
-    }
+    if (common.isDefined(extension[key])) length++;
   }
   writer.writeVLQ(length);
   if (length === 0) return;
   for (const key of keys) {
-    const ext = extension[key];
-    if (common.isDefined(ext)) {
-      writer.writeVLQ(Number(key)).writeHex(ext);
+    const val = extension[key];
+    if (common.isDefined(val)) {
+      writer.writeVLQ(Number(key)).writeHex(val);
     }
   }
 }