@fleet-sdk/serializer 0.4.0 → 0.5.0

package/dist/index.js

@@ -3,62 +3,51 @@
 var common = require('@fleet-sdk/common');
 var crypto = require('@fleet-sdk/crypto');
 
-// src/coders/sigmaReader.ts
+// src/coders/sigmaByteReader.ts
 function hexToBigInt(hex6) {
-  if (hex6.length % 2) {
-    hex6 = "0" + hex6;
-  }
-  const value = BigInt("0x" + hex6);
-  const highByte = parseInt(hex6.slice(0, 2), 16);
-  if (128 & highByte) {
-    return -_bitNegate(value);
-  }
+  const value = BigInt(hex6.length % 2 ? `0x0${hex6}` : `0x${hex6}`);
+  const highByte = Number.parseInt(hex6.slice(0, 2), 16);
+  if (128 & highByte) return -negateAndMask(value);
   return value;
 }
 function bigIntToHex(value) {
   const positive = value >= common._0n;
-  if (!positive) {
-    value = _bitNegate(value);
-  }
-  let hex6 = value.toString(16);
-  if (hex6.length % 2) {
-    hex6 = "0" + hex6;
-  }
-  if (positive && 128 & parseInt(hex6.slice(0, 2), 16)) {
-    hex6 = "00" + hex6;
+  let hex6 = (positive ? value : negateAndMask(value)).toString(16);
+  if (hex6.length % 2) hex6 = `0${hex6}`;
+  if (positive && 128 & Number.parseInt(hex6.slice(0, 2), 16)) {
+    return `00${hex6}`;
   }
   return hex6;
 }
-function _bitNegate(value) {
-  const negative = value < common._0n;
-  if (negative) {
-    value = -value;
-  }
-  const bits = value.toString(2);
-  let bitLen = bits.length;
-  const mod = bitLen % 8;
+function negateAndMask(value) {
+  let val = value;
+  const negative = val < common._0n;
+  if (negative) val = -val;
+  const bits = val.toString(2);
+  let len = bits.length;
+  const mod = len % 8;
   if (mod > 0) {
-    bitLen += 8 - mod;
+    len += 8 - mod;
   } else if (negative && common.first(bits) === "1" && bits.indexOf("1", 1) !== -1) {
-    bitLen += 8;
+    len += 8;
   }
-  const mask = (1n << BigInt(bitLen)) - 1n;
-  return (~value & mask) + 1n;
+  const mask = (1n << BigInt(len)) - 1n;
+  return (~val & mask) + 1n;
 }
 function writeVLQ(writer, value) {
-  if (value === 0) {
-    return writer.write(0);
-  } else if (value < 0) {
-    throw new RangeError("Variable Length Quantity not supported for negative numbers.");
+  if (value === 0) return writer.write(0);
+  if (value < 0) {
+    throw new RangeError(
+      "Variable Length Quantity not supported for negative numbers."
+    );
   }
+  let val = value;
   do {
-    let lower7bits = value & 127;
-    value >>= 7;
-    if (value > 0) {
-      lower7bits |= 128;
-    }
+    let lower7bits = val & 127;
+    val >>= 7;
+    if (val > 0) lower7bits |= 128;
     writer.write(lower7bits);
-  } while (value > 0);
+  } while (val > 0);
   return writer;
 }
 function readVLQ(reader) {
@@ -72,29 +61,27 @@ function readVLQ(reader) {
     lower7bits = reader.readByte();
     value |= (lower7bits & 127) << shift;
     shift += 7;
-  } while ((lower7bits & 128) != 0);
+  } while ((lower7bits & 128) !== 0);
   return value;
 }
 function writeBigVLQ(writer, value) {
-  if (value === common._0n) {
-    return writer.write(0);
-  } else if (value < common._0n) {
-    throw new RangeError("Variable Length Quantity not supported for negative numbers");
+  if (value === common._0n) return writer.write(0);
+  if (value < common._0n) {
+    throw new RangeError(
+      "Variable Length Quantity not supported for negative numbers"
+    );
   }
+  let val = value;
   do {
-    let lower7bits = Number(value & common._127n);
-    value >>= common._7n;
-    if (value > 0) {
-      lower7bits |= 128;
-    }
+    let lower7bits = Number(val & common._127n);
+    val >>= common._7n;
+    if (val > 0) lower7bits |= 128;
     writer.write(lower7bits);
-  } while (value > 0);
+  } while (val > 0);
   return writer;
 }
 function readBigVLQ(reader) {
-  if (reader.isEmpty) {
-    return common._0n;
-  }
+  if (reader.isEmpty) return common._0n;
   let value = common._0n;
   let shift = common._0n;
   let lower7bits = common._0n;
@@ -102,23 +89,24 @@ function readBigVLQ(reader) {
     lower7bits = BigInt(reader.readByte());
     value |= (lower7bits & common._127n) << shift;
     shift += common._7n;
-  } while ((lower7bits & common._128n) != common._0n);
+  } while ((lower7bits & common._128n) !== common._0n);
   return value;
 }
 function estimateVLQSize(value) {
   let size = 0;
-  if (typeof value === "number") {
+  let val = value;
+  if (typeof val === "number") {
     do {
       size++;
-      value = Math.floor(value / 128);
-    } while (value > 0);
+      val = Math.floor(val / 128);
+    } while (val > 0);
     return size;
   }
-  value = common.ensureBigInt(value);
+  val = common.ensureBigInt(val);
   do {
     size++;
-    value /= common._128n;
-  } while (value > common._0n);
+    val /= common._128n;
+  } while (val > common._0n);
   return size;
 }
 function zigZagEncode(input) {
@@ -134,19 +122,15 @@ function zigZagDecodeBigInt(input) {
   return input >> common._1n ^ -(input & common._1n);
 }
 
-// src/coders/sigmaReader.ts
-var SigmaReader = class {
+// src/coders/sigmaByteReader.ts
+var SigmaByteReader = class {
   #bytes;
   #cursor;
   get isEmpty() {
     return common.isEmpty(this.#bytes);
   }
   constructor(bytes) {
-    if (typeof bytes === "string") {
-      this.#bytes = crypto.hex.decode(bytes);
-    } else {
-      this.#bytes = bytes;
-    }
+    this.#bytes = crypto.ensureBytes(bytes);
     this.#cursor = 0;
   }
   readBoolean() {
@@ -158,14 +142,12 @@ var SigmaReader = class {
     for (let i = 0; i < length; i++) {
       const bit = this.#bytes[this.#cursor] >> bitOffset++ & 1;
       bits[i] = bit === 1;
-      if (bitOffset == 8) {
+      if (bitOffset === 8) {
         bitOffset = 0;
         this.#cursor++;
       }
     }
-    if (bitOffset > 0) {
-      this.#cursor++;
-    }
+    if (bitOffset > 0) this.#cursor++;
     return bits;
   }
   readByte() {
@@ -181,8 +163,7 @@ var SigmaReader = class {
     return Number(zigZagDecode(readVLQ(this)));
   }
   readInt() {
-    const int = this.readLong();
-    return Number(int);
+    return Number(this.readLong());
   }
   readLong() {
     return zigZagDecodeBigInt(readBigVLQ(this));
@@ -192,14 +173,14 @@ var SigmaReader = class {
     return hexToBigInt(crypto.hex.encode(this.readBytes(len)));
   }
 };
-var SigmaWriter = class {
+var SigmaByteWriter = class {
   #bytes;
   #cursor;
   get length() {
     return this.#cursor;
   }
-  constructor(maxLength) {
-    this.#bytes = new Uint8Array(maxLength);
+  constructor(length) {
+    this.#bytes = new Uint8Array(length);
     this.#cursor = 0;
   }
   writeBoolean(value) {
@@ -244,26 +225,27 @@ var SigmaWriter = class {
       } else {
         this.#bytes[this.#cursor] &= ~(1 << bitOffset++);
       }
-      if (bitOffset == 8) {
+      if (bitOffset === 8) {
         bitOffset = 0;
         this.#cursor++;
       }
     }
-    if (bitOffset > 0) {
-      this.#cursor++;
-    }
+    if (bitOffset > 0) this.#cursor++;
     return this;
   }
   writeBigInt(value) {
     const hex6 = bigIntToHex(value);
-    this.writeVLQ(hex6.length / 2);
-    this.writeHex(hex6);
-    return this;
+    return this.writeVLQ(hex6.length / 2).writeHex(hex6);
   }
-  toHex() {
-    return crypto.hex.encode(this.toBytes());
+  writeChecksum(length = 4, hashFn = crypto.blake2b256) {
+    const hash = hashFn(this.toBytes());
+    return this.writeBytes(length ? hash.subarray(0, length) : hash);
+  }
+  encode(coder) {
+    return coder.encode(this.toBytes());
   }
   toBytes() {
+    if (this.#cursor === this.#bytes.length) return this.#bytes;
     return this.#bytes.subarray(0, this.#cursor);
   }
 };
@@ -395,7 +377,7 @@ var constructorCode = Object.freeze({
 });
 var MAX_PRIMITIVE_TYPE_CODE = 11;
 var PRIMITIVE_TYPE_RANGE = MAX_PRIMITIVE_TYPE_CODE + 1;
-var typeCodeOf = (constructor) => PRIMITIVE_TYPE_RANGE * constructor;
+var typeCodeOf = (ctor) => PRIMITIVE_TYPE_RANGE * ctor;
 var collDescriptor = Object.freeze({
   code: typeCodeOf(constructorCode.simpleColl),
   embeddable: false,
@@ -488,8 +470,7 @@ function monoProxy(ctor, cache, forceConstruction) {
   return new Proxy(ctor, {
     apply: (target, _, args) => {
       const instance = cache ?? new target();
-      if (!forceConstruction && common.isEmpty(args))
-        return instance;
+      if (!forceConstruction && common.isEmpty(args)) return instance;
       return new SConstant(instance, ...args);
     }
   });
@@ -501,41 +482,56 @@ function genericProxy(ctor, handler) {
 }
 var SByte = monoProxy(SByteType, descriptors.byte);
 var SBool = monoProxy(SBoolType, descriptors.bool);
-var SShort = monoProxy(SShortType, descriptors.short);
+var SShort = monoProxy(
+  SShortType,
+  descriptors.short
+);
 var SInt = monoProxy(SIntType, descriptors.int);
-var SLong = monoProxy(SLongType, descriptors.long);
-var SBigInt = monoProxy(SBigIntType, descriptors.bigInt);
-var SGroupElement = monoProxy(
-  SGroupElementType,
-  descriptors.groupElement
+var SLong = monoProxy(
+  SLongType,
+  descriptors.long
+);
+var SBigInt = monoProxy(
+  SBigIntType,
+  descriptors.bigInt
 );
+var SGroupElement = monoProxy(SGroupElementType, descriptors.groupElement);
 var SSigmaProp = monoProxy(
   SSigmaPropType,
   descriptors.sigmaProp
 );
 var SUnit = monoProxy(SUnitType, void 0, true);
-var SColl = genericProxy(SCollType, (target, _, args) => {
-  const [type, elements] = args;
-  const elementsType = type();
-  if (!elements)
-    return () => new target(elementsType);
-  return new SConstant(new target(elementsType), elements);
-});
-var SPair = genericProxy(STupleType, (target, _, args) => {
-  const [left, right] = args;
-  if (typeof left === "function" && typeof right === "function") {
-    return () => new target([left(), right()]);
-  } else if (left instanceof SConstant && right instanceof SConstant) {
-    return new SConstant(new target([left.type, right.type]), [left.data, right.data]);
-  }
-  throw new Error("Invalid tuple declaration.");
-});
+var SColl = genericProxy(
+  SCollType,
+  (target, _, args) => {
+    const [type, elements] = args;
+    const elementsType = type();
+    if (!elements) return () => new target(elementsType);
+    return new SConstant(new target(elementsType), elements);
+  }
+);
+var SPair = genericProxy(
+  STupleType,
+  (target, _, args) => {
+    const [left, right] = args;
+    if (typeof left === "function" && typeof right === "function") {
+      return () => new target([left(), right()]);
+    }
+    if (left instanceof SConstant && right instanceof SConstant) {
+      return new SConstant(new target([left.type, right.type]), [
+        left.data,
+        right.data
+      ]);
+    }
+    throw new Error("Invalid tuple declaration.");
+  }
+);
 
 // src/serializers/dataSerializer.ts
 var GROUP_ELEMENT_LENGTH = 33;
 var PROVE_DLOG_OP = 205;
-var DataSerializer = class _DataSerializer {
-  static serialize(data, type, writer) {
+var dataSerializer = {
+  serialize(data, type, writer) {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
@@ -548,27 +544,33 @@ var DataSerializer = class _DataSerializer {
           return writer.writeInt(data);
         case descriptors.long.code:
           return writer.writeLong(data);
-        case descriptors.bigInt.code: {
+        case descriptors.bigInt.code:
           return writer.writeBigInt(data);
-        }
         case descriptors.groupElement.code:
           return writer.writeBytes(data);
         case descriptors.sigmaProp.code: {
           const node = data;
           if (node.type === descriptors.groupElement) {
             writer.write(PROVE_DLOG_OP);
-            return _DataSerializer.serialize(node.data, node.type, writer);
-          } else {
-            throw Error("Serialization error: SigmaProp operation not implemented.");
+            return dataSerializer.serialize(node.data, node.type, writer);
           }
+          throw Error(
+            "Serialization error: SigmaProp operation not implemented."
+          );
         }
       }
-    } else if (isColl(type)) {
+    }
+    if (isColl(type)) {
       if (type.elementsType.code === descriptors.byte.code) {
-        const isUint8Array = data instanceof Uint8Array;
-        common.assert(isUint8Array, `SColl[Byte] expected an UInt8Array, got ${typeof data}.`);
+        common.assert(
+          data instanceof Uint8Array,
+          `SColl[Byte] expected an UInt8Array, got ${typeof data}.`
+        );
       } else {
-        common.assert(Array.isArray(data), `SColl expected an array, got ${typeof data}.`);
+        common.assert(
+          Array.isArray(data),
+          `SColl expected an array, got ${typeof data}.`
+        );
       }
       writer.writeVLQ(data.length);
       switch (type.elementsType.code) {
@@ -580,27 +582,29 @@ var DataSerializer = class _DataSerializer {
         }
         default: {
           for (let i = 0; i < data.length; i++) {
-            _DataSerializer.serialize(data[i], type.elementsType, writer);
+            dataSerializer.serialize(data[i], type.elementsType, writer);
           }
           return writer;
         }
       }
-    } else if (isTuple(type)) {
+    }
+    if (isTuple(type)) {
       common.assert(
         Array.isArray(data),
         `STupleType serialization expected an array, got ${typeof data}.`
       );
       const len = type.elementsType.length;
       for (let i = 0; i < len; i++) {
-        _DataSerializer.serialize(data[i], type.elementsType[i], writer);
+        dataSerializer.serialize(data[i], type.elementsType[i], writer);
       }
       return writer;
-    } else if (type.code === descriptors.unit.code) {
-      return writer;
     }
-    throw Error(`Serialization error: '0x${type.code.toString(16)}' type not implemented.`);
-  }
-  static deserialize(type, reader) {
+    if (type.code === descriptors.unit.code) return writer;
+    throw Error(
+      `Serialization error: '0x${type.code.toString(16)}' type not implemented.`
+    );
+  },
+  deserialize(type, reader) {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
@@ -644,29 +648,36 @@ var DataSerializer = class _DataSerializer {
           }
         }
         case descriptors.tuple.code: {
-          return type.elementsType.map((t) => this.deserialize(t, reader));
+          return type.elementsType.map(
+            (t) => this.deserialize(t, reader)
+          );
         }
-        case descriptors.unit.code: {
+        case descriptors.unit.code:
           return void 0;
-        }
       }
     }
-    throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);
+    throw new Error(
+      `Parsing error: '0x${type.code.toString(16)}' type not implemented.`
+    );
   }
 };
-var TypeSerializer = class {
-  static serialize(type, writer) {
+var typeSerializer = {
+  serialize(type, writer) {
     if (type.embeddable) {
       writer.write(type.code);
     } else if (type.code === descriptors.unit.code) {
       writer.write(type.code);
     } else if (isColl(type)) {
       if (type.elementsType.embeddable) {
-        writer.write(descriptors.coll.simpleCollTypeCode + type.elementsType.code);
+        writer.write(
+          descriptors.coll.simpleCollTypeCode + type.elementsType.code
+        );
       } else if (isColl(type.elementsType)) {
         const nestedColl = type.elementsType;
         if (nestedColl.elementsType.embeddable) {
-          writer.write(descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code);
+          writer.write(
+            descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code
+          );
         } else {
           writer.write(descriptors.coll.simpleCollTypeCode);
           this.serialize(nestedColl, writer);
@@ -705,7 +716,10 @@ var TypeSerializer = class {
           break;
         default: {
           const len = type.elementsType.length;
-          common.assert(len >= 2 && len <= 255, "Invalid type: tuples must have between 2 and 255 items.");
+          common.assert(
+            len >= 2 && len <= 255,
+            "Invalid type: tuples must have between 2 and 255 items."
+          );
           writer.write(descriptors.tuple.genericTupleTypeCode);
           writer.writeVLQ(len);
         }
@@ -716,10 +730,13 @@ var TypeSerializer = class {
     } else {
       throw new Error("Serialization error: type not implemented.");
     }
-  }
-  static deserialize(r) {
+  },
+  deserialize(r) {
     const byte = r.readByte();
-    common.assert(byte > 0, `Parsing Error: Unexpected type code '0x${byte.toString(16)}'`);
+    common.assert(
+      byte > 0,
+      `Parsing Error: Unexpected type code '0x${byte.toString(16)}'`
+    );
     if (byte < descriptors.tuple.genericTupleTypeCode) {
       const ctorCode = Math.floor(byte / PRIMITIVE_TYPE_RANGE);
       const embdCode = Math.floor(byte % PRIMITIVE_TYPE_RANGE);
@@ -743,23 +760,27 @@ var TypeSerializer = class {
           return new STupleType(internal);
         }
         case constructorCode.symmetricPair: {
-          const internal = embdCode === 0 ? [this.deserialize(r), this.deserialize(r), this.deserialize(r), this.deserialize(r)] : [getPrimitiveType(embdCode), getPrimitiveType(embdCode)];
+          const internal = embdCode === 0 ? [
+            this.deserialize(r),
+            this.deserialize(r),
+            this.deserialize(r),
+            this.deserialize(r)
+          ] : [getPrimitiveType(embdCode), getPrimitiveType(embdCode)];
           return new STupleType(internal);
         }
       }
-    } else {
-      switch (byte) {
-        case descriptors.tuple.genericTupleTypeCode: {
-          const len = r.readVlq();
-          const wrapped = new Array(len);
-          for (let i = 0; i < len; i++) {
-            wrapped[i] = this.deserialize(r);
-          }
-          return new STupleType(wrapped);
-        }
-        case descriptors.unit.code: {
-          return descriptors.unit;
+    }
+    switch (byte) {
+      case descriptors.tuple.genericTupleTypeCode: {
+        const len = r.readVlq();
+        const wrapped = new Array(len);
+        for (let i = 0; i < len; i++) {
+          wrapped[i] = this.deserialize(r);
         }
+        return new STupleType(wrapped);
+      }
+      case descriptors.unit.code: {
+        return descriptors.unit;
       }
     }
     throw new Error("Not implemented.");
@@ -777,9 +798,9 @@ var SConstant = class _SConstant {
   }
   static from(bytes) {
     common.assert(bytes.length > 0, "Empty constant bytes.");
-    const reader = new SigmaReader(bytes);
-    const type = TypeSerializer.deserialize(reader);
-    const data = DataSerializer.deserialize(type, reader);
+    const reader = new SigmaByteReader(bytes);
+    const type = typeSerializer.deserialize(reader);
+    const data = dataSerializer.deserialize(type, reader);
     return new _SConstant(type, data);
   }
   get type() {
@@ -789,20 +810,24 @@ var SConstant = class _SConstant {
     return this.#data;
   }
   toBytes() {
-    const writer = new SigmaWriter(MAX_CONSTANT_LENGTH);
-    TypeSerializer.serialize(this.type, writer);
-    DataSerializer.serialize(this.data, this.type, writer);
+    const writer = new SigmaByteWriter(MAX_CONSTANT_LENGTH);
+    typeSerializer.serialize(this.type, writer);
+    dataSerializer.serialize(this.data, this.type, writer);
     return writer.toBytes();
   }
   toHex() {
     return crypto.hex.encode(this.toBytes());
   }
 };
+function decode(value, coder) {
+  if (common.isUndefined(value)) return;
+  const data = parse(value, "safe");
+  if (common.isUndefined(data)) return;
+  return coder ? coder(data) : data;
+}
 function parse(constant, mode = "strict") {
-  if (mode === "strict")
-    return SConstant.from(constant ?? "").data;
-  if (!constant)
-    return;
+  if (mode === "strict") return SConstant.from(constant ?? "").data;
+  if (!constant) return;
   try {
     return SConstant.from(constant).data;
   } catch {
@@ -810,23 +835,15 @@ function parse(constant, mode = "strict") {
   }
 }
 var MAX_UINT16_VALUE = 65535;
-function serializeBox(box, writer, distinctTokenIds) {
-  if (!writer) {
-    writer = new SigmaWriter(5e4);
-  }
+function serializeBox(box, writer = new SigmaByteWriter(5e4), distinctTokenIds) {
   writer.writeBigVLQ(common.ensureBigInt(box.value));
   writer.writeHex(box.ergoTree);
   writer.writeVLQ(box.creationHeight);
   writeTokens(writer, box.assets, distinctTokenIds);
   writeRegisters(writer, box.additionalRegisters);
-  if (common.isDefined(distinctTokenIds)) {
-    return writer;
-  } else {
-    if (!isBox(box)) {
-      throw new Error("Invalid box type.");
-    }
-    return writer.writeHex(box.transactionId).writeVLQ(box.index);
-  }
+  if (common.isDefined(distinctTokenIds)) return writer;
+  if (!isBox(box)) throw new Error("Invalid box type.");
+  return writer.writeHex(box.transactionId).writeVLQ(box.index);
 }
 function isBox(box) {
   const castedBox = box;
@@ -843,26 +860,22 @@ function writeTokens(writer, tokens, tokenIds) {
       (token) => writer.writeVLQ(tokenIds.indexOf(token.tokenId)).writeBigVLQ(common.ensureBigInt(token.amount))
     );
   } else {
-    tokens.map((token) => writer.writeHex(token.tokenId).writeBigVLQ(common.ensureBigInt(token.amount)));
+    tokens.map(
+      (token) => writer.writeHex(token.tokenId).writeBigVLQ(common.ensureBigInt(token.amount))
+    );
   }
 }
 function writeRegisters(writer, registers) {
   const keys = Object.keys(registers).sort();
   let length = 0;
   for (const key of keys) {
-    if (registers[key]) {
-      length++;
-    }
+    if (registers[key]) length++;
   }
   writer.writeVLQ(length);
-  if (length == 0) {
-    return;
-  }
+  if (length === 0) return;
   for (const key of keys) {
     const register = registers[key];
-    if (common.isDefined(register)) {
-      writer.writeHex(register);
-    }
+    if (common.isDefined(register)) writer.writeHex(register);
   }
 }
 function estimateBoxSize(box, withValue) {
@@ -874,10 +887,9 @@ function estimateBoxSize(box, withValue) {
   size += common.byteSizeOf(box.ergoTree);
   size += estimateVLQSize(box.creationHeight);
   size += estimateVLQSize(box.assets.length);
-  size += box.assets.reduce(
-    (acc, curr) => acc += common.byteSizeOf(curr.tokenId) + estimateVLQSize(curr.amount),
-    0
-  );
+  for (const asset of box.assets) {
+    size += common.byteSizeOf(asset.tokenId) + estimateVLQSize(asset.amount);
+  }
   let registersLength = 0;
   for (const key in box.additionalRegisters) {
     const register = box.additionalRegisters[key];
@@ -892,7 +904,7 @@ function estimateBoxSize(box, withValue) {
   return size;
 }
 function serializeTransaction(transaction) {
-  const writer = new SigmaWriter(1e5);
+  const writer = new SigmaByteWriter(1e5);
   writer.writeVLQ(transaction.inputs.length);
   transaction.inputs.map((input) => writeInput(writer, input));
   writer.writeVLQ(transaction.dataInputs.length);
@@ -901,7 +913,9 @@ function serializeTransaction(transaction) {
   writer.writeVLQ(distinctTokenIds.length);
   distinctTokenIds.map((tokenId) => writer.writeHex(tokenId));
   writer.writeVLQ(transaction.outputs.length);
-  transaction.outputs.map((output) => serializeBox(output, writer, distinctTokenIds));
+  transaction.outputs.map(
+    (output) => serializeBox(output, writer, distinctTokenIds)
+  );
   return writer;
 }
 function writeInput(writer, input) {
@@ -919,9 +933,7 @@ function writeExtension(writer, extension) {
     }
   }
   writer.writeVLQ(length);
-  if (length == 0) {
-    return;
-  }
+  if (length === 0) return;
   for (const key of keys) {
     const ext = extension[key];
     if (common.isDefined(ext)) {
@@ -931,11 +943,12 @@ function writeExtension(writer, extension) {
 }
 function getDistinctTokenIds(outputs) {
   const tokenIds = /* @__PURE__ */ new Set();
-  outputs.flatMap((output) => output.assets.map((asset) => tokenIds.add(asset.tokenId)));
+  outputs.flatMap(
+    (output) => output.assets.map((asset) => tokenIds.add(asset.tokenId))
+  );
   return Array.from(tokenIds);
 }
 
-exports.DataSerializer = DataSerializer;
 exports.SBigInt = SBigInt;
 exports.SBigIntType = SBigIntType;
 exports.SBool = SBool;
@@ -963,7 +976,10 @@ exports.STupleType = STupleType;
 exports.SType = SType;
 exports.SUnit = SUnit;
 exports.SUnitType = SUnitType;
-exports.TypeSerializer = TypeSerializer;
+exports.SigmaByteReader = SigmaByteReader;
+exports.SigmaByteWriter = SigmaByteWriter;
+exports.dataSerializer = dataSerializer;
+exports.decode = decode;
 exports.estimateBoxSize = estimateBoxSize;
 exports.estimateVLQSize = estimateVLQSize;
 exports.isColl = isColl;
@@ -971,5 +987,6 @@ exports.isTuple = isTuple;
 exports.parse = parse;
 exports.serializeBox = serializeBox;
 exports.serializeTransaction = serializeTransaction;
+exports.typeSerializer = typeSerializer;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map