@fleet-sdk/serializer 0.8.3 → 0.9.0

package/dist/index.mjs

@@ -1,21 +1,21 @@
-import { isEmpty, assert, first, last, _1n, _0n, _128n, ensureBigInt, _7n, _127n, _63n, isDefined, some, isUndefined, byteSizeOf } from '@fleet-sdk/common';
-import { hex, ensureBytes, blake2b256 } from '@fleet-sdk/crypto';
+import { FEE_CONTRACT, isEmpty, startsWith, assert, first, last, _0n, _128n, _1n, ensureBigInt, isDefined, _7n, ergoTreeHeaderFlags, _127n, _63n, isUndefined, byteSizeOf } from '@fleet-sdk/common';
+import { hex, ensureBytes, blake2b256, validateEcPoint } from '@fleet-sdk/crypto';
 
 // src/coders/sigmaByteReader.ts
-function hexToBigInt(hex7) {
-  const value = BigInt(hex7.length % 2 ? `0x0${hex7}` : `0x${hex7}`);
-  const highByte = Number.parseInt(hex7.slice(0, 2), 16);
+function hexToBigInt(hex8) {
+  const value = BigInt(hex8.length % 2 ? `0x0${hex8}` : `0x${hex8}`);
+  const highByte = Number.parseInt(hex8.slice(0, 2), 16);
   if (128 & highByte) return -negateAndMask(value);
   return value;
 }
 function bigIntToHex(value) {
   const positive = value >= _0n;
-  let hex7 = (positive ? value : negateAndMask(value)).toString(16);
-  if (hex7.length % 2) hex7 = `0${hex7}`;
-  if (positive && 128 & Number.parseInt(hex7.slice(0, 2), 16)) {
-    return `00${hex7}`;
+  let hex8 = (positive ? value : negateAndMask(value)).toString(16);
+  if (hex8.length % 2) hex8 = `0${hex8}`;
+  if (positive && 128 & Number.parseInt(hex8.slice(0, 2), 16)) {
+    return `00${hex8}`;
   }
-  return hex7;
+  return hex8;
 }
 function negateAndMask(value) {
   let val = value;
@@ -32,6 +32,22 @@ function negateAndMask(value) {
   const mask = (1n << BigInt(len)) - 1n;
   return (~val & mask) + 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"
+);
 function writeVLQ(writer, value) {
   if (value === 0) return writer.write(0);
   if (value < 0) {
@@ -78,7 +94,7 @@ function readBigVLQ(reader) {
   if (reader.isEmpty) return _0n;
   let value = _0n;
   let shift = _0n;
-  let lower7bits = _0n;
+  let lower7bits;
   do {
     lower7bits = BigInt(reader.readByte());
     value |= (lower7bits & _127n) << shift;
@@ -127,33 +143,31 @@ var zigZag64 = {
   }
 };
 
-// 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 {
   #bytes;
   #cursor;
   get isEmpty() {
-    return isEmpty(this.#bytes);
+    return this.#bytes.length === this.#cursor;
+  }
+  get bytes() {
+    return this.#bytes;
+  }
+  get cursor() {
+    return this.#cursor;
   }
   constructor(bytes) {
     this.#bytes = ensureBytes(bytes);
     this.#cursor = 0;
   }
+  readArray(readFn) {
+    const length = this.readUInt();
+    const items = new Array(length);
+    for (let i = 0; i < length; i++) {
+      items[i] = readFn(this, i);
+    }
+    return items;
+  }
   readBool() {
     return this.readByte() === 1;
   }
@@ -177,9 +191,12 @@ var SigmaByteReader = class {
   readBytes(length) {
     return this.#bytes.subarray(this.#cursor, this.#cursor += length);
   }
-  readVlq() {
+  readUInt() {
     return readVLQ(this);
   }
+  readBigUInt() {
+    return readBigVLQ(this);
+  }
   readI8() {
     const byte = this.readByte();
     return byte > MAX_I8 ? byte - (MAX_U8 + 1) : byte;
@@ -197,6 +214,22 @@ var SigmaByteReader = class {
     const len = readVLQ(this);
     return hexToBigInt(hex.encode(this.readBytes(len)));
   }
+  readRemainingBytes() {
+    return this.readBytes(this.#bytes.length - this.#cursor);
+  }
+  /**
+   * Returns bytes without advancing the cursor.
+   */
+  peek(count, offset = 0) {
+    const begin = this.#cursor + offset;
+    return this.#bytes.subarray(begin, begin + count);
+  }
+  /**
+   * Checks if the current position in the byte array starts with the given bytes.
+   */
+  match(bytes, offset = 0) {
+    return startsWith(this.#bytes, bytes, this.#cursor + offset);
+  }
 };
 var SigmaByteWriter = class {
   #bytes;
@@ -212,37 +245,37 @@ var SigmaByteWriter = class {
     this.write(value === true ? 1 : 0);
     return this;
   }
-  writeVLQ(value) {
+  writeUInt(value) {
     return writeVLQ(this, value);
   }
-  writeBigVLQ(value) {
+  writeBigUInt(value) {
     return writeBigVLQ(this, 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));
+    this.writeBigUInt(zigZag32.encode(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));
+    return this.writeBigUInt(zigZag32.encode(value));
   }
   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));
+    return this.writeBigUInt(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 hex7 = bigIntToHex(value);
-    return this.writeVLQ(hex7.length / 2).writeHex(hex7);
+    const hex8 = bigIntToHex(value);
+    return this.writeUInt(hex8.length / 2).writeHex(hex8);
   }
   write(byte) {
     this.#bytes[this.#cursor++] = byte;
@@ -276,6 +309,23 @@ var SigmaByteWriter = class {
     const hash = hashFn(this.toBytes());
     return this.writeBytes(length ? hash.subarray(0, length) : hash);
   }
+  /**
+   * Writes a length-delimited array of items to the byte stream using a provided
+   * serializer function.
+   *
+   * @typeParam T - The type of items in the array.
+   * @param items - The array of items to serialize and write.
+   * @param serializer - A function that serializes each item and writes it using the provided SigmaByteWriter.
+   * @returns The current instance of SigmaByteWriter for method chaining.
+   */
+  writeArray(items, serializer) {
+    this.writeUInt(items.length);
+    if (items.length === 0) return this;
+    for (const item of items) {
+      serializer(this, item);
+    }
+    return this;
+  }
   encode(coder) {
     return coder.encode(this.toBytes());
   }
@@ -397,6 +447,14 @@ var SUnitType = class extends SMonomorphicType {
     return "SUnit";
   }
 };
+var SBoxType = class extends SMonomorphicType {
+  get code() {
+    return 99;
+  }
+  toString() {
+    return "SBox";
+  }
+};
 
 // src/types/descriptors.ts
 var constructorCode = Object.freeze({
@@ -439,6 +497,7 @@ var descriptors = {
   groupElement: new SGroupElementType(),
   sigmaProp: new SSigmaPropType(),
   unit: new SUnitType(),
+  box: new SBoxType(),
   coll: collDescriptor,
   tuple: tupleDescriptor
 };
@@ -519,14 +578,8 @@ var SByte = monoProxy(SByteType, descriptors.byte);
 var SBool = monoProxy(SBoolType, descriptors.bool);
 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 SLong = monoProxy(SLongType, descriptors.long);
+var SBigInt = monoProxy(SBigIntType, descriptors.bigInt);
 var SGroupElement = monoProxy(
   SGroupElementType,
   descriptors.groupElement
@@ -536,6 +589,7 @@ var SSigmaProp = monoProxy(
   descriptors.sigmaProp
 );
 var SUnit = monoProxy(SUnitType, void 0, true);
+var SBox = monoProxy(SBoxType, void 0, true);
 var SColl = genericProxy(SCollType, (target, _, args) => {
   const [type, elements] = args;
   const elementsType = type();
@@ -552,6 +606,143 @@ var SPair = genericProxy(STupleType, (target, _, args) => {
   }
   throw new Error("Invalid tuple declaration.");
 });
+var MAX_UINT16_VALUE = 65535;
+var FEE_CONTRACT_BYTES = hex.decode(FEE_CONTRACT);
+var P2PK_CONTRACT_PREFIX = hex.decode("0008cd");
+var COMPRESSED_PK_LENGTH = 33;
+var P2PK_CONTRACT_LENGTH = P2PK_CONTRACT_PREFIX.length + COMPRESSED_PK_LENGTH;
+function serializeBox(box, writer = new SigmaByteWriter(4096), distinctTokenIds) {
+  writer.writeBigUInt(ensureBigInt(box.value)).writeHex(box.ergoTree).writeUInt(box.creationHeight);
+  writeTokens(writer, box.assets, distinctTokenIds);
+  writeRegisters(writer, box.additionalRegisters);
+  if (isDefined(distinctTokenIds)) return writer;
+  if (!isBox(box)) throw new Error("Invalid box type.");
+  return writer.writeHex(box.transactionId).writeUInt(box.index);
+}
+function isBox(box) {
+  const castedBox = box;
+  return isDefined(castedBox.transactionId) && isDefined(castedBox.index);
+}
+function writeTokens(writer, tokens, tokenIds) {
+  if (tokenIds) {
+    writer.writeArray(
+      tokens,
+      (w, token) => w.writeUInt(tokenIds.indexOf(token.tokenId)).writeBigUInt(ensureBigInt(token.amount))
+    );
+  } else {
+    writer.writeArray(
+      tokens,
+      (w, token) => w.writeHex(token.tokenId).writeBigUInt(ensureBigInt(token.amount))
+    );
+  }
+}
+function writeRegisters(writer, registers) {
+  const keys = Object.keys(registers).sort();
+  const values = [];
+  for (const key of keys) {
+    const value = registers[key];
+    if (!value) continue;
+    values.push(value);
+  }
+  writer.writeArray(values, (w, value) => w.writeHex(value));
+}
+function estimateBoxSize(box, withValue) {
+  if (isUndefined(box.creationHeight)) {
+    throw new Error("Box size estimation error: creation height is undefined.");
+  }
+  let size = 0;
+  size += estimateVLQSize(isDefined(withValue) ? withValue : box.value);
+  size += byteSizeOf(box.ergoTree);
+  size += estimateVLQSize(box.creationHeight);
+  size += estimateVLQSize(box.assets.length);
+  for (const asset of box.assets) {
+    size += byteSizeOf(asset.tokenId) + estimateVLQSize(asset.amount);
+  }
+  let registersLength = 0;
+  for (const key in box.additionalRegisters) {
+    const register = box.additionalRegisters[key];
+    if (register) {
+      size += byteSizeOf(register);
+      registersLength++;
+    }
+  }
+  size += estimateVLQSize(registersLength);
+  size += 32;
+  size += estimateVLQSize(isBox(box) ? box.index : MAX_UINT16_VALUE);
+  return size;
+}
+function deserializeEmbeddedBox(reader, distinctTokenIds, transactionId, index) {
+  let begin = reader.cursor;
+  const value = reader.readBigUInt();
+  const ergoTree = hex.encode(readErgoTree(reader));
+  const creationHeight = reader.readUInt();
+  const boxIdWriter = new SigmaByteWriter(4096).writeBytes(reader.bytes.subarray(begin, reader.cursor));
+  const assets = readTokens(reader, distinctTokenIds);
+  boxIdWriter.writeUInt(assets.length);
+  for (const asset of assets) {
+    boxIdWriter.writeHex(asset.tokenId).writeBigUInt(asset.amount);
+  }
+  begin = reader.cursor;
+  const additionalRegisters = readRegisters(reader);
+  boxIdWriter.writeBytes(reader.bytes.subarray(begin, reader.cursor)).writeHex(transactionId).writeUInt(index);
+  return {
+    boxId: hex.encode(blake2b256(boxIdWriter.toBytes())),
+    value,
+    ergoTree,
+    creationHeight,
+    assets,
+    additionalRegisters,
+    transactionId,
+    index
+  };
+}
+function deserializeBox(input) {
+  const reader = input instanceof SigmaByteReader ? input : new SigmaByteReader(input);
+  const begin = reader.cursor;
+  const box = {
+    boxId: "",
+    // placeholder, will be calculated later
+    value: reader.readBigUInt(),
+    ergoTree: hex.encode(readErgoTree(reader)),
+    creationHeight: reader.readUInt(),
+    assets: readTokens(reader),
+    additionalRegisters: readRegisters(reader),
+    transactionId: hex.encode(reader.readBytes(32)),
+    index: reader.readUInt()
+  };
+  box.boxId = hex.encode(blake2b256(reader.bytes.subarray(begin, reader.cursor)));
+  return box;
+}
+function readErgoTree(reader) {
+  if (reader.match(FEE_CONTRACT_BYTES)) {
+    return reader.readBytes(FEE_CONTRACT_BYTES.length);
+  }
+  if (reader.match(P2PK_CONTRACT_PREFIX) && validateEcPoint(reader.peek(COMPRESSED_PK_LENGTH, P2PK_CONTRACT_PREFIX.length))) {
+    return reader.readBytes(P2PK_CONTRACT_LENGTH);
+  }
+  const header = reader.readByte();
+  const hasSize = (header & ergoTreeHeaderFlags.sizeInclusion) !== 0;
+  if (!hasSize) {
+    throw new Error("ErgoTree parsing without the size flag is not supported.");
+  }
+  const size = reader.readUInt();
+  return new SigmaByteWriter(1 + 4 + size).write(header).writeUInt(size).writeBytes(reader.readBytes(size)).toBytes();
+}
+function readTokens(reader, tokenIds) {
+  return reader.readArray((r) => ({
+    tokenId: tokenIds ? tokenIds[r.readUInt()] : hex.encode(r.readBytes(32)),
+    amount: r.readBigUInt()
+  }));
+}
+function readRegisters(reader) {
+  const registers = {};
+  const count = reader.readUInt();
+  for (let i = 0; i < count; i++) {
+    const value = SConstant.from(reader).toHex();
+    registers[`R${(i + 4).toString()}`] = value;
+  }
+  return registers;
+}
 
 // src/serializers/dataSerializer.ts
 var GROUP_ELEMENT_LENGTH = 33;
@@ -593,7 +784,7 @@ var dataSerializer = {
       } else {
         assert(Array.isArray(data), `SColl expected an array, got ${typeof data}.`);
       }
-      writer.writeVLQ(data.length);
+      writer.writeUInt(data.length);
       switch (type.elementsType.code) {
         case descriptors.bool.code: {
           return writer.writeBits(data);
@@ -621,9 +812,8 @@ var dataSerializer = {
       return writer;
     }
     if (type.code === descriptors.unit.code) return writer;
-    throw Error(
-      `Serialization error: '0x${type.code.toString(16)}' type not implemented.`
-    );
+    if (type.code === descriptors.box.code) return serializeBox(data, writer);
+    throw Error(`Serialization error: '0x${type.code.toString(16)}' type not implemented.`);
   },
   deserialize(type, reader) {
     if (type.embeddable) {
@@ -652,7 +842,7 @@ var dataSerializer = {
     } else {
       switch (type.code) {
         case descriptors.coll.code: {
-          const length = reader.readVlq();
+          const length = reader.readUInt();
           const embeddedType = type.elementsType;
           switch (embeddedType.code) {
             case descriptors.bool.code:
@@ -669,12 +859,12 @@ var 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:
           return void 0;
+        case descriptors.box.code:
+          return deserializeBox(reader);
       }
     }
     throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);
@@ -686,15 +876,15 @@ var typeSerializer = {
       writer.write(type.code);
     } else if (type.code === descriptors.unit.code) {
       writer.write(type.code);
+    } else if (type.code === descriptors.box.code) {
+      writer.write(type.code);
     } else if (isColl(type)) {
       if (type.elementsType.embeddable) {
         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);
@@ -733,12 +923,9 @@ var typeSerializer = {
           break;
         default: {
           const len = type.elementsType.length;
-          assert(
-            len >= 2 && len <= 255,
-            "Invalid type: tuples must have between 2 and 255 items."
-          );
+          assert(len >= 2 && len <= 255, "Invalid type: tuples must have between 2 and 255 items.");
           writer.write(descriptors.tuple.genericTupleTypeCode);
-          writer.writeVLQ(len);
+          writer.writeUInt(len);
         }
       }
       for (let i = 0; i < type.elementsType.length; i++) {
@@ -774,28 +961,24 @@ var typeSerializer = {
           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);
         }
       }
     }
     switch (byte) {
       case descriptors.tuple.genericTupleTypeCode: {
-        const len = r.readVlq();
+        const len = r.readUInt();
         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: {
+      case descriptors.unit.code:
         return descriptors.unit;
-      }
+      case descriptors.box.code:
+        return descriptors.box;
     }
     throw new Error("Not implemented.");
   }
@@ -806,16 +989,22 @@ var MAX_CONSTANT_LENGTH = 4096;
 var SConstant = class _SConstant {
   #type;
   #data;
+  #bytes;
   constructor(type, data) {
     this.#type = type;
     this.#data = type.coerce(data);
   }
   static from(bytes) {
-    assert(bytes.length > 0, "Empty constant bytes.");
-    const reader = new SigmaByteReader(bytes);
+    const reader = bytes instanceof SigmaByteReader ? bytes : new SigmaByteReader(bytes);
+    if (reader.isEmpty) throw new Error("Empty constant bytes.");
+    const start = reader.cursor;
     const type = typeSerializer.deserialize(reader);
     const data = dataSerializer.deserialize(type, reader);
-    return new _SConstant(type, data);
+    return new _SConstant(type, data).#withBytes(reader.bytes.slice(start, reader.cursor));
+  }
+  #withBytes(bytes) {
+    this.#bytes = bytes;
+    return this;
   }
   get type() {
     return this.#type;
@@ -823,16 +1012,52 @@ var SConstant = class _SConstant {
   get data() {
     return this.#data;
   }
-  toBytes() {
-    const writer = new SigmaByteWriter(MAX_CONSTANT_LENGTH);
+  /**
+   * Returns the serialized representation of the current instance as a `Uint8Array`.
+   * If the bytes have already been computed and cached, returns the cached value.
+   * Otherwise, serializes the instance and returns the resulting bytes.
+   */
+  get bytes() {
+    if (this.#bytes) return this.#bytes;
+    return this.serialize();
+  }
+  /**
+   * Serializes the current object into a `Uint8Array`.
+   */
+  serialize() {
+    const writer = new SigmaByteWriter(guessConstantBytesSize(this.type, this.data));
     typeSerializer.serialize(this.type, writer);
     dataSerializer.serialize(this.data, this.type, writer);
-    return writer.toBytes();
+    this.#bytes = writer.toBytes();
+    return this.#bytes;
+  }
+  /**
+   * @deprecated use `serialize` instead
+   */
+  toBytes() {
+    return this.serialize();
   }
   toHex() {
-    return hex.encode(this.toBytes());
+    return hex.encode(this.serialize());
   }
 };
+function guessConstantBytesSize(type, data) {
+  const dataSize = 1;
+  if (type.code === descriptors.short.code) return dataSize + 8;
+  if (type.code === descriptors.int.code) return dataSize + 16;
+  if (type.code === descriptors.long.code) return dataSize + 32;
+  if (type.code === descriptors.bigInt.code) return dataSize + 64;
+  if (type.code === descriptors.bool.code) return dataSize + 1;
+  if (type.code === descriptors.byte.code) return dataSize + 1;
+  if (type.code === descriptors.unit.code) return dataSize + 0;
+  if (type.code === descriptors.groupElement.code) return dataSize + 33;
+  if (type.code === descriptors.sigmaProp.code) return dataSize + 35;
+  if (isColl(type) && !isColl(type.elementsType) && !isTuple(type.elementsType)) {
+    const len = data.length;
+    return dataSize + estimateVLQSize(len) + guessConstantBytesSize(type.elementsType) * len;
+  }
+  return MAX_CONSTANT_LENGTH;
+}
 function decode(value) {
   if (value === void 0) return;
   try {
@@ -858,97 +1083,26 @@ function parse(constant, mode = "strict") {
     return;
   }
 }
-var MAX_UINT16_VALUE = 65535;
-function serializeBox(box, writer = new SigmaByteWriter(4096), distinctTokenIds) {
-  writer.writeBigVLQ(ensureBigInt(box.value));
-  writer.writeHex(box.ergoTree);
-  writer.writeVLQ(box.creationHeight);
-  writeTokens(writer, box.assets, distinctTokenIds);
-  writeRegisters(writer, box.additionalRegisters);
-  if (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;
-  return isDefined(castedBox.transactionId) && isDefined(castedBox.index);
-}
-function writeTokens(writer, tokens, tokenIds) {
-  if (isEmpty(tokens)) {
-    writer.write(0);
-    return;
-  }
-  writer.writeVLQ(tokens.length);
-  if (some(tokenIds)) {
-    tokens.map(
-      (token) => writer.writeVLQ(tokenIds.indexOf(token.tokenId)).writeBigVLQ(ensureBigInt(token.amount))
-    );
-  } else {
-    tokens.map(
-      (token) => writer.writeHex(token.tokenId).writeBigVLQ(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++;
-  }
-  writer.writeVLQ(length);
-  if (length === 0) return;
-  for (const key of keys) {
-    const register = registers[key];
-    if (isDefined(register)) writer.writeHex(register);
-  }
-}
-function estimateBoxSize(box, withValue) {
-  if (isUndefined(box.creationHeight)) {
-    throw new Error("Box size estimation error: creation height is undefined.");
-  }
-  let size = 0;
-  size += estimateVLQSize(isDefined(withValue) ? withValue : box.value);
-  size += byteSizeOf(box.ergoTree);
-  size += estimateVLQSize(box.creationHeight);
-  size += estimateVLQSize(box.assets.length);
-  for (const asset of box.assets) {
-    size += byteSizeOf(asset.tokenId) + estimateVLQSize(asset.amount);
-  }
-  let registersLength = 0;
-  for (const key in box.additionalRegisters) {
-    const register = box.additionalRegisters[key];
-    if (register) {
-      size += byteSizeOf(register);
-      registersLength++;
-    }
-  }
-  size += estimateVLQSize(registersLength);
-  size += 32;
-  size += estimateVLQSize(isBox(box) ? box.index : MAX_UINT16_VALUE);
-  return size;
-}
 function serializeTransaction(transaction) {
-  const writer = new SigmaByteWriter(1e5);
-  writer.writeVLQ(transaction.inputs.length);
-  transaction.inputs.map((input) => writeInput(writer, input));
-  writer.writeVLQ(transaction.dataInputs.length);
-  transaction.dataInputs.map((dataInput) => writer.writeHex(dataInput.boxId));
-  const distinctTokenIds = getDistinctTokenIds(transaction.outputs);
-  writer.writeVLQ(distinctTokenIds.length);
-  distinctTokenIds.map((tokenId) => writer.writeHex(tokenId));
-  writer.writeVLQ(transaction.outputs.length);
-  transaction.outputs.map((output) => serializeBox(output, writer, distinctTokenIds));
-  return writer;
+  const tokenIds = getDistinctTokenIds(transaction.outputs);
+  return new SigmaByteWriter(1e5).writeArray(transaction.inputs, (w, input) => writeInput(w, input)).writeArray(transaction.dataInputs, (w, dataInput) => w.writeHex(dataInput.boxId)).writeArray(tokenIds, (w, tokenId) => w.writeHex(tokenId)).writeArray(transaction.outputs, (w, output) => serializeBox(output, w, tokenIds));
 }
 function writeInput(writer, input) {
-  writer.writeHex(input.boxId);
   if (isSignedInput(input)) {
-    writeProof(writer, input.spendingProof?.proofBytes);
-    writeExtension(writer, input.spendingProof?.extension);
+    writeSignedInput(writer, input);
     return;
   }
+  writeUnsignedInput(writer, input);
+}
+function writeSignedInput(writer, input) {
+  writer.writeHex(input.boxId);
+  writeProof(writer, input.spendingProof?.proofBytes);
+  writeExtension(writer, input.spendingProof?.extension);
+}
+function writeUnsignedInput(writer, input) {
+  writer.writeHex(input.boxId);
   writeProof(writer, null);
-  writeExtension(writer, input.extension);
+  writeExtension(writer, isSignedInput(input) ? input.spendingProof?.extension : input.extension);
 }
 function isSignedInput(input) {
   return input.spendingProof !== void 0;
@@ -959,8 +1113,7 @@ function writeProof(writer, proof) {
     return;
   }
   const bytes = hex.decode(proof);
-  writer.writeVLQ(bytes.length);
-  writer.writeBytes(bytes);
+  writer.writeUInt(bytes.length).writeBytes(bytes);
 }
 function writeExtension(writer, extension) {
   if (!extension) {
@@ -968,25 +1121,49 @@ function writeExtension(writer, extension) {
     return;
   }
   const keys = Object.keys(extension);
-  let length = 0;
+  const values = [];
   for (const key of keys) {
-    if (isDefined(extension[key])) length++;
-  }
-  writer.writeVLQ(length);
-  if (length === 0) return;
-  for (const key of keys) {
-    const val = extension[key];
-    if (isDefined(val)) {
-      writer.writeVLQ(Number(key)).writeHex(val);
-    }
+    const value = extension[key];
+    if (!value) continue;
+    values.push([key, value]);
   }
+  writer.writeArray(values, (w, [key, value]) => w.writeUInt(Number(key)).writeHex(value));
 }
 function getDistinctTokenIds(outputs) {
   const tokenIds = /* @__PURE__ */ new Set();
   outputs.flatMap((output) => output.assets.map((asset) => tokenIds.add(asset.tokenId)));
   return Array.from(tokenIds);
 }
+function deserializeTransaction(input) {
+  const reader = new SigmaByteReader(input);
+  const inputs = reader.readArray(readInput);
+  const id = computeId(reader, inputs);
+  const dataInputs = reader.readArray((r) => ({ boxId: hex.encode(r.readBytes(32)) }));
+  const tokenIds = reader.readArray((r) => hex.encode(r.readBytes(32)));
+  const outputs = reader.readArray((r, i) => deserializeEmbeddedBox(r, tokenIds, id, i));
+  return {
+    id,
+    inputs,
+    dataInputs,
+    outputs
+  };
+}
+function readInput(reader) {
+  const boxId = hex.encode(reader.readBytes(32));
+  const proofLength = reader.readUInt();
+  const proofBytes = proofLength > 0 ? hex.encode(reader.readBytes(proofLength)) : null;
+  const extensionLength = reader.readUInt();
+  const extension = {};
+  for (let i = 0; i < extensionLength; i++) {
+    extension[reader.readUInt()] = SConstant.from(reader).toHex();
+  }
+  return proofBytes ? { boxId, spendingProof: { proofBytes, extension } } : { boxId, extension };
+}
+function computeId(reader, inputs) {
+  const bytes = new SigmaByteWriter(reader.bytes.length).writeArray(inputs, (w, input) => writeUnsignedInput(w, input)).writeBytes(reader.bytes.subarray(reader.cursor)).toBytes();
+  return hex.encode(blake2b256(bytes));
+}
 
-export { SBigInt, SBigIntType, SBool, SBoolType, SByte, SByteType, SColl, SCollType, SConstant, SGenericType, SGroupElement, SGroupElementType, SInt, SIntType, SLong, SLongType, SMonomorphicType, SPair, SPrimitiveType, SShort, SShortType, SSigmaProp, SSigmaPropType, STupleType, SType, SUnit, SUnitType, SigmaByteReader, SigmaByteWriter, dataSerializer, decode, estimateBoxSize, estimateVLQSize, isColl, isTuple, parse, serializeBox, serializeTransaction, stypeof, typeSerializer };
+export { SBigInt, SBigIntType, SBool, SBoolType, SBox, SBoxType, SByte, SByteType, SColl, SCollType, SConstant, SGenericType, SGroupElement, SGroupElementType, SInt, SIntType, SLong, SLongType, SMonomorphicType, SPair, SPrimitiveType, SShort, SShortType, SSigmaProp, SSigmaPropType, STupleType, SType, SUnit, SUnitType, SigmaByteReader, SigmaByteWriter, dataSerializer, decode, deserializeBox, deserializeEmbeddedBox, deserializeTransaction, estimateBoxSize, estimateVLQSize, isColl, isTuple, parse, serializeBox, serializeTransaction, stypeof, typeSerializer };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map