@fleet-sdk/serializer 0.8.5 → 0.9.0

package/dist/index.mjs

@@ -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,22 +143,6 @@ 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;
@@ -214,6 +214,9 @@ 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.
    */
@@ -319,7 +322,7 @@ var SigmaByteWriter = class {
     this.writeUInt(items.length);
     if (items.length === 0) return this;
     for (const item of items) {
-      serializer(item, this);
+      serializer(this, item);
     }
     return this;
   }
@@ -575,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
@@ -630,12 +627,12 @@ function writeTokens(writer, tokens, tokenIds) {
   if (tokenIds) {
     writer.writeArray(
       tokens,
-      (token, w) => w.writeUInt(tokenIds.indexOf(token.tokenId)).writeBigUInt(ensureBigInt(token.amount))
+      (w, token) => w.writeUInt(tokenIds.indexOf(token.tokenId)).writeBigUInt(ensureBigInt(token.amount))
     );
   } else {
     writer.writeArray(
       tokens,
-      (token, w) => w.writeHex(token.tokenId).writeBigUInt(ensureBigInt(token.amount))
+      (w, token) => w.writeHex(token.tokenId).writeBigUInt(ensureBigInt(token.amount))
     );
   }
 }
@@ -647,7 +644,7 @@ function writeRegisters(writer, registers) {
     if (!value) continue;
     values.push(value);
   }
-  writer.writeArray(values, (value, w) => w.writeHex(value));
+  writer.writeArray(values, (w, value) => w.writeHex(value));
 }
 function estimateBoxSize(box, withValue) {
   if (isUndefined(box.creationHeight)) {
@@ -816,9 +813,7 @@ var dataSerializer = {
     }
     if (type.code === descriptors.unit.code) return writer;
     if (type.code === descriptors.box.code) return serializeBox(data, writer);
-    throw Error(
-      `Serialization error: '0x${type.code.toString(16)}' type not implemented.`
-    );
+    throw Error(`Serialization error: '0x${type.code.toString(16)}' type not implemented.`);
   },
   deserialize(type, reader) {
     if (type.embeddable) {
@@ -864,9 +859,7 @@ 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;
@@ -891,9 +884,7 @@ var typeSerializer = {
       } 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);
@@ -932,10 +923,7 @@ 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.writeUInt(len);
         }
@@ -973,12 +961,7 @@ 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);
         }
       }
@@ -1006,6 +989,7 @@ var MAX_CONSTANT_LENGTH = 4096;
 var SConstant = class _SConstant {
   #type;
   #data;
+  #bytes;
   constructor(type, data) {
     this.#type = type;
     this.#data = type.coerce(data);
@@ -1013,9 +997,14 @@ var SConstant = class _SConstant {
   static from(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;
@@ -1023,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 {
@@ -1060,7 +1085,7 @@ function parse(constant, mode = "strict") {
 }
 function serializeTransaction(transaction) {
   const tokenIds = getDistinctTokenIds(transaction.outputs);
-  return new SigmaByteWriter(1e5).writeArray(transaction.inputs, (input, w) => writeInput(w, input)).writeArray(transaction.dataInputs, (dataInput, w) => w.writeHex(dataInput.boxId)).writeArray(tokenIds, (tokenId, w) => w.writeHex(tokenId)).writeArray(transaction.outputs, (output, w) => serializeBox(output, w, tokenIds));
+  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) {
   if (isSignedInput(input)) {
@@ -1077,10 +1102,7 @@ function writeSignedInput(writer, input) {
 function writeUnsignedInput(writer, input) {
   writer.writeHex(input.boxId);
   writeProof(writer, null);
-  writeExtension(
-    writer,
-    isSignedInput(input) ? input.spendingProof?.extension : input.extension
-  );
+  writeExtension(writer, isSignedInput(input) ? input.spendingProof?.extension : input.extension);
 }
 function isSignedInput(input) {
   return input.spendingProof !== void 0;
@@ -1105,10 +1127,7 @@ function writeExtension(writer, extension) {
     if (!value) continue;
     values.push([key, value]);
   }
-  writer.writeArray(
-    values,
-    ([key, value], w) => w.writeUInt(Number(key)).writeHex(value)
-  );
+  writer.writeArray(values, (w, [key, value]) => w.writeUInt(Number(key)).writeHex(value));
 }
 function getDistinctTokenIds(outputs) {
   const tokenIds = /* @__PURE__ */ new Set();
@@ -1141,7 +1160,7 @@ function readInput(reader) {
   return proofBytes ? { boxId, spendingProof: { proofBytes, extension } } : { boxId, extension };
 }
 function computeId(reader, inputs) {
-  const bytes = new SigmaByteWriter(reader.bytes.length).writeArray(inputs, (input, writer) => writeUnsignedInput(writer, input)).writeBytes(reader.bytes.subarray(reader.cursor)).toBytes();
+  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));
 }