@fleet-sdk/serializer 0.2.0

package/dist/index.js

@@ -0,0 +1,974 @@
+'use strict';
+
+var common = require('@fleet-sdk/common');
+var crypto = require('@fleet-sdk/crypto');
+
+// src/coders/sigmaReader.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);
+  }
+  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;
+  }
+  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;
+  if (mod > 0) {
+    bitLen += 8 - mod;
+  } else if (negative && common.first(bits) === "1" && bits.indexOf("1", 1) !== -1) {
+    bitLen += 8;
+  }
+  const mask = (1n << BigInt(bitLen)) - 1n;
+  return (~value & 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.");
+  }
+  do {
+    let lower7bits = value & 127;
+    value >>= 7;
+    if (value > 0) {
+      lower7bits |= 128;
+    }
+    writer.write(lower7bits);
+  } while (value > 0);
+  return writer;
+}
+function readVLQ(reader) {
+  if (reader.isEmpty) {
+    return 0;
+  }
+  let value = 0;
+  let shift = 0;
+  let lower7bits = 0;
+  do {
+    lower7bits = reader.readByte();
+    value |= (lower7bits & 127) << shift;
+    shift += 7;
+  } 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");
+  }
+  do {
+    let lower7bits = Number(value & common._127n);
+    value >>= common._7n;
+    if (value > 0) {
+      lower7bits |= 128;
+    }
+    writer.write(lower7bits);
+  } while (value > 0);
+  return writer;
+}
+function readBigVLQ(reader) {
+  if (reader.isEmpty) {
+    return common._0n;
+  }
+  let value = common._0n;
+  let shift = common._0n;
+  let lower7bits = common._0n;
+  do {
+    lower7bits = BigInt(reader.readByte());
+    value |= (lower7bits & common._127n) << shift;
+    shift += common._7n;
+  } while ((lower7bits & common._128n) != common._0n);
+  return value;
+}
+function estimateVLQSize(value) {
+  let size = 0;
+  if (typeof value === "number") {
+    do {
+      size++;
+      value = Math.floor(value / 128);
+    } while (value > 0);
+    return size;
+  }
+  value = common.ensureBigInt(value);
+  do {
+    size++;
+    value /= common._128n;
+  } while (value > 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);
+}
+
+// src/coders/sigmaReader.ts
+var SigmaReader = 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.#cursor = 0;
+  }
+  readBoolean() {
+    return this.readByte() === 1;
+  }
+  readBits(length) {
+    const bits = new Array(length);
+    let bitOffset = 0;
+    for (let i = 0; i < length; i++) {
+      const bit = this.#bytes[this.#cursor] >> bitOffset++ & 1;
+      bits[i] = bit === 1;
+      if (bitOffset == 8) {
+        bitOffset = 0;
+        this.#cursor++;
+      }
+    }
+    if (bitOffset > 0) {
+      this.#cursor++;
+    }
+    return bits;
+  }
+  readByte() {
+    return this.#bytes[this.#cursor++];
+  }
+  readBytes(length) {
+    return this.#bytes.subarray(this.#cursor, this.#cursor += length);
+  }
+  readVlq() {
+    return readVLQ(this);
+  }
+  readShort() {
+    return Number(zigZagDecode(readVLQ(this)));
+  }
+  readInt() {
+    const int = this.readLong();
+    return Number(int);
+  }
+  readLong() {
+    return zigZagDecodeBigInt(readBigVLQ(this));
+  }
+  readBigInt() {
+    const len = readVLQ(this);
+    return hexToBigInt(crypto.hex.encode(this.readBytes(len)));
+  }
+};
+var SigmaWriter = class {
+  #bytes;
+  #cursor;
+  get length() {
+    return this.#cursor;
+  }
+  constructor(maxLength) {
+    this.#bytes = new Uint8Array(maxLength);
+    this.#cursor = 0;
+  }
+  writeBoolean(value) {
+    this.write(value === true ? 1 : 0);
+    return this;
+  }
+  writeVLQ(value) {
+    return writeVLQ(this, value);
+  }
+  writeBigVLQ(value) {
+    return writeBigVLQ(this, value);
+  }
+  writeShort(value) {
+    this.writeVLQ(zigZagEncode(value));
+    return this;
+  }
+  writeInt(value) {
+    this.writeLong(BigInt(value));
+    return this;
+  }
+  writeLong(value) {
+    this.writeBigVLQ(zigZagEncodeBigInt(value));
+    return this;
+  }
+  write(byte) {
+    this.#bytes[this.#cursor++] = byte;
+    return this;
+  }
+  writeBytes(bytes) {
+    this.#bytes.set(bytes, this.#cursor);
+    this.#cursor += bytes.length;
+    return this;
+  }
+  writeHex(bytesHex) {
+    return this.writeBytes(crypto.hex.decode(bytesHex));
+  }
+  writeBits(bits) {
+    let bitOffset = 0;
+    for (let i = 0; i < bits.length; i++) {
+      if (bits[i]) {
+        this.#bytes[this.#cursor] |= 1 << bitOffset++;
+      } else {
+        this.#bytes[this.#cursor] &= ~(1 << bitOffset++);
+      }
+      if (bitOffset == 8) {
+        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;
+  }
+  toHex() {
+    return crypto.hex.encode(this.toBytes());
+  }
+  toBytes() {
+    return this.#bytes.subarray(0, this.#cursor);
+  }
+};
+
+// src/types/base.ts
+var SType = class {
+  coerce(data) {
+    return data;
+  }
+};
+var SMonomorphicType = class extends SType {
+  get embeddable() {
+    return false;
+  }
+};
+var SPrimitiveType = class extends SMonomorphicType {
+  get embeddable() {
+    return true;
+  }
+};
+var SGenericType = class extends SType {
+  #internalType;
+  constructor(type) {
+    super();
+    this.#internalType = type;
+  }
+  get elementsType() {
+    return this.#internalType;
+  }
+  get embeddable() {
+    return false;
+  }
+};
+var SBoolType = class extends SPrimitiveType {
+  get code() {
+    return 1;
+  }
+  toString() {
+    return "SBool";
+  }
+};
+var SByteType = class extends SPrimitiveType {
+  get code() {
+    return 2;
+  }
+  toString() {
+    return "SByte";
+  }
+};
+var SShortType = class extends SPrimitiveType {
+  get code() {
+    return 3;
+  }
+  toString() {
+    return "SShort";
+  }
+};
+var SIntType = class extends SPrimitiveType {
+  get code() {
+    return 4;
+  }
+  toString() {
+    return "SInt";
+  }
+};
+var SLongType = class extends SPrimitiveType {
+  get code() {
+    return 5;
+  }
+  coerce(data) {
+    return common.ensureBigInt(data);
+  }
+  toString() {
+    return "SLong";
+  }
+};
+var SBigIntType = class extends SPrimitiveType {
+  get code() {
+    return 6;
+  }
+  coerce(data) {
+    return common.ensureBigInt(data);
+  }
+  toString() {
+    return "SBigInt";
+  }
+};
+var SGroupElementType = class extends SPrimitiveType {
+  get code() {
+    return 7;
+  }
+  coerce(data) {
+    return typeof data === "string" ? crypto.hex.decode(data) : data;
+  }
+  toString() {
+    return "SGroupElement";
+  }
+};
+var SSigmaPropType = class extends SPrimitiveType {
+  get code() {
+    return 8;
+  }
+  toString() {
+    return "SSigmaProp";
+  }
+};
+
+// src/types/monomorphics.ts
+var SUnitType = class extends SMonomorphicType {
+  get code() {
+    return 98;
+  }
+  toString() {
+    return "SUnit";
+  }
+};
+
+// src/types/descriptors.ts
+var constructorCode = Object.freeze({
+  embeddable: 0,
+  simpleColl: 1,
+  nestedColl: 2,
+  option: 3,
+  optionCollection: 4,
+  pairOne: 5,
+  pairTwo: 6,
+  symmetricPair: 7,
+  genericTuple: 8
+});
+var MAX_PRIMITIVE_TYPE_CODE = 11;
+var PRIMITIVE_TYPE_RANGE = MAX_PRIMITIVE_TYPE_CODE + 1;
+var typeCodeOf = (constructor) => PRIMITIVE_TYPE_RANGE * constructor;
+var collDescriptor = Object.freeze({
+  code: typeCodeOf(constructorCode.simpleColl),
+  embeddable: false,
+  simpleCollTypeCode: typeCodeOf(constructorCode.simpleColl),
+  nestedCollTypeCode: typeCodeOf(constructorCode.nestedColl)
+});
+var tupleDescriptor = Object.freeze({
+  code: typeCodeOf(constructorCode.pairOne),
+  embeddable: false,
+  pairOneTypeCode: typeCodeOf(constructorCode.pairOne),
+  pairTwoTypeCode: typeCodeOf(constructorCode.pairTwo),
+  tripleTypeCode: typeCodeOf(constructorCode.pairTwo),
+  symmetricPairTypeCode: typeCodeOf(constructorCode.symmetricPair),
+  quadrupleTypeCode: typeCodeOf(constructorCode.symmetricPair),
+  genericTupleTypeCode: typeCodeOf(constructorCode.genericTuple)
+});
+var descriptors = {
+  bool: new SBoolType(),
+  byte: new SByteType(),
+  short: new SShortType(),
+  int: new SIntType(),
+  long: new SLongType(),
+  bigInt: new SBigIntType(),
+  groupElement: new SGroupElementType(),
+  sigmaProp: new SSigmaPropType(),
+  unit: new SUnitType(),
+  coll: collDescriptor,
+  tuple: tupleDescriptor
+};
+function isColl(type) {
+  return type.code >= descriptors.coll.simpleCollTypeCode && type.code <= descriptors.coll.nestedCollTypeCode + MAX_PRIMITIVE_TYPE_CODE;
+}
+function isTuple(type) {
+  return type.code >= descriptors.tuple.pairOneTypeCode && type.code <= descriptors.tuple.genericTupleTypeCode;
+}
+function getPrimitiveType(typeCode) {
+  switch (typeCode) {
+    case descriptors.bool.code:
+      return descriptors.bool;
+    case descriptors.byte.code:
+      return descriptors.byte;
+    case descriptors.short.code:
+      return descriptors.short;
+    case descriptors.int.code:
+      return descriptors.int;
+    case descriptors.long.code:
+      return descriptors.long;
+    case descriptors.bigInt.code:
+      return descriptors.bigInt;
+    case descriptors.groupElement.code:
+      return descriptors.groupElement;
+    case descriptors.sigmaProp.code:
+      return descriptors.sigmaProp;
+    default:
+      throw new Error(
+        `The type code '0x${typeCode.toString(16)}' is not a valid primitive type code.`
+      );
+  }
+}
+var SCollType = class extends SGenericType {
+  get code() {
+    return descriptors.coll.code;
+  }
+  coerce(elements) {
+    if (this.elementsType.code === descriptors.byte.code && !(elements instanceof Uint8Array)) {
+      return typeof elements === "string" ? crypto.hex.decode(elements) : Uint8Array.from(elements);
+    }
+    return elements.map((el) => this.elementsType.coerce(el));
+  }
+  toString() {
+    return `SColl[${this.elementsType.toString()}]`;
+  }
+};
+var STupleType = class extends SGenericType {
+  get code() {
+    return descriptors.tuple.code;
+  }
+  coerce(elements) {
+    const output = new Array(elements.length);
+    for (let i = 0; i < elements.length; i++) {
+      output[i] = this.elementsType[i].coerce(elements[i]);
+    }
+    return output;
+  }
+  toString() {
+    return `(${this.elementsType.map((el) => el.toString()).join(", ")})`;
+  }
+};
+function monoProxy(ctor, cache, forceConstruction) {
+  return new Proxy(ctor, {
+    apply: (target, _, args) => {
+      const instance = cache ?? new target();
+      if (!forceConstruction && common.isEmpty(args))
+        return instance;
+      return new SConstant(instance, ...args);
+    }
+  });
+}
+function genericProxy(ctor, handler) {
+  return new Proxy(ctor, {
+    apply: handler
+  });
+}
+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 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.");
+});
+
+// src/serializers/dataSerializer.ts
+var GROUP_ELEMENT_LENGTH = 33;
+var PROVE_DLOG_OP = 205;
+var DataSerializer = class _DataSerializer {
+  static serialize(data, type, writer) {
+    if (type.embeddable) {
+      switch (type.code) {
+        case descriptors.bool.code:
+          return writer.writeBoolean(data);
+        case descriptors.byte.code:
+          return writer.write(data);
+        case descriptors.short.code:
+          return writer.writeShort(data);
+        case descriptors.int.code:
+          return writer.writeInt(data);
+        case descriptors.long.code:
+          return writer.writeLong(data);
+        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.");
+          }
+        }
+      }
+    } else 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}.`);
+      } else {
+        common.assert(Array.isArray(data), `SColl expected an array, got ${typeof data}.`);
+      }
+      writer.writeVLQ(data.length);
+      switch (type.elementsType.code) {
+        case descriptors.bool.code: {
+          return writer.writeBits(data);
+        }
+        case descriptors.byte.code: {
+          return writer.writeBytes(data);
+        }
+        default: {
+          for (let i = 0; i < data.length; i++) {
+            _DataSerializer.serialize(data[i], type.elementsType, writer);
+          }
+          return writer;
+        }
+      }
+    } else 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);
+      }
+      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.embeddable) {
+      switch (type.code) {
+        case descriptors.bool.code:
+          return reader.readBoolean();
+        case descriptors.byte.code:
+          return reader.readByte();
+        case descriptors.short.code:
+          return reader.readShort();
+        case descriptors.int.code:
+          return reader.readInt();
+        case descriptors.long.code:
+          return reader.readLong();
+        case descriptors.bigInt.code:
+          return reader.readBigInt();
+        case descriptors.groupElement.code:
+          return reader.readBytes(GROUP_ELEMENT_LENGTH);
+        case descriptors.sigmaProp.code: {
+          if (reader.readByte() === PROVE_DLOG_OP) {
+            return this.deserialize(descriptors.groupElement, reader);
+          }
+          break;
+        }
+      }
+    } else {
+      switch (type.code) {
+        case descriptors.coll.code: {
+          const length = reader.readVlq();
+          const embeddedType = type.elementsType;
+          switch (embeddedType.code) {
+            case descriptors.bool.code:
+              return reader.readBits(length);
+            case descriptors.byte.code:
+              return reader.readBytes(length);
+            default: {
+              const elements = new Array(length);
+              for (let i = 0; i < length; i++) {
+                elements[i] = this.deserialize(embeddedType, reader);
+              }
+              return elements;
+            }
+          }
+        }
+        case descriptors.tuple.code: {
+          return type.elementsType.map((t) => this.deserialize(t, reader));
+        }
+        case descriptors.unit.code: {
+          return void 0;
+        }
+      }
+    }
+    throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);
+  }
+};
+var TypeSerializer = class {
+  static 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);
+      } else if (isColl(type.elementsType)) {
+        const nestedColl = type.elementsType;
+        if (nestedColl.elementsType.embeddable) {
+          writer.write(descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code);
+        } else {
+          writer.write(descriptors.coll.simpleCollTypeCode);
+          this.serialize(nestedColl, writer);
+        }
+      } else {
+        writer.write(descriptors.coll.simpleCollTypeCode);
+        this.serialize(type.elementsType, writer);
+      }
+    } else if (isTuple(type)) {
+      switch (type.elementsType.length) {
+        case 2: {
+          const left = common.first(type.elementsType);
+          const right = common.last(type.elementsType);
+          if (left.embeddable) {
+            if (left.code === right.code) {
+              writer.write(descriptors.tuple.symmetricPairTypeCode + left.code);
+            } else {
+              writer.write(descriptors.tuple.pairOneTypeCode + left.code);
+              this.serialize(right, writer);
+            }
+          } else if (right.embeddable) {
+            writer.write(descriptors.tuple.pairTwoTypeCode + right.code);
+            this.serialize(left, writer);
+          } else {
+            writer.write(descriptors.tuple.pairOneTypeCode);
+            this.serialize(left, writer);
+            this.serialize(right, writer);
+          }
+          return;
+        }
+        case 3:
+          writer.write(descriptors.tuple.tripleTypeCode);
+          break;
+        case 4:
+          writer.write(descriptors.tuple.quadrupleTypeCode);
+          break;
+        default: {
+          const len = type.elementsType.length;
+          common.assert(len >= 2 && len <= 255, "Invalid type: tuples must have between 2 and 255 items.");
+          writer.write(descriptors.tuple.genericTupleTypeCode);
+          writer.writeVLQ(len);
+        }
+      }
+      for (let i = 0; i < type.elementsType.length; i++) {
+        this.serialize(type.elementsType[i], writer);
+      }
+    } else {
+      throw new Error("Serialization error: type not implemented.");
+    }
+  }
+  static deserialize(r) {
+    const byte = r.readByte();
+    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);
+      switch (ctorCode) {
+        case constructorCode.embeddable: {
+          return getPrimitiveType(embdCode);
+        }
+        case constructorCode.simpleColl: {
+          const internal = embdCode === 0 ? this.deserialize(r) : getPrimitiveType(embdCode);
+          return new SCollType(internal);
+        }
+        case constructorCode.nestedColl: {
+          return new SCollType(new SCollType(getPrimitiveType(embdCode)));
+        }
+        case constructorCode.pairOne: {
+          const internal = embdCode === 0 ? [this.deserialize(r), this.deserialize(r)] : [getPrimitiveType(embdCode), this.deserialize(r)];
+          return new STupleType(internal);
+        }
+        case constructorCode.pairTwo: {
+          const internal = embdCode === 0 ? [this.deserialize(r), this.deserialize(r), this.deserialize(r)] : [this.deserialize(r), getPrimitiveType(embdCode)];
+          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)];
+          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;
+        }
+      }
+    }
+    throw new Error("Not implemented.");
+  }
+};
+
+// src/sigmaConstant.ts
+var MAX_CONSTANT_LENGTH = 4096;
+var SConstant = class _SConstant {
+  #type;
+  #data;
+  constructor(type, data) {
+    this.#type = type;
+    this.#data = type.coerce(data);
+  }
+  static from(bytes) {
+    const reader = new SigmaReader(bytes);
+    const type = TypeSerializer.deserialize(reader);
+    const data = DataSerializer.deserialize(type, reader);
+    return new _SConstant(type, data);
+  }
+  get type() {
+    return this.#type;
+  }
+  get data() {
+    return this.#data;
+  }
+  toBytes() {
+    const writer = new SigmaWriter(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 parse(bytes, mode = "strict") {
+  if (mode === "strict")
+    return SConstant.from(bytes).data;
+  if (!bytes)
+    return;
+  try {
+    return SConstant.from(bytes).data;
+  } catch {
+    return;
+  }
+}
+var MAX_UINT16_VALUE = 65535;
+function serializeBox(box, writer, distinctTokenIds) {
+  if (!writer) {
+    writer = new SigmaWriter(5e4);
+  }
+  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);
+  }
+}
+function isBox(box) {
+  const castedBox = box;
+  return common.isDefined(castedBox.transactionId) && common.isDefined(castedBox.index);
+}
+function writeTokens(writer, tokens, tokenIds) {
+  if (common.isEmpty(tokens)) {
+    writer.write(0);
+    return;
+  }
+  writer.writeVLQ(tokens.length);
+  if (common.some(tokenIds)) {
+    tokens.map(
+      (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)));
+  }
+}
+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 (common.isDefined(register)) {
+      writer.writeHex(register);
+    }
+  }
+}
+function estimateBoxSize(box, withValue) {
+  if (common.isUndefined(box.creationHeight)) {
+    throw new Error("Box size estimation error: creation height is undefined.");
+  }
+  let size = 0;
+  size += estimateVLQSize(common.isDefined(withValue) ? withValue : box.value);
+  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
+  );
+  let registersLength = 0;
+  for (const key in box.additionalRegisters) {
+    const register = box.additionalRegisters[key];
+    if (register) {
+      size += common.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 SigmaWriter(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;
+}
+function writeInput(writer, input) {
+  writer.writeHex(input.boxId);
+  writer.write(0);
+  writeExtension(writer, input.extension);
+}
+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++;
+    }
+  }
+  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);
+    }
+  }
+}
+function getDistinctTokenIds(outputs) {
+  const tokenIds = /* @__PURE__ */ new Set();
+  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;
+exports.SBoolType = SBoolType;
+exports.SByte = SByte;
+exports.SByteType = SByteType;
+exports.SColl = SColl;
+exports.SCollType = SCollType;
+exports.SConstant = SConstant;
+exports.SGenericType = SGenericType;
+exports.SGroupElement = SGroupElement;
+exports.SGroupElementType = SGroupElementType;
+exports.SInt = SInt;
+exports.SIntType = SIntType;
+exports.SLong = SLong;
+exports.SLongType = SLongType;
+exports.SMonomorphicType = SMonomorphicType;
+exports.SPair = SPair;
+exports.SPrimitiveType = SPrimitiveType;
+exports.SShort = SShort;
+exports.SShortType = SShortType;
+exports.SSigmaProp = SSigmaProp;
+exports.SSigmaPropType = SSigmaPropType;
+exports.STupleType = STupleType;
+exports.SType = SType;
+exports.SUnit = SUnit;
+exports.SUnitType = SUnitType;
+exports.TypeSerializer = TypeSerializer;
+exports.estimateBoxSize = estimateBoxSize;
+exports.estimateVLQSize = estimateVLQSize;
+exports.isColl = isColl;
+exports.isTuple = isTuple;
+exports.parse = parse;
+exports.serializeBox = serializeBox;
+exports.serializeTransaction = serializeTransaction;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.js.map