{"version":3,"sources":["../src/coders/bigint.ts","../src/coders/numRanges.ts","../src/coders/vlq.ts","../src/coders/zigZag.ts","../src/coders/sigmaByteReader.ts","../src/coders/sigmaByteWriter.ts","../src/types/base.ts","../src/types/primitives.ts","../src/types/monomorphics.ts","../src/types/descriptors.ts","../src/types/generics.ts","../src/types/constructors.ts","../src/serializers/avlTreeSerializer.ts","../src/serializers/boxSerializer.ts","../src/serializers/dataSerializer.ts","../src/serializers/typeSerializer.ts","../src/sigmaConstant.ts","../src/serializers/transactionSerializer.ts"],"names":["hex","_0n","ensureBigInt","blake2b256","first","assert"],"mappings":"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","file":"index.mjs","sourcesContent":["import { _0n, first } from \"@fleet-sdk/common\";\n\n/**\n * Converts a hex string to bigint.\n * @param hex The hex string to be converted.\n * @returns The bigint value represented by the hex string.\n */\nexport function hexToBigInt(hex: string): bigint {\n  // https://coolaj86.com/articles/convert-hex-to-decimal-with-js-bigints/\n  const value = BigInt(hex.length % 2 ? `0x0${hex}` : `0x${hex}`);\n  const highByte = Number.parseInt(hex.slice(0, 2), 16);\n  if (0x80 & highByte) return -negateAndMask(value);\n\n  return value;\n}\n\n/**\n * Serializes a `BigInt` to a hex string\n * @param value The bigint value to be serialized\n * @returns Hex representation for the provided `number`.\n */\nexport function bigIntToHex(value: bigint): string {\n  // implementation inspired on\n  // https://coolaj86.com/articles/convert-decimal-to-hex-with-js-bigints/\n  const positive = value >= _0n;\n  let hex = (positive ? value : negateAndMask(value)).toString(16);\n  if (hex.length % 2) hex = `0${hex}`;\n\n  if (positive && 0x80 & Number.parseInt(hex.slice(0, 2), 16)) {\n    return `00${hex}`;\n  }\n\n  return hex;\n}\n\n/**\n * Returns the two’s complement of a bigint value.\n * @param value The bigint value to negate.\n * @returns The two’s complement of `number` as a bigint.\n */\nexport function negateAndMask(value: bigint): bigint {\n  let val = value;\n  const negative = val < _0n;\n  if (negative) val = -val; // turn into a positive number\n\n  const bits = val.toString(2);\n  let len = bits.length; // convert to binary\n  const mod = len % 8;\n\n  if (mod > 0) {\n    len += 8 - mod;\n  } else if (negative && first(bits) === \"1\" && bits.indexOf(\"1\", 1) !== -1) {\n    len += 8;\n  }\n\n  const mask = (1n << BigInt(len)) - 1n; // create a mask\n  return (~val & mask) + 1n; // invert bits, mask it, and add one\n}\n","export const MIN_U8 = 0x00;\nexport const MAX_U8 = 0xff;\n\nexport const MIN_I8 = -0x80;\nexport const MAX_I8 = 0x7f;\n\nexport const MIN_I16 = -0x8000;\nexport const MAX_I16 = 0x7fff;\n\nexport const MIN_I32 = -0x80000000;\nexport const MAX_I32 = 0x7fffffff;\n\nexport const MIN_I64 = -BigInt(\"0x8000000000000000\");\nexport const MAX_I64 = BigInt(\"0x7fffffffffffffff\");\n\nexport const MIN_I256 = -BigInt(\n  \"0x8000000000000000000000000000000000000000000000000000000000000000\"\n);\n\nexport const MAX_I256 = BigInt(\n  \"0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\"\n);\n","import { _0n, _7n, _127n, _128n, ensureBigInt } from \"@fleet-sdk/common\";\nimport type { SigmaByteReader } from \"./sigmaByteReader\";\nimport type { SigmaByteWriter } from \"./sigmaByteWriter\";\n\n/**\n * A **variable-length quantity (VLQ)** is a universal code that uses an arbitrary number\n * of binary octets (eight-bit bytes) to represent an arbitrarily large integer. A VLQ\n * is essentially a base-128 representation of an unsigned integer with the addition of\n * the eighth bit to mark continuation of bytes. VLQ is identical to LEB128 except in\n * endianness. See the example below.\n */\n\n/**\n * Write an unsigned integer value as VLQ to a `SigmaByteWriter`.\n * @param value: Integer value\n * @param writer: Sigma writer\n * @returns Sigma writer passed as function argument.\n */\nexport function writeVLQ(writer: SigmaByteWriter, value: number): SigmaByteWriter {\n  // source: https://stackoverflow.com/a/3564685\n  if (value === 0) return writer.write(0);\n  if (value < 0) {\n    throw new RangeError(\"Variable Length Quantity not supported for negative numbers.\");\n  }\n\n  let val = value;\n  do {\n    let lower7bits = val & 0x7f;\n    val >>= 7;\n    if (val > 0) lower7bits |= 0x80;\n    writer.write(lower7bits);\n  } while (val > 0);\n\n  return writer;\n}\n\n/**\n * Decode VLQ bytes to an unsigned integer value\n * @param reader VLQ bytes\n * @returns Unsigned integer value\n */\nexport function readVLQ(reader: SigmaByteReader): number {\n  if (reader.isEmpty) {\n    return 0;\n  }\n\n  let value = 0;\n  let shift = 0;\n  let lower7bits = 0;\n\n  do {\n    lower7bits = reader.readByte();\n    value |= (lower7bits & 0x7f) << shift;\n    shift += 7;\n  } while ((lower7bits & 0x80) !== 0);\n\n  return value;\n}\n\n/**\n * Write an unsigned integer value as VLQ to a `SigmaByteWriter`.\n * @param value: Big integer value\n * @param writer: Sigma writer\n * @returns Sigma writer passed as function argument.\n */\nexport function writeBigVLQ(writer: SigmaByteWriter, value: bigint): SigmaByteWriter {\n  // source: https://stackoverflow.com/a/3564685\n\n  if (value === _0n) return writer.write(0);\n  if (value < _0n) {\n    throw new RangeError(\"Variable Length Quantity not supported for negative numbers\");\n  }\n\n  let val = value;\n  do {\n    let lower7bits = Number(val & _127n);\n    val >>= _7n;\n    if (val > 0) lower7bits |= 0x80;\n    writer.write(lower7bits);\n  } while (val > 0);\n\n  return writer;\n}\n\n/**\n * Decode VLQ bytes to an unsigned big integer value\n * @param reader VLQ bytes\n * @returns Unsigned integer value\n */\nexport function readBigVLQ(reader: SigmaByteReader): bigint {\n  if (reader.isEmpty) return _0n;\n\n  let value = _0n;\n  let shift = _0n;\n  let lower7bits: bigint;\n\n  do {\n    lower7bits = BigInt(reader.readByte());\n    value |= (lower7bits & _127n) << shift;\n    shift += _7n;\n  } while ((lower7bits & _128n) !== _0n);\n\n  return value;\n}\n\n/**\n * Estimates the byte size of a given unsigned integer.\n * @param value: the value to be evaluated.\n * @returns the byte size of the value.\n */\nexport function estimateVLQSize(value: number | bigint | string): number {\n  let size = 0;\n  let val = value;\n  if (typeof val === \"number\") {\n    do {\n      size++;\n      val = Math.floor(val / 128);\n    } while (val > 0);\n\n    return size;\n  }\n\n  val = ensureBigInt(val);\n  do {\n    size++;\n    val /= _128n;\n  } while (val > _0n);\n\n  return size;\n}\n","import { _1n, _63n } from \"@fleet-sdk/common\";\n\n/**\n * ZigZag encoding maps signed integers to unsigned integers so that numbers\n * with a small absolute value (for instance, -1) have a small variant encoded\n * value too. It does this in a way that \"zig-zags\" back and forth through the\n * positive and negative integers, so that -1 is encoded as 1, 1 is encoded as 2,\n * -2 is encoded as 3, and so on.\n * @see https://developers.google.com/protocol-buffers/docs/encoding#types\n */\n\nconst _31n = BigInt(31);\n\nconst u64 = (v: bigint) => BigInt.asUintN(64, v);\nconst i64 = (v: bigint) => BigInt.asIntN(64, v);\nconst i32 = (v: bigint) => BigInt.asIntN(32, v);\nconst u32 = (v: bigint) => BigInt.asUintN(32, v);\n\n/**\n * 32-bit ZigZag encoding.\n */\nexport const zigZag32 = {\n  encode: (input: bigint | number): bigint => {\n    const v = i32(BigInt(input));\n    return u64(i32(v << _1n) ^ i32(v >> _31n));\n  },\n  decode: (input: bigint): number => {\n    const v = u32(input);\n    return Number((v >> _1n) ^ -(v & _1n));\n  }\n};\n\n/**\n * 64-bit ZigZag encoding.\n */\nexport const zigZag64 = {\n  encode: (input: bigint): bigint => {\n    return u64((input << _1n) ^ (input >> _63n));\n  },\n  decode: (input: bigint): bigint => {\n    return i64((input >> _1n) ^ -(input & _1n));\n  }\n};\n","import { startsWith } from \"@fleet-sdk/common\";\nimport { type ByteInput, ensureBytes, hex } from \"@fleet-sdk/crypto\";\nimport { hexToBigInt } from \"./bigint\";\nimport { MAX_I8, MAX_U8 } from \"./numRanges\";\nimport { readBigVLQ, readVLQ } from \"./vlq\";\nimport { zigZag32, zigZag64 } from \"./zigZag\";\n\nexport class SigmaByteReader {\n  readonly #bytes: Uint8Array;\n  #cursor: number;\n\n  get isEmpty(): boolean {\n    return this.#bytes.length === this.#cursor;\n  }\n\n  get bytes(): Uint8Array {\n    return this.#bytes;\n  }\n\n  get cursor(): number {\n    return this.#cursor;\n  }\n\n  constructor(bytes: ByteInput) {\n    this.#bytes = ensureBytes(bytes);\n    this.#cursor = 0;\n  }\n\n  readArray<T>(readFn: (reader: SigmaByteReader, index: number) => T): Array<T> {\n    const length = this.readUInt();\n    const items = new Array<T>(length);\n\n    for (let i = 0; i < length; i++) {\n      items[i] = readFn(this, i);\n    }\n\n    return items;\n  }\n\n  readBool(): boolean {\n    return this.readByte() === 0x01;\n  }\n\n  readBits(length: number): ArrayLike<boolean> {\n    const bits = new Array<boolean>(length);\n    let bitOffset = 0;\n\n    for (let i = 0; i < length; i++) {\n      const bit = (this.#bytes[this.#cursor] >> bitOffset++) & 1;\n      bits[i] = bit === 1;\n\n      if (bitOffset === 8) {\n        bitOffset = 0;\n        this.#cursor++;\n      }\n    }\n\n    if (bitOffset > 0) this.#cursor++;\n\n    return bits;\n  }\n\n  readByte(): number {\n    return this.#bytes[this.#cursor++];\n  }\n\n  readBytes(length: number): Uint8Array {\n    return this.#bytes.subarray(this.#cursor, (this.#cursor += length));\n  }\n\n  readUInt(): number {\n    return readVLQ(this);\n  }\n\n  readBigUInt(): bigint {\n    return readBigVLQ(this);\n  }\n\n  readI8(): number {\n    const byte = this.readByte();\n    return byte > MAX_I8 ? byte - (MAX_U8 + 1) : byte;\n  }\n\n  readI16(): number {\n    return zigZag32.decode(readBigVLQ(this));\n  }\n\n  readI32(): number {\n    return zigZag32.decode(readBigVLQ(this));\n  }\n\n  readI64(): bigint {\n    return zigZag64.decode(readBigVLQ(this));\n  }\n\n  readI256(): bigint {\n    const len = readVLQ(this);\n    return hexToBigInt(hex.encode(this.readBytes(len)));\n  }\n\n  readRemainingBytes(): Uint8Array {\n    return this.readBytes(this.#bytes.length - this.#cursor);\n  }\n\n  readOption<T>(processor: (r: SigmaByteReader) => T): T | undefined {\n    if (this.readByte()) return processor(this);\n    return undefined;\n  }\n\n  /**\n   * Returns bytes without advancing the cursor.\n   */\n  peek(count: number, offset = 0): Uint8Array {\n    const begin = this.#cursor + offset;\n    return this.#bytes.subarray(begin, begin + count);\n  }\n\n  /**\n   * Checks if the current position in the byte array starts with the given bytes.\n   */\n  match(bytes: Uint8Array, offset = 0): boolean {\n    return startsWith(this.#bytes, bytes, this.#cursor + offset);\n  }\n}\n","import { type Coder, blake2b256, hex } from \"@fleet-sdk/crypto\";\nimport { bigIntToHex } from \"./bigint\";\nimport {\n  MAX_I16,\n  MAX_I32,\n  MAX_I64,\n  MAX_I256,\n  MIN_I16,\n  MIN_I32,\n  MIN_I64,\n  MIN_I256\n} from \"./numRanges\";\nimport { writeBigVLQ, writeVLQ } from \"./vlq\";\nimport { zigZag32, zigZag64 } from \"./zigZag\";\n\nexport class SigmaByteWriter {\n  readonly #bytes: Uint8Array;\n  #cursor: number;\n\n  get length() {\n    return this.#cursor;\n  }\n\n  constructor(length: number) {\n    this.#bytes = new Uint8Array(length);\n    this.#cursor = 0;\n  }\n\n  writeBool(value: boolean): SigmaByteWriter {\n    this.write(value === true ? 0x01 : 0x00);\n    return this;\n  }\n\n  writeUInt(value: number): SigmaByteWriter {\n    return writeVLQ(this, value);\n  }\n\n  writeBigUInt(value: bigint): SigmaByteWriter {\n    return writeBigVLQ(this, value);\n  }\n\n  writeI16(value: number): SigmaByteWriter {\n    if (value < MIN_I16 || value > MAX_I16) {\n      throw new RangeError(`Value ${value} is out of range for a 16-bit integer`);\n    }\n\n    this.writeBigUInt(zigZag32.encode(value));\n    return this;\n  }\n\n  writeI32(value: number): SigmaByteWriter {\n    if (value < MIN_I32 || value > MAX_I32) {\n      throw new RangeError(`Value ${value} is out of range for a 32-bit integer`);\n    }\n\n    return this.writeBigUInt(zigZag32.encode(value));\n  }\n\n  writeI64(value: bigint): SigmaByteWriter {\n    if (value < MIN_I64 || value > MAX_I64) {\n      throw new RangeError(`Value ${value} is out of range for a 64-bit integer`);\n    }\n\n    return this.writeBigUInt(zigZag64.encode(value));\n  }\n\n  writeI256(value: bigint): SigmaByteWriter {\n    if (value < MIN_I256 || value > MAX_I256) {\n      throw new RangeError(`Value ${value} is out of range for a 256-bit integer`);\n    }\n\n    const hex = bigIntToHex(value);\n    return this.writeUInt(hex.length / 2).writeHex(hex);\n  }\n\n  write(byte: number): SigmaByteWriter {\n    this.#bytes[this.#cursor++] = byte;\n    return this;\n  }\n\n  writeBytes(bytes: ArrayLike<number>): SigmaByteWriter {\n    this.#bytes.set(bytes, this.#cursor);\n    this.#cursor += bytes.length;\n    return this;\n  }\n\n  writeHex(bytesHex: string): SigmaByteWriter {\n    return this.writeBytes(hex.decode(bytesHex));\n  }\n\n  writeBits(bits: ArrayLike<boolean>): SigmaByteWriter {\n    let bitOffset = 0;\n\n    for (let i = 0; i < bits.length; i++) {\n      if (bits[i]) {\n        this.#bytes[this.#cursor] |= 1 << bitOffset++;\n      } else {\n        this.#bytes[this.#cursor] &= ~(1 << bitOffset++);\n      }\n\n      if (bitOffset === 8) {\n        bitOffset = 0;\n        this.#cursor++;\n      }\n    }\n\n    if (bitOffset > 0) this.#cursor++;\n\n    return this;\n  }\n\n  writeOption<T>(value: T | undefined, processor: (w: SigmaByteWriter) => void): SigmaByteWriter {\n    if (value === undefined) {\n      this.write(0x00); // write 0x00 for None\n      return this;\n    }\n\n    this.write(0x01); // write 0x01 for Some\n    processor(this); // call the inner writer to write the Option value\n\n    return this;\n  }\n\n  writeChecksum(length = 4, hashFn = blake2b256): SigmaByteWriter {\n    const hash = hashFn(this.toBytes());\n    return this.writeBytes(length ? hash.subarray(0, length) : hash);\n  }\n\n  /**\n   * Writes a length-delimited array of items to the byte stream using a provided\n   * serializer function.\n   *\n   * @typeParam T - The type of items in the array.\n   * @param items - The array of items to serialize and write.\n   * @param serializer - A function that serializes each item and writes it using the provided SigmaByteWriter.\n   * @returns The current instance of SigmaByteWriter for method chaining.\n   */\n  writeArray<T>(\n    items: T[],\n    serializer: (writer: SigmaByteWriter, item: T) => void\n  ): SigmaByteWriter {\n    this.writeUInt(items.length);\n    if (items.length === 0) return this;\n\n    for (const item of items) {\n      serializer(this, item);\n    }\n\n    return this;\n  }\n\n  encode<T>(coder: Coder<Uint8Array, T>): T {\n    return coder.encode(this.toBytes());\n  }\n\n  toBytes(): Uint8Array {\n    if (this.#cursor === this.#bytes.length) return this.#bytes;\n    return this.#bytes.subarray(0, this.#cursor);\n  }\n}\n","export abstract class SType<I = unknown, O = I> {\n  abstract get code(): number;\n  abstract get embeddable(): boolean;\n\n  coerce(data: I): O {\n    // a bit hacky but most of types will not need a specific coercion function.\n    return data as unknown as O;\n  }\n\n  abstract toString(): string;\n}\n\nexport abstract class SMonomorphicType<I, O = I> extends SType<I, O> {\n  abstract get code(): number;\n\n  get embeddable(): boolean {\n    return false;\n  }\n}\n\nexport abstract class SPrimitiveType<I, O = I> extends SMonomorphicType<I, O> {\n  abstract get code(): number;\n\n  override get embeddable(): boolean {\n    return true;\n  }\n}\n\nexport abstract class SGenericType<T extends SType | SType[]> extends SType {\n  readonly #internalType: T;\n\n  constructor(type: T) {\n    super();\n    this.#internalType = type;\n  }\n\n  abstract get code(): number;\n\n  get elementsType(): T {\n    return this.#internalType;\n  }\n\n  get embeddable(): boolean {\n    return false;\n  }\n}\n","import { ensureBigInt } from \"@fleet-sdk/common\";\nimport { hex } from \"@fleet-sdk/crypto\";\nimport type { SConstant } from \"../sigmaConstant\";\nimport { SPrimitiveType } from \"./base\";\nimport type { BigIntInput, ByteInput } from \"./constructors\";\n\nexport class SBoolType extends SPrimitiveType<boolean> {\n  get code(): 0x01 {\n    return 0x01;\n  }\n\n  toString(): string {\n    return \"SBool\";\n  }\n}\n\nexport class SByteType extends SPrimitiveType<number> {\n  get code(): 0x02 {\n    return 0x02;\n  }\n\n  toString(): string {\n    return \"SByte\";\n  }\n}\n\nexport class SShortType extends SPrimitiveType<number> {\n  get code(): 0x03 {\n    return 0x03;\n  }\n\n  toString(): string {\n    return \"SShort\";\n  }\n}\n\nexport class SIntType extends SPrimitiveType<number> {\n  get code(): 0x04 {\n    return 0x04;\n  }\n\n  toString(): string {\n    return \"SInt\";\n  }\n}\n\nexport class SLongType extends SPrimitiveType<BigIntInput, bigint> {\n  get code(): 0x05 {\n    return 0x05;\n  }\n\n  override coerce(data: BigIntInput): bigint {\n    return ensureBigInt(data);\n  }\n\n  toString(): string {\n    return \"SLong\";\n  }\n}\n\nexport class SBigIntType extends SPrimitiveType<string | bigint, bigint> {\n  get code(): number {\n    return 0x06;\n  }\n\n  override coerce(data: BigIntInput): bigint {\n    return ensureBigInt(data);\n  }\n\n  toString(): string {\n    return \"SBigInt\";\n  }\n}\n\nexport class SGroupElementType extends SPrimitiveType<ByteInput, Uint8Array> {\n  get code(): 0x07 {\n    return 0x07;\n  }\n\n  override coerce(data: ByteInput): Uint8Array {\n    return typeof data === \"string\" ? hex.decode(data) : data;\n  }\n\n  toString(): string {\n    return \"SGroupElement\";\n  }\n}\n\nexport class SSigmaPropType extends SPrimitiveType<SConstant<Uint8Array>> {\n  get code(): 0x08 {\n    return 0x08;\n  }\n\n  toString(): string {\n    return \"SSigmaProp\";\n  }\n}\n","import type { Box } from \"@fleet-sdk/common\";\nimport type { AvlTreeData } from \"../serializers/avlTreeSerializer\";\nimport type { SConstant } from \"../sigmaConstant\";\nimport { SMonomorphicType } from \"./base\";\n\nexport class SUnitType extends SMonomorphicType<undefined> {\n  get code(): 0x62 {\n    return 0x62;\n  }\n\n  toString(): string {\n    return \"SUnit\";\n  }\n}\n\nexport class SBoxType extends SMonomorphicType<SConstant<Box<bigint>>> {\n  get code(): 0x63 {\n    return 0x63;\n  }\n\n  toString(): string {\n    return \"SBox\";\n  }\n}\n\nexport class SAvlTreeType extends SMonomorphicType<AvlTreeData> {\n  get code(): 0x64 {\n    return 0x64;\n  }\n\n  toString(): string {\n    return \"SAvlTree\";\n  }\n}\n","import type { SType } from \"./base\";\nimport type { SCollType, STupleType } from \"./generics\";\nimport { SAvlTreeType, SBoxType, SUnitType } from \"./monomorphics\";\nimport {\n  SBigIntType,\n  SBoolType,\n  SByteType,\n  SGroupElementType,\n  SIntType,\n  SLongType,\n  SShortType,\n  SSigmaPropType\n} from \"./primitives\";\n\nexport const constructorCode = Object.freeze({\n  embeddable: 0,\n\n  simpleColl: 1,\n  nestedColl: 2,\n\n  option: 3,\n  optionCollection: 4,\n\n  pairOne: 5,\n  pairTwo: 6,\n  symmetricPair: 7,\n  genericTuple: 8\n});\n\nconst MAX_PRIMITIVE_TYPE_CODE = 0x0b;\nexport const PRIMITIVE_TYPE_RANGE = MAX_PRIMITIVE_TYPE_CODE + 0x01;\nconst typeCodeOf = (ctor: number) => PRIMITIVE_TYPE_RANGE * ctor;\n\ntype Descriptor = { code: number; embeddable: boolean };\n\nconst collDescriptor = Object.freeze({\n  code: typeCodeOf(constructorCode.simpleColl),\n  embeddable: false,\n  simpleCollTypeCode: typeCodeOf(constructorCode.simpleColl),\n  nestedCollTypeCode: typeCodeOf(constructorCode.nestedColl)\n}) satisfies Descriptor;\n\nconst tupleDescriptor = Object.freeze({\n  code: typeCodeOf(constructorCode.pairOne),\n  embeddable: false,\n  pairOneTypeCode: typeCodeOf(constructorCode.pairOne),\n  pairTwoTypeCode: typeCodeOf(constructorCode.pairTwo),\n  tripleTypeCode: typeCodeOf(constructorCode.pairTwo),\n  symmetricPairTypeCode: typeCodeOf(constructorCode.symmetricPair),\n  quadrupleTypeCode: typeCodeOf(constructorCode.symmetricPair),\n  genericTupleTypeCode: typeCodeOf(constructorCode.genericTuple)\n}) satisfies Descriptor;\n\nexport const descriptors = {\n  bool: new SBoolType(),\n  byte: new SByteType(),\n  short: new SShortType(),\n  int: new SIntType(),\n  long: new SLongType(),\n  bigInt: new SBigIntType(),\n  groupElement: new SGroupElementType(),\n  sigmaProp: new SSigmaPropType(),\n  unit: new SUnitType(),\n  box: new SBoxType(),\n  avlTree: new SAvlTreeType(),\n  coll: collDescriptor,\n  tuple: tupleDescriptor\n} satisfies { [key: string]: Descriptor };\n\nexport function isColl(type: SType): type is SCollType {\n  return (\n    type.code >= descriptors.coll.simpleCollTypeCode &&\n    type.code <= descriptors.coll.nestedCollTypeCode + MAX_PRIMITIVE_TYPE_CODE\n  );\n}\n\nexport function isTuple(type: SType): type is STupleType {\n  return (\n    type.code >= descriptors.tuple.pairOneTypeCode &&\n    type.code <= descriptors.tuple.genericTupleTypeCode\n  );\n}\n\nexport function getPrimitiveType(typeCode: number) {\n  switch (typeCode) {\n    case descriptors.bool.code:\n      return descriptors.bool;\n    case descriptors.byte.code:\n      return descriptors.byte;\n    case descriptors.short.code:\n      return descriptors.short;\n    case descriptors.int.code:\n      return descriptors.int;\n    case descriptors.long.code:\n      return descriptors.long;\n    case descriptors.bigInt.code:\n      return descriptors.bigInt;\n    case descriptors.groupElement.code:\n      return descriptors.groupElement;\n    case descriptors.sigmaProp.code:\n      return descriptors.sigmaProp;\n    default:\n      throw new Error(\n        `The type code '0x${typeCode.toString(16)}' is not a valid primitive type code.`\n      );\n  }\n}\n","import { hex } from \"@fleet-sdk/crypto\";\nimport { SGenericType, type SType } from \"./base\";\nimport { descriptors } from \"./descriptors\";\n\nexport class SCollType<T extends SType = SType> extends SGenericType<T> {\n  get code(): number {\n    return descriptors.coll.code;\n  }\n\n  override coerce<I, O>(elements: I[]): O[] | Uint8Array {\n    if (this.elementsType.code === descriptors.byte.code && !(elements instanceof Uint8Array)) {\n      return typeof elements === \"string\"\n        ? hex.decode(elements)\n        : Uint8Array.from(elements as ArrayLike<number>);\n    }\n\n    return elements.map((el) => this.elementsType.coerce(el)) as O[];\n  }\n\n  toString(): string {\n    return `SColl[${this.elementsType.toString()}]`;\n  }\n}\n\nexport class STupleType<T extends SType[] = SType[]> extends SGenericType<T> {\n  get code(): number {\n    return descriptors.tuple.code;\n  }\n\n  override coerce<I, O>(elements: I[]): O[] {\n    const output = new Array(elements.length);\n    for (let i = 0; i < elements.length; i++) {\n      output[i] = this.elementsType[i].coerce(elements[i]);\n    }\n\n    return output;\n  }\n\n  toString(): string {\n    return `(${this.elementsType.map((el) => el.toString()).join(\", \")})`;\n  }\n}\n","import { type Box, isEmpty } from \"@fleet-sdk/common\";\nimport type { AvlTreeData } from \"../serializers/avlTreeSerializer\";\nimport { SConstant } from \"../sigmaConstant\";\nimport type { SType } from \"./base\";\nimport { descriptors } from \"./descriptors\";\nimport { SCollType, STupleType } from \"./generics\";\nimport { SAvlTreeType, SBoxType, SUnitType } from \"./monomorphics\";\nimport {\n  SBigIntType,\n  SBoolType,\n  SByteType,\n  SGroupElementType,\n  SIntType,\n  SLongType,\n  SShortType,\n  SSigmaPropType\n} from \"./primitives\";\n\nexport type BigIntInput = string | bigint;\nexport type ByteInput = Uint8Array | string;\n\nexport type SConstructor<T = unknown, S extends SType = SType | SCollType<SType>> = (arg?: T) => S;\n\n// biome-ignore lint/suspicious/noExplicitAny: <explanation>\ntype Any = any;\n\ntype Constructable<T = Any> = { new (...args: Any): T };\ntype GenericProxyArgs<R> = R extends (...args: Any) => unknown ? Parameters<R> : [];\n\ntype SProxy<T extends SType, I, O = I> = {\n  (value: I): SConstant<O, T>;\n  (value?: I): T;\n};\n\n/**\n * Creates a proxy for monomorphic types, this allows constructor\n * functions to be equivalent to their corresponding type.\n *\n * This function will return one instance of `ctor` if not params as set.\n * Otherwise it will return an `SigmaConstant` instance of `ctor` type.\n *\n * @example\n * // SInt is a proxy for SIntType\n * (intConstant instanceof SInt) === true\n * (intConstant instanceof SIntType) === true\n * @param ctor Class to be proxied.\n * @param cache If defined, proxy will return this instead of a new instance of `ctor`.\n * @param forceConstruction If true, bypasses the constant creation and returns a type.\n * @returns\n */\nfunction monoProxy<T extends SType, I, O = I>(\n  ctor: Constructable<T>,\n  cache?: T,\n  forceConstruction?: boolean\n): SProxy<T, I, O> {\n  return new Proxy(ctor, {\n    apply: (target, _, args) => {\n      const instance = cache ?? new target();\n      if (!forceConstruction && isEmpty(args)) return instance;\n\n      return new (SConstant as Constructable)(instance, ...args);\n    }\n  }) as Any;\n}\n\n/**\n * Creates a proxy for generic types.\n */\nfunction genericProxy<T extends SType, R>(\n  ctor: Constructable<T>,\n  handler: (target: Constructable<T>, thisArgs: unknown, args: GenericProxyArgs<R>) => unknown\n) {\n  return new Proxy(ctor, {\n    apply: handler\n  }) as R;\n}\n\nexport const SByte = monoProxy<SByteType, number>(SByteType, descriptors.byte);\n\nexport const SBool = monoProxy<SBoolType, boolean>(SBoolType, descriptors.bool);\n\nexport const SShort = monoProxy<SShortType, number>(SShortType, descriptors.short);\n\nexport const SInt = monoProxy<SIntType, number>(SIntType, descriptors.int);\n\nexport const SLong = monoProxy<SLongType, BigIntInput, bigint>(SLongType, descriptors.long);\n\nexport const SBigInt = monoProxy<SBigIntType, BigIntInput, bigint>(SBigIntType, descriptors.bigInt);\n\nexport const SGroupElement = monoProxy<SGroupElementType, ByteInput, Uint8Array>(\n  SGroupElementType,\n  descriptors.groupElement\n);\n\nexport const SSigmaProp = monoProxy<SSigmaPropType, SConstant<Uint8Array>>(\n  SSigmaPropType,\n  descriptors.sigmaProp\n);\n\ntype SUnit = () => SConstant<undefined, SUnitType>;\nexport const SUnit = monoProxy(SUnitType, undefined, true) as unknown as SUnit;\n\ntype SBox = (value?: Box) => SConstant<Box<bigint>, SBoxType>;\nexport const SBox = monoProxy(SBoxType, undefined, true) as unknown as SBox;\n\ntype SAvlTree = (value?: AvlTreeData) => SConstant<AvlTreeData, SAvlTreeType>;\nexport const SAvlTree = monoProxy(SAvlTreeType, undefined, true) as unknown as SAvlTree;\n\ntype SColl = {\n  <D, T extends SByteType>(\n    type: SConstructor<D, T>,\n    elements: ByteInput | D[]\n  ): SConstant<Uint8Array, T>;\n  <D, T extends SByteType>(\n    type: SConstructor<D, T>,\n    elements: ByteInput[]\n  ): SConstant<Uint8Array[], T>;\n\n  <D, T extends SType>(type: SConstructor<D, T>): SConstructor<D[], T>;\n  <D, T extends SType>(type: SConstructor<D, T>, elements: D[]): SConstant<D[], T>;\n};\n\nexport const SColl = genericProxy<SCollType, SColl>(SCollType, (target, _, args) => {\n  const [type, elements] = args;\n  const elementsType = type();\n  if (!elements) return () => new target(elementsType);\n\n  return new SConstant(new target(elementsType), elements);\n});\n\nexport function STuple(...items: SConstant[]) {\n  return new SConstant(\n    new STupleType(items.map((x) => x.type)),\n    items.map((x) => x.data)\n  );\n}\n\ntype ByteInputOr<D, T extends SType> = T extends SByteType ? ByteInput | D : D;\ntype SPair = {\n  <L, R>(left: SConstant<L>, right: SConstant<R>): SConstant<[L, R], STupleType>;\n  <LD, RD, LT extends SType, RT extends SType>(\n    left: SConstructor<LD, LT>,\n    right: SConstructor<RD, RT>\n  ): SConstructor<[ByteInputOr<LD, LT>, ByteInputOr<RD, RT>]>;\n};\n\nexport const SPair = genericProxy<STupleType, SPair>(STupleType, (target, _, args) => {\n  const [left, right] = args;\n\n  if (typeof left === \"function\" && typeof right === \"function\") {\n    return () => new target([left(), right()]);\n  }\n\n  if (left instanceof SConstant && right instanceof SConstant) {\n    return new SConstant(new target([left.type, right.type]), [left.data, right.data]);\n  }\n\n  throw new Error(\"Invalid tuple declaration.\");\n});\n","import { hex } from \"@fleet-sdk/crypto\";\nimport { type SigmaByteReader, SigmaByteWriter } from \"../coders\";\n\nexport interface AvlTreeFlags {\n  insertAllowed: boolean;\n  updateAllowed: boolean;\n  removeAllowed: boolean;\n}\n\nexport interface AvlTreeData extends AvlTreeFlags {\n  digest: string;\n  keyLength: number;\n  valueLengthOpt?: number;\n}\n\nconst DIGEST_SIZE = 33;\n\nconst enum AvlTreeFlag {\n  InsertAllowed = 0x01,\n  UpdateAllowed = 0x02,\n  RemoveAllowed = 0x04\n}\n\nexport function serializeAvlTree(\n  data: AvlTreeData,\n  writer: SigmaByteWriter = new SigmaByteWriter(4_096)\n): SigmaByteWriter {\n  return writer // (DIGEST_SIZE + 1 + 4 + 1 + 4 /** flags, key len, opt flag, opt value */)\n    .writeBytes(hex.decode(data.digest))\n    .write(serializeFlags(data))\n    .writeUInt(data.keyLength)\n    .writeOption(data.valueLengthOpt, (w) => w.writeUInt(data.valueLengthOpt as number));\n}\n\nexport function deserializeAvlTree(reader: SigmaByteReader): AvlTreeData {\n  return {\n    digest: hex.encode(reader.readBytes(DIGEST_SIZE)),\n    ...parseFlags(reader.readByte()),\n    keyLength: reader.readUInt(),\n    valueLengthOpt: reader.readOption((r) => r.readUInt())\n  };\n}\n\nfunction parseFlags(byte: number): AvlTreeFlags {\n  return {\n    insertAllowed: (byte & AvlTreeFlag.InsertAllowed) !== 0,\n    updateAllowed: (byte & AvlTreeFlag.UpdateAllowed) !== 0,\n    removeAllowed: (byte & AvlTreeFlag.RemoveAllowed) !== 0\n  };\n}\n\nfunction serializeFlags(flags: AvlTreeFlags): number {\n  let byte = 0x0;\n  if (flags.insertAllowed) byte |= AvlTreeFlag.InsertAllowed;\n  if (flags.updateAllowed) byte |= AvlTreeFlag.UpdateAllowed;\n  if (flags.removeAllowed) byte |= AvlTreeFlag.RemoveAllowed;\n  return byte;\n}\n","import {\n  FEE_CONTRACT,\n  byteSizeOf,\n  ensureBigInt,\n  ergoTreeHeaderFlags,\n  isDefined,\n  isUndefined\n} from \"@fleet-sdk/common\";\nimport type {\n  Amount,\n  Box,\n  BoxCandidate,\n  NonMandatoryRegisters,\n  TokenAmount\n} from \"@fleet-sdk/common\";\nimport { blake2b256, hex, validateEcPoint } from \"@fleet-sdk/crypto\";\nimport { SigmaByteReader, SigmaByteWriter, estimateVLQSize } from \"../coders\";\nimport { SConstant } from \"../sigmaConstant\";\nimport type { ByteInput } from \"../types/constructors\";\n\nconst MAX_UINT16_VALUE = 65535;\n\nconst FEE_CONTRACT_BYTES = hex.decode(FEE_CONTRACT);\nconst P2PK_CONTRACT_PREFIX = hex.decode(\"0008cd\");\nconst COMPRESSED_PK_LENGTH = 33;\nconst P2PK_CONTRACT_LENGTH = P2PK_CONTRACT_PREFIX.length + COMPRESSED_PK_LENGTH;\n\nexport function serializeBox(\n  box: Box<Amount> | BoxCandidate<Amount>,\n  writer = new SigmaByteWriter(4_096),\n  distinctTokenIds?: string[]\n): SigmaByteWriter {\n  writer.writeBigUInt(ensureBigInt(box.value)).writeHex(box.ergoTree).writeUInt(box.creationHeight);\n\n  writeTokens(writer, box.assets, distinctTokenIds);\n  writeRegisters(writer, box.additionalRegisters);\n\n  if (isDefined(distinctTokenIds)) return writer;\n  if (!isBox(box)) throw new Error(\"Invalid box type.\");\n  return writer.writeHex(box.transactionId).writeUInt(box.index);\n}\n\nfunction isBox<T extends Amount>(box: Box<Amount> | BoxCandidate<Amount>): box is Box<T> {\n  const castedBox = box as Box<T>;\n  return isDefined(castedBox.transactionId) && isDefined(castedBox.index);\n}\n\nfunction writeTokens(\n  writer: SigmaByteWriter,\n  tokens: TokenAmount<Amount>[],\n  tokenIds?: string[]\n): void {\n  if (tokenIds) {\n    writer.writeArray(tokens, (w, token) =>\n      w.writeUInt(tokenIds.indexOf(token.tokenId)).writeBigUInt(ensureBigInt(token.amount))\n    );\n  } else {\n    writer.writeArray(tokens, (w, token) =>\n      w.writeHex(token.tokenId).writeBigUInt(ensureBigInt(token.amount))\n    );\n  }\n}\n\nfunction writeRegisters(writer: SigmaByteWriter, registers: NonMandatoryRegisters): void {\n  const keys = Object.keys(registers).sort();\n  const values: string[] = [];\n\n  for (const key of keys) {\n    const value = registers[key as keyof NonMandatoryRegisters];\n    if (!value) continue;\n\n    values.push(value);\n  }\n\n  writer.writeArray(values, (w, value) => w.writeHex(value));\n}\n\n/**\n * Estimates the byte size a box.\n * @returns byte size of the box.\n */\nexport function estimateBoxSize(\n  box: Box<Amount> | BoxCandidate<Amount>,\n  withValue?: Amount\n): number {\n  if (isUndefined(box.creationHeight)) {\n    throw new Error(\"Box size estimation error: creation height is undefined.\");\n  }\n\n  let size = 0;\n\n  size += estimateVLQSize(isDefined(withValue) ? withValue : box.value);\n  size += byteSizeOf(box.ergoTree);\n  size += estimateVLQSize(box.creationHeight);\n\n  size += estimateVLQSize(box.assets.length);\n  for (const asset of box.assets) {\n    size += byteSizeOf(asset.tokenId) + estimateVLQSize(asset.amount);\n  }\n\n  let registersLength = 0;\n  for (const key in box.additionalRegisters) {\n    const register = box.additionalRegisters[key as keyof NonMandatoryRegisters];\n    if (register) {\n      size += byteSizeOf(register);\n      registersLength++;\n    }\n  }\n\n  size += estimateVLQSize(registersLength);\n  size += 32; // transaction id (BLAKE2b 256 hash)\n  size += estimateVLQSize(isBox(box) ? box.index : MAX_UINT16_VALUE);\n\n  return size;\n}\n\n/**\n * Deserializes a box embedded in a transaction.\n *\n * It efficiently calculates the box ID by accumulating the serialized data during\n * deserialization and applying blake2b256 hashing, avoiding redundant serialization\n * operations.\n *\n * @param reader - SigmaByteReader containing the serialized box data\n * @param distinctTokenIds - Array of TokenIDs referenced in the parent transaction\n * @param transactionId - ID of the transaction containing this box\n * @param index - Index position of the box in the transaction outputs\n * @returns A fully deserialized Box with all properties including boxId\n */\nexport function deserializeEmbeddedBox(\n  reader: SigmaByteReader,\n  distinctTokenIds: string[],\n  transactionId: string,\n  index: number\n): Box<bigint> {\n  // SigmaByteReader moves the cursor on read, so we need to save the current position to\n  // track read bytes.\n  let begin = reader.cursor;\n\n  const value = reader.readBigUInt();\n  const ergoTree = hex.encode(readErgoTree(reader));\n  const creationHeight = reader.readUInt();\n\n  // Calculating the BoxID needs the full box data, so to avoid serialization road-trips,\n  // we will accumulate the the box data in a SigmaByteWriter and then calculate the hash\n  // from the its bytes.\n  const boxIdWriter = new SigmaByteWriter(4_096) // max size of a box\n    .writeBytes(reader.bytes.subarray(begin, reader.cursor)); // copy the bytes read so far\n\n  const assets = readTokens(reader, distinctTokenIds);\n\n  // TokenIDs need to be written in the full box writer\n  boxIdWriter.writeUInt(assets.length);\n  for (const asset of assets) {\n    boxIdWriter.writeHex(asset.tokenId).writeBigUInt(asset.amount);\n  }\n\n  begin = reader.cursor; // save the current cursor position again to track the registers bytes\n  const additionalRegisters = readRegisters(reader);\n\n  boxIdWriter\n    .writeBytes(reader.bytes.subarray(begin, reader.cursor)) // write the registers\n    .writeHex(transactionId)\n    .writeUInt(index);\n\n  return {\n    boxId: hex.encode(blake2b256(boxIdWriter.toBytes())),\n    value,\n    ergoTree,\n    creationHeight,\n    assets,\n    additionalRegisters,\n    transactionId,\n    index\n  };\n}\n\nexport function deserializeBox(\n  input: ByteInput | SigmaByteReader\n): BoxCandidate<bigint> | Box<bigint> {\n  const reader = input instanceof SigmaByteReader ? input : new SigmaByteReader(input);\n  const begin = reader.cursor; // save the current cursor position to track the read bytes\n\n  const box: Box<bigint> = {\n    boxId: \"\", // placeholder, will be calculated later\n    value: reader.readBigUInt(),\n    ergoTree: hex.encode(readErgoTree(reader)),\n    creationHeight: reader.readUInt(),\n    assets: readTokens(reader),\n    additionalRegisters: readRegisters(reader),\n    transactionId: hex.encode(reader.readBytes(32)),\n    index: reader.readUInt()\n  };\n\n  box.boxId = hex.encode(blake2b256(reader.bytes.subarray(begin, reader.cursor)));\n  return box;\n}\n\nfunction readErgoTree(reader: SigmaByteReader): Uint8Array {\n  // handles miner fee contract\n  if (reader.match(FEE_CONTRACT_BYTES)) {\n    return reader.readBytes(FEE_CONTRACT_BYTES.length);\n  }\n\n  // handles P2PK contracts\n  if (\n    reader.match(P2PK_CONTRACT_PREFIX) &&\n    validateEcPoint(reader.peek(COMPRESSED_PK_LENGTH, P2PK_CONTRACT_PREFIX.length))\n  ) {\n    return reader.readBytes(P2PK_CONTRACT_LENGTH);\n  }\n\n  // handles contracts with the size flag enabled\n  const header = reader.readByte();\n  const hasSize = (header & ergoTreeHeaderFlags.sizeInclusion) !== 0;\n  if (!hasSize) {\n    throw new Error(\"ErgoTree parsing without the size flag is not supported.\");\n  }\n\n  const size = reader.readUInt();\n  return new SigmaByteWriter(1 + 4 + size) // header + vlq size + body\n    .write(header)\n    .writeUInt(size)\n    .writeBytes(reader.readBytes(size))\n    .toBytes();\n}\n\nfunction readTokens(reader: SigmaByteReader, tokenIds?: string[]): TokenAmount<bigint>[] {\n  return reader.readArray((r) => ({\n    tokenId: tokenIds ? tokenIds[r.readUInt()] : hex.encode(r.readBytes(32)),\n    amount: r.readBigUInt()\n  }));\n}\n\nfunction readRegisters(reader: SigmaByteReader): NonMandatoryRegisters {\n  const registers: NonMandatoryRegisters = {};\n  const count = reader.readUInt();\n\n  for (let i = 0; i < count; i++) {\n    // const key = reader.readByte();\n    const value = SConstant.from(reader).toHex();\n    registers[`R${(i + 4).toString()}` as keyof NonMandatoryRegisters] = value;\n  }\n\n  return registers;\n}\n","import { assert, type Box } from \"@fleet-sdk/common\";\nimport type { SigmaByteReader, SigmaByteWriter } from \"../coders\";\nimport type { SConstant } from \"../sigmaConstant\";\nimport { type SCollType, type STupleType, type SType, isColl, isTuple } from \"../types\";\nimport { descriptors } from \"../types/descriptors\";\nimport { type AvlTreeData, deserializeAvlTree, serializeAvlTree } from \"./avlTreeSerializer\";\nimport { deserializeBox, serializeBox } from \"./boxSerializer\";\n\nconst GROUP_ELEMENT_LENGTH = 33;\nconst PROVE_DLOG_OP = 0xcd;\n\nexport const dataSerializer = {\n  serialize(data: unknown, type: SType, writer: SigmaByteWriter): SigmaByteWriter {\n    if (type.embeddable) {\n      switch (type.code) {\n        case descriptors.bool.code:\n          return writer.writeBool(data as boolean);\n        case descriptors.byte.code:\n          return writer.write(data as number);\n        case descriptors.short.code:\n          return writer.writeI16(data as number);\n        case descriptors.int.code:\n          return writer.writeI32(data as number);\n        case descriptors.long.code:\n          return writer.writeI64(data as bigint);\n        case descriptors.bigInt.code:\n          return writer.writeI256(data as bigint);\n        case descriptors.groupElement.code:\n          return writer.writeBytes(data as Uint8Array);\n        case descriptors.sigmaProp.code: {\n          const node = data as SConstant<SConstant<Uint8Array>>;\n          if (node.type === descriptors.groupElement) {\n            writer.write(PROVE_DLOG_OP);\n            return dataSerializer.serialize(node.data, node.type, writer);\n          }\n\n          throw Error(\"Serialization error: SigmaProp operation not implemented.\");\n        }\n      }\n    }\n\n    if (isColl(type)) {\n      if (type.elementsType.code === descriptors.byte.code) {\n        assert(\n          data instanceof Uint8Array,\n          `SColl[Byte] expected an UInt8Array, got ${typeof data}.`\n        );\n      } else {\n        assert(Array.isArray(data), `SColl expected an array, got ${typeof data}.`);\n      }\n\n      writer.writeUInt(data.length);\n      switch (type.elementsType.code) {\n        case descriptors.bool.code: {\n          return writer.writeBits(data as boolean[]);\n        }\n        case descriptors.byte.code: {\n          return writer.writeBytes(data as Uint8Array);\n        }\n        default: {\n          for (let i = 0; i < data.length; i++) {\n            dataSerializer.serialize(data[i], type.elementsType, writer);\n          }\n\n          return writer;\n        }\n      }\n    }\n\n    if (isTuple(type)) {\n      assert(\n        Array.isArray(data),\n        `STupleType serialization expected an array, got ${typeof data}.`\n      );\n\n      const len = type.elementsType.length;\n      for (let i = 0; i < len; i++) {\n        dataSerializer.serialize(data[i], type.elementsType[i], writer);\n      }\n\n      return writer;\n    }\n\n    if (type.code === descriptors.unit.code) return writer;\n    if (type.code === descriptors.box.code) return serializeBox(data as Box, writer);\n    if (type.code === descriptors.avlTree.code) {\n      return serializeAvlTree(data as AvlTreeData, writer);\n    }\n\n    throw Error(`Serialization error: '0x${type.code.toString(16)}' type not implemented.`);\n  },\n\n  deserialize(type: SType, reader: SigmaByteReader): unknown {\n    if (type.embeddable) {\n      switch (type.code) {\n        case descriptors.bool.code:\n          return reader.readBool();\n        case descriptors.byte.code:\n          return reader.readI8();\n        case descriptors.short.code:\n          return reader.readI16();\n        case descriptors.int.code:\n          return reader.readI32();\n        case descriptors.long.code:\n          return reader.readI64();\n        case descriptors.bigInt.code:\n          return reader.readI256();\n        case descriptors.groupElement.code:\n          return reader.readBytes(GROUP_ELEMENT_LENGTH);\n        case descriptors.sigmaProp.code: {\n          if (reader.readByte() === PROVE_DLOG_OP) {\n            return this.deserialize(descriptors.groupElement, reader);\n          }\n\n          break;\n        }\n      }\n    } else {\n      switch (type.code) {\n        case descriptors.coll.code: {\n          const length = reader.readUInt();\n          const embeddedType = (type as SCollType).elementsType;\n\n          switch (embeddedType.code) {\n            case descriptors.bool.code:\n              return reader.readBits(length);\n            case descriptors.byte.code:\n              return reader.readBytes(length);\n            default: {\n              const elements = new Array(length);\n              for (let i = 0; i < length; i++) {\n                elements[i] = this.deserialize(embeddedType, reader);\n              }\n\n              return elements;\n            }\n          }\n        }\n        case descriptors.tuple.code: {\n          return (type as STupleType).elementsType.map((t) => this.deserialize(t, reader));\n        }\n        case descriptors.unit.code:\n          return undefined;\n        case descriptors.box.code:\n          return deserializeBox(reader);\n        case descriptors.avlTree.code:\n          return deserializeAvlTree(reader);\n      }\n    }\n\n    throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);\n  }\n};\n","import { assert, first, last } from \"@fleet-sdk/common\";\nimport type { SigmaByteReader, SigmaByteWriter } from \"../coders\";\nimport { SCollType, STupleType, type SType, isColl, isTuple } from \"../types\";\nimport {\n  PRIMITIVE_TYPE_RANGE,\n  constructorCode,\n  descriptors,\n  getPrimitiveType\n} from \"../types/descriptors\";\n\nexport const typeSerializer = {\n  serialize(type: SType, writer: SigmaByteWriter) {\n    if (type.embeddable) {\n      writer.write(type.code);\n    } else if (type.code === descriptors.unit.code) {\n      writer.write(type.code);\n    } else if (type.code === descriptors.box.code) {\n      writer.write(type.code);\n    } else if (type.code === descriptors.avlTree.code) {\n      writer.write(type.code);\n    } else if (isColl(type)) {\n      if (type.elementsType.embeddable) {\n        writer.write(descriptors.coll.simpleCollTypeCode + type.elementsType.code);\n      } else if (isColl(type.elementsType)) {\n        const nestedColl = type.elementsType;\n        if (nestedColl.elementsType.embeddable) {\n          writer.write(descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code);\n        } else {\n          writer.write(descriptors.coll.simpleCollTypeCode);\n          this.serialize(nestedColl, writer);\n        }\n      } else {\n        writer.write(descriptors.coll.simpleCollTypeCode);\n        this.serialize(type.elementsType, writer);\n      }\n    } else if (isTuple(type)) {\n      switch (type.elementsType.length) {\n        case 2: {\n          const left = first(type.elementsType);\n          const right = last(type.elementsType);\n\n          if (left.embeddable) {\n            if (left.code === right.code) {\n              // Symmetric pair of primitive types (`(Int, Int)`, `(Byte,Byte)`, etc.)\n              writer.write(descriptors.tuple.symmetricPairTypeCode + left.code);\n            } else {\n              // Pair of types where first is primitive (`(_, Int)`)\n              writer.write(descriptors.tuple.pairOneTypeCode + left.code);\n              this.serialize(right, writer);\n            }\n          } else if (right.embeddable) {\n            // Pair of types where second is primitive (`(Int, _)`)\n            writer.write(descriptors.tuple.pairTwoTypeCode + right.code);\n            this.serialize(left, writer);\n          } else {\n            // Pair of non-primitive types (`((Int, Byte), (Boolean,Box))`, etc.)\n            writer.write(descriptors.tuple.pairOneTypeCode);\n            this.serialize(left, writer);\n            this.serialize(right, writer);\n          }\n\n          return;\n        }\n        case 3:\n          writer.write(descriptors.tuple.tripleTypeCode);\n          break;\n        case 4:\n          writer.write(descriptors.tuple.quadrupleTypeCode);\n          break;\n        default: {\n          const len = type.elementsType.length;\n          assert(len >= 2 && len <= 255, \"Invalid type: tuples must have between 2 and 255 items.\");\n\n          // Generic tuple\n          writer.write(descriptors.tuple.genericTupleTypeCode);\n          writer.writeUInt(len);\n        }\n      }\n\n      for (let i = 0; i < type.elementsType.length; i++) {\n        this.serialize(type.elementsType[i], writer);\n      }\n    } else {\n      throw new Error(\"Serialization error: type not implemented.\");\n    }\n  },\n\n  deserialize(r: SigmaByteReader): SType {\n    const byte = r.readByte();\n    assert(byte > 0, `Parsing Error: Unexpected type code '0x${byte.toString(16)}'`);\n\n    if (byte < descriptors.tuple.genericTupleTypeCode) {\n      const ctorCode = Math.floor(byte / PRIMITIVE_TYPE_RANGE);\n      const embdCode = Math.floor(byte % PRIMITIVE_TYPE_RANGE);\n\n      switch (ctorCode) {\n        case constructorCode.embeddable: {\n          return getPrimitiveType(embdCode);\n        }\n        case constructorCode.simpleColl: {\n          const internal = embdCode === 0 ? this.deserialize(r) : getPrimitiveType(embdCode);\n\n          return new SCollType(internal);\n        }\n        case constructorCode.nestedColl: {\n          return new SCollType(new SCollType(getPrimitiveType(embdCode)));\n        }\n        case constructorCode.pairOne: {\n          const internal =\n            embdCode === 0\n              ? [this.deserialize(r), this.deserialize(r)] // Pair of non-primitive types (`((Int, Byte), (Boolean,Box))`, etc.)\n              : [getPrimitiveType(embdCode), this.deserialize(r)]; // Pair of types where first is primitive (`(_, Int)`)\n\n          return new STupleType(internal);\n        }\n        case constructorCode.pairTwo: {\n          const internal =\n            embdCode === 0\n              ? [this.deserialize(r), this.deserialize(r), this.deserialize(r)] // Triple of types\n              : [this.deserialize(r), getPrimitiveType(embdCode)];\n\n          return new STupleType(internal);\n        }\n        case constructorCode.symmetricPair: {\n          const internal =\n            embdCode === 0\n              ? [this.deserialize(r), this.deserialize(r), this.deserialize(r), this.deserialize(r)] // Quadruple of types\n              : [getPrimitiveType(embdCode), getPrimitiveType(embdCode)]; // Symmetric pair of primitive types (`(Int, Int)`, `(Byte,Byte)`, etc.)\n\n          return new STupleType(internal);\n        }\n      }\n    }\n\n    switch (byte) {\n      case descriptors.tuple.genericTupleTypeCode: {\n        const len = r.readUInt();\n        const wrapped = new Array<SType>(len);\n        for (let i = 0; i < len; i++) {\n          wrapped[i] = this.deserialize(r);\n        }\n\n        return new STupleType(wrapped);\n      }\n      case descriptors.unit.code:\n        return descriptors.unit;\n      case descriptors.box.code:\n        return descriptors.box;\n      case descriptors.avlTree.code:\n        return descriptors.avlTree;\n    }\n\n    throw new Error(\"Not implemented.\");\n  }\n};\n","import { type ByteInput, hex } from \"@fleet-sdk/crypto\";\nimport { SigmaByteReader, SigmaByteWriter, estimateVLQSize } from \"./coders\";\nimport { dataSerializer } from \"./serializers/dataSerializer\";\nimport { typeSerializer } from \"./serializers/typeSerializer\";\nimport type { SCollType, SType } from \"./types\";\nimport { descriptors, isColl, isTuple } from \"./types/descriptors\";\n\nexport const MAX_CONSTANT_LENGTH = 4096;\n\nexport class SConstant<D = unknown, T extends SType = SType> {\n  readonly #type: T;\n  readonly #data: D;\n  #bytes?: Uint8Array;\n\n  constructor(type: T, data: D) {\n    this.#type = type;\n    this.#data = type.coerce(data) as D;\n  }\n\n  static from<D, T extends SType = SType>(bytes: ByteInput | SigmaByteReader): SConstant<D, T> {\n    const reader = bytes instanceof SigmaByteReader ? bytes : new SigmaByteReader(bytes);\n    if (reader.isEmpty) throw new Error(\"Empty constant bytes.\");\n\n    const start = reader.cursor;\n    const type = typeSerializer.deserialize(reader);\n    const data = dataSerializer.deserialize(type, reader);\n    return new SConstant(type as T, data as D).#withBytes(reader.bytes.slice(start, reader.cursor));\n  }\n\n  #withBytes(bytes: Uint8Array): SConstant<D, T> {\n    this.#bytes = bytes;\n    return this;\n  }\n\n  get type(): T {\n    return this.#type;\n  }\n\n  get data(): D {\n    return this.#data;\n  }\n\n  /**\n   * Returns the serialized representation of the current instance as a `Uint8Array`.\n   * If the bytes have already been computed and cached, returns the cached value.\n   * Otherwise, serializes the instance and returns the resulting bytes.\n   */\n  get bytes(): Uint8Array {\n    if (this.#bytes) return this.#bytes;\n    return this.serialize();\n  }\n\n  /**\n   * Serializes the current object into a `Uint8Array`.\n   */\n  serialize(): Uint8Array {\n    const writer = new SigmaByteWriter(guessConstantBytesSize(this.type, this.data));\n    typeSerializer.serialize(this.type, writer);\n    dataSerializer.serialize(this.data, this.type, writer);\n\n    this.#bytes = writer.toBytes();\n    return this.#bytes;\n  }\n\n  /**\n   * @deprecated use `serialize` instead\n   */\n  toBytes(): Uint8Array {\n    return this.serialize();\n  }\n\n  toHex(): string {\n    return hex.encode(this.serialize());\n  }\n}\n\nfunction guessConstantBytesSize(type: SType, data?: unknown): number {\n  const dataSize = 1;\n\n  // left some safe room for integer types\n  if (type.code === descriptors.short.code) return dataSize + 8;\n  if (type.code === descriptors.int.code) return dataSize + 16;\n  if (type.code === descriptors.long.code) return dataSize + 32;\n  if (type.code === descriptors.bigInt.code) return dataSize + 64;\n\n  if (type.code === descriptors.bool.code) return dataSize + 1;\n  if (type.code === descriptors.byte.code) return dataSize + 1;\n  if (type.code === descriptors.unit.code) return dataSize + 0;\n  if (type.code === descriptors.groupElement.code) return dataSize + 33;\n  if (type.code === descriptors.sigmaProp.code) return dataSize + 35; // only prove DLog is implemented, so it's safe to assume 35 bytes\n\n  // handle collections, but avoid complex types\n  if (isColl(type) && !isColl(type.elementsType) && !isTuple(type.elementsType)) {\n    const len = (data as Uint8Array).length;\n    return (\n      dataSize +\n      estimateVLQSize(len) +\n      guessConstantBytesSize((type as SCollType).elementsType) * len\n    );\n  }\n\n  return MAX_CONSTANT_LENGTH;\n}\n\n/**\n * Decodes a byte input into a Sigma constant of type `SConstant<D, T>`.\n *\n * @template D - The data type of the constant.\n * @template T - The type of the constant.\n * @param value - The value to decode.\n * @returns The decoded constant or `undefined` if the value is `undefined` or decoding fails.\n */\nexport function decode<D = unknown, T extends SType = SType>(\n  value?: ByteInput\n): SConstant<D, T> | undefined {\n  if (value === undefined) return;\n\n  try {\n    return SConstant.from<D, T>(value);\n  } catch {\n    return;\n  }\n}\n\n/**\n * Returns the `SType` of the given value.\n *\n * @param value - The value to check the SType of.\n * @returns The SType of the value, or `undefined` if the value is `undefined` or\n * deserialization fails.\n */\nexport function stypeof(value?: ByteInput): SType | undefined {\n  if (!value) return;\n\n  try {\n    return typeSerializer.deserialize(new SigmaByteReader(value));\n  } catch {\n    return;\n  }\n}\n\n/** @deprecated use `decode` instead */\nexport function parse<T>(constant: ByteInput): T;\n/** @deprecated use `decode` instead */\nexport function parse<T>(constant: ByteInput, mode: \"strict\"): T;\n/** @deprecated use `decode` instead */\nexport function parse<T>(constant: ByteInput | undefined, mode: \"safe\"): T | undefined;\n/** @deprecated use `decode` instead */\nexport function parse<T>(constant: ByteInput | undefined, mode: \"strict\" | \"safe\" = \"strict\") {\n  if (mode === \"strict\") return SConstant.from<T>(constant ?? \"\").data;\n  if (!constant) return;\n\n  try {\n    return SConstant.from<T>(constant).data;\n  } catch {\n    return;\n  }\n}\n","import type {\n  Amount,\n  BoxCandidate,\n  SignedInput,\n  SignedTransaction,\n  UnsignedInput,\n  UnsignedTransaction\n} from \"@fleet-sdk/common\";\nimport { blake2b256, hex } from \"@fleet-sdk/crypto\";\nimport { SigmaByteReader, SigmaByteWriter } from \"../coders\";\nimport { SConstant } from \"../sigmaConstant\";\nimport type { ByteInput } from \"../types/constructors\";\nimport { deserializeEmbeddedBox, serializeBox } from \"./boxSerializer\";\n\ntype Nullish<T> = T | null | undefined;\ntype Input = UnsignedInput | SignedInput;\ntype Transaction = UnsignedTransaction | SignedTransaction;\n\nexport function serializeTransaction(transaction: Transaction): SigmaByteWriter {\n  const tokenIds = getDistinctTokenIds(transaction.outputs);\n\n  return new SigmaByteWriter(100_000)\n    .writeArray<Input>(transaction.inputs, (w, input) => writeInput(w, input))\n    .writeArray(transaction.dataInputs, (w, dataInput) => w.writeHex(dataInput.boxId))\n    .writeArray(tokenIds, (w, tokenId) => w.writeHex(tokenId))\n    .writeArray(transaction.outputs, (w, output) => serializeBox(output, w, tokenIds));\n}\n\nfunction writeInput(writer: SigmaByteWriter, input: Input): void {\n  if (isSignedInput(input)) {\n    writeSignedInput(writer, input);\n    return;\n  }\n\n  writeUnsignedInput(writer, input);\n}\n\nfunction writeSignedInput(writer: SigmaByteWriter, input: SignedInput): void {\n  writer.writeHex(input.boxId);\n  writeProof(writer, input.spendingProof?.proofBytes);\n  writeExtension(writer, input.spendingProof?.extension);\n}\n\nfunction writeUnsignedInput(writer: SigmaByteWriter, input: Input): void {\n  writer.writeHex(input.boxId);\n  writeProof(writer, null);\n  writeExtension(writer, isSignedInput(input) ? input.spendingProof?.extension : input.extension);\n}\n\nfunction isSignedInput(input: Input): input is SignedInput {\n  return (input as SignedInput).spendingProof !== undefined;\n}\n\nfunction writeProof(writer: SigmaByteWriter, proof: Nullish<string>): void {\n  if (!proof) {\n    writer.write(0);\n    return;\n  }\n\n  const bytes = hex.decode(proof);\n  writer.writeUInt(bytes.length).writeBytes(bytes);\n}\n\nfunction writeExtension(\n  writer: SigmaByteWriter,\n  extension: Nullish<Record<string, string | undefined>>\n): void {\n  if (!extension) {\n    writer.write(0);\n    return;\n  }\n\n  const keys = Object.keys(extension);\n  const values: [string, string][] = [];\n\n  for (const key of keys) {\n    const value = extension[key];\n    if (!value) continue;\n\n    values.push([key, value]);\n  }\n\n  writer.writeArray(values, (w, [key, value]) => w.writeUInt(Number(key)).writeHex(value));\n}\n\nfunction getDistinctTokenIds(outputs: readonly BoxCandidate<Amount>[]) {\n  const tokenIds = new Set<string>();\n  outputs.flatMap((output) => output.assets.map((asset) => tokenIds.add(asset.tokenId)));\n\n  return Array.from(tokenIds);\n}\n\nexport function deserializeTransaction<T extends Transaction>(input: ByteInput): T {\n  const reader = new SigmaByteReader(input);\n\n  const inputs = reader.readArray(readInput);\n  const id = computeId(reader, inputs);\n  const dataInputs = reader.readArray((r) => ({ boxId: hex.encode(r.readBytes(32)) }));\n  const tokenIds = reader.readArray((r) => hex.encode(r.readBytes(32)));\n  const outputs = reader.readArray((r, i) => deserializeEmbeddedBox(r, tokenIds, id, i));\n\n  return {\n    id,\n    inputs,\n    dataInputs,\n    outputs\n  } as T;\n}\n\nfunction readInput(reader: SigmaByteReader): SignedInput | UnsignedInput {\n  const boxId = hex.encode(reader.readBytes(32));\n\n  const proofLength = reader.readUInt();\n  const proofBytes = proofLength > 0 ? hex.encode(reader.readBytes(proofLength)) : null;\n\n  const extensionLength = reader.readUInt();\n  const extension: Record<string, string> = {};\n  for (let i = 0; i < extensionLength; i++) {\n    extension[reader.readUInt()] = SConstant.from(reader).toHex();\n  }\n\n  return proofBytes ? { boxId, spendingProof: { proofBytes, extension } } : { boxId, extension };\n}\n\n/**\n * Computes the transaction ID by serializing inputs as unsigned (excluding proofs),\n * even for signed transactions.\n */\nfunction computeId(reader: SigmaByteReader, inputs: Input[]): string {\n  const bytes = new SigmaByteWriter(reader.bytes.length)\n    .writeArray(inputs, (w, input) => writeUnsignedInput(w, input)) // write inputs as unsigned\n    .writeBytes(reader.bytes.subarray(reader.cursor))\n    .toBytes();\n\n  return hex.encode(blake2b256(bytes));\n}\n"]}