@fleet-sdk/serializer 0.8.0 → 0.8.3

package/dist/index.mjs

@@ -1,21 +1,21 @@
-import { ensureBigInt, _0n, _128n, isEmpty, assert, first, last, isDefined, some, isUndefined, byteSizeOf, _7n, _1n, _63n, _127n } from '@fleet-sdk/common';
-import { ensureBytes, hex, blake2b256 } from '@fleet-sdk/crypto';
+import { isEmpty, assert, first, last, _1n, _0n, _128n, ensureBigInt, _7n, _127n, _63n, isDefined, some, isUndefined, byteSizeOf } from '@fleet-sdk/common';
+import { hex, ensureBytes, blake2b256 } from '@fleet-sdk/crypto';
 
 // src/coders/sigmaByteReader.ts
-function hexToBigInt(hex6) {
-  const value = BigInt(hex6.length % 2 ? `0x0${hex6}` : `0x${hex6}`);
-  const highByte = Number.parseInt(hex6.slice(0, 2), 16);
+function hexToBigInt(hex7) {
+  const value = BigInt(hex7.length % 2 ? `0x0${hex7}` : `0x${hex7}`);
+  const highByte = Number.parseInt(hex7.slice(0, 2), 16);
   if (128 & highByte) return -negateAndMask(value);
   return value;
 }
 function bigIntToHex(value) {
   const positive = value >= _0n;
-  let hex6 = (positive ? value : negateAndMask(value)).toString(16);
-  if (hex6.length % 2) hex6 = `0${hex6}`;
-  if (positive && 128 & Number.parseInt(hex6.slice(0, 2), 16)) {
-    return `00${hex6}`;
+  let hex7 = (positive ? value : negateAndMask(value)).toString(16);
+  if (hex7.length % 2) hex7 = `0${hex7}`;
+  if (positive && 128 & Number.parseInt(hex7.slice(0, 2), 16)) {
+    return `00${hex7}`;
   }
-  return hex6;
+  return hex7;
 }
 function negateAndMask(value) {
   let val = value;
@@ -103,18 +103,45 @@ function estimateVLQSize(value) {
   } while (val > _0n);
   return size;
 }
-function zigZagEncode(input) {
-  return input << 1 ^ input >> 63;
-}
-function zigZagDecode(input) {
-  return input >> 1 ^ -(input & 1);
-}
-function zigZagEncodeBigInt(input) {
-  return input << _1n ^ input >> _63n;
-}
-function zigZagDecodeBigInt(input) {
-  return input >> _1n ^ -(input & _1n);
-}
+var _31n = BigInt(31);
+var u64 = (v) => BigInt.asUintN(64, v);
+var i64 = (v) => BigInt.asIntN(64, v);
+var i32 = (v) => BigInt.asIntN(32, v);
+var u32 = (v) => BigInt.asUintN(32, v);
+var zigZag32 = {
+  encode: (input) => {
+    const v = i32(BigInt(input));
+    return u64(i32(v << _1n) ^ i32(v >> _31n));
+  },
+  decode: (input) => {
+    const v = u32(input);
+    return Number(v >> _1n ^ -(v & _1n));
+  }
+};
+var zigZag64 = {
+  encode: (input) => {
+    return u64(input << _1n ^ input >> _63n);
+  },
+  decode: (input) => {
+    return i64(input >> _1n ^ -(input & _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"
+);
 
 // src/coders/sigmaByteReader.ts
 var SigmaByteReader = class {
@@ -127,7 +154,7 @@ var SigmaByteReader = class {
     this.#bytes = ensureBytes(bytes);
     this.#cursor = 0;
   }
-  readBoolean() {
+  readBool() {
     return this.readByte() === 1;
   }
   readBits(length) {
@@ -153,16 +180,20 @@ var SigmaByteReader = class {
   readVlq() {
     return readVLQ(this);
   }
-  readShort() {
-    return Number(zigZagDecode(readVLQ(this)));
+  readI8() {
+    const byte = this.readByte();
+    return byte > MAX_I8 ? byte - (MAX_U8 + 1) : byte;
   }
-  readInt() {
-    return Number(this.readLong());
+  readI16() {
+    return zigZag32.decode(readBigVLQ(this));
   }
-  readLong() {
-    return zigZagDecodeBigInt(readBigVLQ(this));
+  readI32() {
+    return zigZag32.decode(readBigVLQ(this));
   }
-  readBigInt() {
+  readI64() {
+    return zigZag64.decode(readBigVLQ(this));
+  }
+  readI256() {
     const len = readVLQ(this);
     return hexToBigInt(hex.encode(this.readBytes(len)));
   }
@@ -177,7 +208,7 @@ var SigmaByteWriter = class {
     this.#bytes = new Uint8Array(length);
     this.#cursor = 0;
   }
-  writeBoolean(value) {
+  writeBool(value) {
     this.write(value === true ? 1 : 0);
     return this;
   }
@@ -187,17 +218,31 @@ var SigmaByteWriter = class {
   writeBigVLQ(value) {
     return writeBigVLQ(this, value);
   }
-  writeShort(value) {
-    this.writeVLQ(zigZagEncode(value));
+  writeI16(value) {
+    if (value < MIN_I16 || value > MAX_I16) {
+      throw new RangeError(`Value ${value} is out of range for a 16-bit integer`);
+    }
+    this.writeBigVLQ(zigZag32.encode(value));
     return this;
   }
-  writeInt(value) {
-    this.writeLong(BigInt(value));
-    return this;
+  writeI32(value) {
+    if (value < MIN_I32 || value > MAX_I32) {
+      throw new RangeError(`Value ${value} is out of range for a 32-bit integer`);
+    }
+    return this.writeBigVLQ(zigZag32.encode(value));
   }
-  writeLong(value) {
-    this.writeBigVLQ(zigZagEncodeBigInt(value));
-    return this;
+  writeI64(value) {
+    if (value < MIN_I64 || value > MAX_I64) {
+      throw new RangeError(`Value ${value} is out of range for a 64-bit integer`);
+    }
+    return this.writeBigVLQ(zigZag64.encode(value));
+  }
+  writeI256(value) {
+    if (value < MIN_I256 || value > MAX_I256) {
+      throw new RangeError(`Value ${value} is out of range for a 256-bit integer`);
+    }
+    const hex7 = bigIntToHex(value);
+    return this.writeVLQ(hex7.length / 2).writeHex(hex7);
   }
   write(byte) {
     this.#bytes[this.#cursor++] = byte;
@@ -227,10 +272,6 @@ var SigmaByteWriter = class {
     if (bitOffset > 0) this.#cursor++;
     return this;
   }
-  writeBigInt(value) {
-    const hex6 = bigIntToHex(value);
-    return this.writeVLQ(hex6.length / 2).writeHex(hex6);
-  }
   writeChecksum(length = 4, hashFn = blake2b256) {
     const hash = hashFn(this.toBytes());
     return this.writeBytes(length ? hash.subarray(0, length) : hash);
@@ -520,17 +561,17 @@ var dataSerializer = {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
-          return writer.writeBoolean(data);
+          return writer.writeBool(data);
         case descriptors.byte.code:
           return writer.write(data);
         case descriptors.short.code:
-          return writer.writeShort(data);
+          return writer.writeI16(data);
         case descriptors.int.code:
-          return writer.writeInt(data);
+          return writer.writeI32(data);
         case descriptors.long.code:
-          return writer.writeLong(data);
+          return writer.writeI64(data);
         case descriptors.bigInt.code:
-          return writer.writeBigInt(data);
+          return writer.writeI256(data);
         case descriptors.groupElement.code:
           return writer.writeBytes(data);
         case descriptors.sigmaProp.code: {
@@ -588,17 +629,17 @@ var dataSerializer = {
     if (type.embeddable) {
       switch (type.code) {
         case descriptors.bool.code:
-          return reader.readBoolean();
+          return reader.readBool();
         case descriptors.byte.code:
-          return reader.readByte();
+          return reader.readI8();
         case descriptors.short.code:
-          return reader.readShort();
+          return reader.readI16();
         case descriptors.int.code:
-          return reader.readInt();
+          return reader.readI32();
         case descriptors.long.code:
-          return reader.readLong();
+          return reader.readI64();
         case descriptors.bigInt.code:
-          return reader.readBigInt();
+          return reader.readI256();
         case descriptors.groupElement.code:
           return reader.readBytes(GROUP_ELEMENT_LENGTH);
         case descriptors.sigmaProp.code: {
@@ -901,24 +942,42 @@ function serializeTransaction(transaction) {
 }
 function writeInput(writer, input) {
   writer.writeHex(input.boxId);
-  writer.write(0);
+  if (isSignedInput(input)) {
+    writeProof(writer, input.spendingProof?.proofBytes);
+    writeExtension(writer, input.spendingProof?.extension);
+    return;
+  }
+  writeProof(writer, null);
   writeExtension(writer, input.extension);
 }
+function isSignedInput(input) {
+  return input.spendingProof !== void 0;
+}
+function writeProof(writer, proof) {
+  if (!proof) {
+    writer.write(0);
+    return;
+  }
+  const bytes = hex.decode(proof);
+  writer.writeVLQ(bytes.length);
+  writer.writeBytes(bytes);
+}
 function writeExtension(writer, extension) {
+  if (!extension) {
+    writer.write(0);
+    return;
+  }
   const keys = Object.keys(extension);
   let length = 0;
   for (const key of keys) {
-    const ext = extension[key];
-    if (isDefined(ext)) {
-      length++;
-    }
+    if (isDefined(extension[key])) length++;
   }
   writer.writeVLQ(length);
   if (length === 0) return;
   for (const key of keys) {
-    const ext = extension[key];
-    if (isDefined(ext)) {
-      writer.writeVLQ(Number(key)).writeHex(ext);
+    const val = extension[key];
+    if (isDefined(val)) {
+      writer.writeVLQ(Number(key)).writeHex(val);
     }
   }
 }