@fleet-sdk/serializer 0.8.0 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @fleet-sdk/serializer
 
+## 0.8.3
+
+### Patch Changes
+
+- 9c04d3c: Add `SignedTransaction` serialization
+- Updated dependencies [9c04d3c]
+  - @fleet-sdk/common@0.8.3
+  - @fleet-sdk/crypto@0.8.3
+
+## 0.8.2
+
+### Patch Changes
+
+- 66d6fc9: Fix `ZigZag` encoding for 32-bit integers
+- 1c8541a: Fix signed `SByte` parsing
+- Updated dependencies [9a244b5]
+- Updated dependencies [1b07c4a]
+  - @fleet-sdk/crypto@0.8.2
+
 ## 0.8.0
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,36 +1,37 @@
 import { ByteInput as ByteInput$1, blake2b256, Coder } from '@fleet-sdk/crypto';
-import { Box, Amount, BoxCandidate, UnsignedInput, DataInput } from '@fleet-sdk/common';
+import { Box, Amount, BoxCandidate, UnsignedInput, DataInput, SignedTransaction } from '@fleet-sdk/common';
 
 declare class SigmaByteReader {
     #private;
     get isEmpty(): boolean;
     constructor(bytes: ByteInput$1);
-    readBoolean(): boolean;
+    readBool(): boolean;
     readBits(length: number): ArrayLike<boolean>;
     readByte(): number;
     readBytes(length: number): Uint8Array;
     readVlq(): number;
-    readShort(): number;
-    readInt(): number;
-    readLong(): bigint;
-    readBigInt(): bigint;
+    readI8(): number;
+    readI16(): number;
+    readI32(): number;
+    readI64(): bigint;
+    readI256(): bigint;
 }
 
 declare class SigmaByteWriter {
     #private;
     get length(): number;
     constructor(length: number);
-    writeBoolean(value: boolean): SigmaByteWriter;
+    writeBool(value: boolean): SigmaByteWriter;
     writeVLQ(value: number): SigmaByteWriter;
     writeBigVLQ(value: bigint): SigmaByteWriter;
-    writeShort(value: number): SigmaByteWriter;
-    writeInt(value: number): SigmaByteWriter;
-    writeLong(value: bigint): SigmaByteWriter;
+    writeI16(value: number): SigmaByteWriter;
+    writeI32(value: number): SigmaByteWriter;
+    writeI64(value: bigint): SigmaByteWriter;
+    writeI256(value: bigint): SigmaByteWriter;
     write(byte: number): SigmaByteWriter;
     writeBytes(bytes: ArrayLike<number>): SigmaByteWriter;
     writeHex(bytesHex: string): SigmaByteWriter;
     writeBits(bits: ArrayLike<boolean>): SigmaByteWriter;
-    writeBigInt(value: bigint): SigmaByteWriter;
     writeChecksum(length?: number, hashFn?: typeof blake2b256): SigmaByteWriter;
     encode<T>(coder: Coder<Uint8Array, T>): T;
     toBytes(): Uint8Array;
@@ -94,8 +95,8 @@ declare const SShort: SProxy<SShortType, number, number>;
 declare const SInt: SProxy<SIntType, number, number>;
 declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
 declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
-declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array>;
-declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array, SType<unknown, unknown>>, SConstant<Uint8Array, SType<unknown, unknown>>>;
+declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array<ArrayBufferLike>>;
+declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>>;
 type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
 declare const SUnit: SUnit;
 type SColl = {
@@ -194,11 +195,11 @@ declare function serializeBox(box: BoxCandidate<Amount>, writer: SigmaByteWriter
 declare function estimateBoxSize(box: Box<Amount> | BoxCandidate<Amount>, withValue?: Amount): number;
 
 type MinimalUnsignedTransaction = {
-    inputs: readonly UnsignedInput[];
-    dataInputs: readonly DataInput[];
-    outputs: readonly BoxCandidate<Amount>[];
+    inputs: UnsignedInput[];
+    dataInputs: DataInput[];
+    outputs: BoxCandidate<Amount>[];
 };
-declare function serializeTransaction(transaction: MinimalUnsignedTransaction): SigmaByteWriter;
+declare function serializeTransaction(transaction: MinimalUnsignedTransaction | SignedTransaction): SigmaByteWriter;
 
 declare const dataSerializer: {
     serialize(data: unknown, type: SType, writer: SigmaByteWriter): SigmaByteWriter;

package/dist/index.d.ts

@@ -1,36 +1,37 @@
 import { ByteInput as ByteInput$1, blake2b256, Coder } from '@fleet-sdk/crypto';
-import { Box, Amount, BoxCandidate, UnsignedInput, DataInput } from '@fleet-sdk/common';
+import { Box, Amount, BoxCandidate, UnsignedInput, DataInput, SignedTransaction } from '@fleet-sdk/common';
 
 declare class SigmaByteReader {
     #private;
     get isEmpty(): boolean;
     constructor(bytes: ByteInput$1);
-    readBoolean(): boolean;
+    readBool(): boolean;
     readBits(length: number): ArrayLike<boolean>;
     readByte(): number;
     readBytes(length: number): Uint8Array;
     readVlq(): number;
-    readShort(): number;
-    readInt(): number;
-    readLong(): bigint;
-    readBigInt(): bigint;
+    readI8(): number;
+    readI16(): number;
+    readI32(): number;
+    readI64(): bigint;
+    readI256(): bigint;
 }
 
 declare class SigmaByteWriter {
     #private;
     get length(): number;
     constructor(length: number);
-    writeBoolean(value: boolean): SigmaByteWriter;
+    writeBool(value: boolean): SigmaByteWriter;
     writeVLQ(value: number): SigmaByteWriter;
     writeBigVLQ(value: bigint): SigmaByteWriter;
-    writeShort(value: number): SigmaByteWriter;
-    writeInt(value: number): SigmaByteWriter;
-    writeLong(value: bigint): SigmaByteWriter;
+    writeI16(value: number): SigmaByteWriter;
+    writeI32(value: number): SigmaByteWriter;
+    writeI64(value: bigint): SigmaByteWriter;
+    writeI256(value: bigint): SigmaByteWriter;
     write(byte: number): SigmaByteWriter;
     writeBytes(bytes: ArrayLike<number>): SigmaByteWriter;
     writeHex(bytesHex: string): SigmaByteWriter;
     writeBits(bits: ArrayLike<boolean>): SigmaByteWriter;
-    writeBigInt(value: bigint): SigmaByteWriter;
     writeChecksum(length?: number, hashFn?: typeof blake2b256): SigmaByteWriter;
     encode<T>(coder: Coder<Uint8Array, T>): T;
     toBytes(): Uint8Array;
@@ -94,8 +95,8 @@ declare const SShort: SProxy<SShortType, number, number>;
 declare const SInt: SProxy<SIntType, number, number>;
 declare const SLong: SProxy<SLongType, BigIntInput, bigint>;
 declare const SBigInt: SProxy<SBigIntType, BigIntInput, bigint>;
-declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array>;
-declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array, SType<unknown, unknown>>, SConstant<Uint8Array, SType<unknown, unknown>>>;
+declare const SGroupElement: SProxy<SGroupElementType, ByteInput, Uint8Array<ArrayBufferLike>>;
+declare const SSigmaProp: SProxy<SSigmaPropType, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>, SConstant<Uint8Array<ArrayBufferLike>, SType<unknown, unknown>>>;
 type SUnit = (value?: undefined) => SConstant<undefined, SUnitType>;
 declare const SUnit: SUnit;
 type SColl = {
@@ -194,11 +195,11 @@ declare function serializeBox(box: BoxCandidate<Amount>, writer: SigmaByteWriter
 declare function estimateBoxSize(box: Box<Amount> | BoxCandidate<Amount>, withValue?: Amount): number;
 
 type MinimalUnsignedTransaction = {
-    inputs: readonly UnsignedInput[];
-    dataInputs: readonly DataInput[];
-    outputs: readonly BoxCandidate<Amount>[];
+    inputs: UnsignedInput[];
+    dataInputs: DataInput[];
+    outputs: BoxCandidate<Amount>[];
 };
-declare function serializeTransaction(transaction: MinimalUnsignedTransaction): SigmaByteWriter;
+declare function serializeTransaction(transaction: MinimalUnsignedTransaction | SignedTransaction): SigmaByteWriter;
 
 declare const dataSerializer: {
     serialize(data: unknown, type: SType, writer: SigmaByteWriter): SigmaByteWriter;

package/dist/index.js

@@ -4,20 +4,20 @@ var common = require('@fleet-sdk/common');
 var crypto = require('@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 >= common._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;
@@ -105,18 +105,45 @@ function estimateVLQSize(value) {
   } while (val > 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);
-}
+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 << common._1n) ^ i32(v >> _31n));
+  },
+  decode: (input) => {
+    const v = u32(input);
+    return Number(v >> common._1n ^ -(v & common._1n));
+  }
+};
+var zigZag64 = {
+  encode: (input) => {
+    return u64(input << common._1n ^ input >> common._63n);
+  },
+  decode: (input) => {
+    return i64(input >> common._1n ^ -(input & common._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 {
@@ -129,7 +156,7 @@ var SigmaByteReader = class {
     this.#bytes = crypto.ensureBytes(bytes);
     this.#cursor = 0;
   }
-  readBoolean() {
+  readBool() {
     return this.readByte() === 1;
   }
   readBits(length) {
@@ -155,16 +182,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(crypto.hex.encode(this.readBytes(len)));
   }
@@ -179,7 +210,7 @@ var SigmaByteWriter = class {
     this.#bytes = new Uint8Array(length);
     this.#cursor = 0;
   }
-  writeBoolean(value) {
+  writeBool(value) {
     this.write(value === true ? 1 : 0);
     return this;
   }
@@ -189,17 +220,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;
@@ -229,10 +274,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 = crypto.blake2b256) {
     const hash = hashFn(this.toBytes());
     return this.writeBytes(length ? hash.subarray(0, length) : hash);
@@ -522,17 +563,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: {
@@ -590,17 +631,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: {
@@ -903,24 +944,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 = crypto.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 (common.isDefined(ext)) {
-      length++;
-    }
+    if (common.isDefined(extension[key])) 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);
+    const val = extension[key];
+    if (common.isDefined(val)) {
+      writer.writeVLQ(Number(key)).writeHex(val);
     }
   }
 }