@fleet-sdk/serializer 0.4.1 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.js CHANGED
@@ -3,62 +3,51 @@
3
3
  var common = require('@fleet-sdk/common');
4
4
  var crypto = require('@fleet-sdk/crypto');
5
5
 
6
- // src/coders/sigmaReader.ts
6
+ // src/coders/sigmaByteReader.ts
7
7
  function hexToBigInt(hex6) {
8
- if (hex6.length % 2) {
9
- hex6 = "0" + hex6;
10
- }
11
- const value = BigInt("0x" + hex6);
12
- const highByte = parseInt(hex6.slice(0, 2), 16);
13
- if (128 & highByte) {
14
- return -_bitNegate(value);
15
- }
8
+ const value = BigInt(hex6.length % 2 ? `0x0${hex6}` : `0x${hex6}`);
9
+ const highByte = Number.parseInt(hex6.slice(0, 2), 16);
10
+ if (128 & highByte) return -negateAndMask(value);
16
11
  return value;
17
12
  }
18
13
  function bigIntToHex(value) {
19
14
  const positive = value >= common._0n;
20
- if (!positive) {
21
- value = _bitNegate(value);
22
- }
23
- let hex6 = value.toString(16);
24
- if (hex6.length % 2) {
25
- hex6 = "0" + hex6;
26
- }
27
- if (positive && 128 & parseInt(hex6.slice(0, 2), 16)) {
28
- hex6 = "00" + hex6;
15
+ let hex6 = (positive ? value : negateAndMask(value)).toString(16);
16
+ if (hex6.length % 2) hex6 = `0${hex6}`;
17
+ if (positive && 128 & Number.parseInt(hex6.slice(0, 2), 16)) {
18
+ return `00${hex6}`;
29
19
  }
30
20
  return hex6;
31
21
  }
32
- function _bitNegate(value) {
33
- const negative = value < common._0n;
34
- if (negative) {
35
- value = -value;
36
- }
37
- const bits = value.toString(2);
38
- let bitLen = bits.length;
39
- const mod = bitLen % 8;
22
+ function negateAndMask(value) {
23
+ let val = value;
24
+ const negative = val < common._0n;
25
+ if (negative) val = -val;
26
+ const bits = val.toString(2);
27
+ let len = bits.length;
28
+ const mod = len % 8;
40
29
  if (mod > 0) {
41
- bitLen += 8 - mod;
30
+ len += 8 - mod;
42
31
  } else if (negative && common.first(bits) === "1" && bits.indexOf("1", 1) !== -1) {
43
- bitLen += 8;
32
+ len += 8;
44
33
  }
45
- const mask = (1n << BigInt(bitLen)) - 1n;
46
- return (~value & mask) + 1n;
34
+ const mask = (1n << BigInt(len)) - 1n;
35
+ return (~val & mask) + 1n;
47
36
  }
48
37
  function writeVLQ(writer, value) {
49
- if (value === 0) {
50
- return writer.write(0);
51
- } else if (value < 0) {
52
- throw new RangeError("Variable Length Quantity not supported for negative numbers.");
38
+ if (value === 0) return writer.write(0);
39
+ if (value < 0) {
40
+ throw new RangeError(
41
+ "Variable Length Quantity not supported for negative numbers."
42
+ );
53
43
  }
44
+ let val = value;
54
45
  do {
55
- let lower7bits = value & 127;
56
- value >>= 7;
57
- if (value > 0) {
58
- lower7bits |= 128;
59
- }
46
+ let lower7bits = val & 127;
47
+ val >>= 7;
48
+ if (val > 0) lower7bits |= 128;
60
49
  writer.write(lower7bits);
61
- } while (value > 0);
50
+ } while (val > 0);
62
51
  return writer;
63
52
  }
64
53
  function readVLQ(reader) {
@@ -72,29 +61,27 @@ function readVLQ(reader) {
72
61
  lower7bits = reader.readByte();
73
62
  value |= (lower7bits & 127) << shift;
74
63
  shift += 7;
75
- } while ((lower7bits & 128) != 0);
64
+ } while ((lower7bits & 128) !== 0);
76
65
  return value;
77
66
  }
78
67
  function writeBigVLQ(writer, value) {
79
- if (value === common._0n) {
80
- return writer.write(0);
81
- } else if (value < common._0n) {
82
- throw new RangeError("Variable Length Quantity not supported for negative numbers");
68
+ if (value === common._0n) return writer.write(0);
69
+ if (value < common._0n) {
70
+ throw new RangeError(
71
+ "Variable Length Quantity not supported for negative numbers"
72
+ );
83
73
  }
74
+ let val = value;
84
75
  do {
85
- let lower7bits = Number(value & common._127n);
86
- value >>= common._7n;
87
- if (value > 0) {
88
- lower7bits |= 128;
89
- }
76
+ let lower7bits = Number(val & common._127n);
77
+ val >>= common._7n;
78
+ if (val > 0) lower7bits |= 128;
90
79
  writer.write(lower7bits);
91
- } while (value > 0);
80
+ } while (val > 0);
92
81
  return writer;
93
82
  }
94
83
  function readBigVLQ(reader) {
95
- if (reader.isEmpty) {
96
- return common._0n;
97
- }
84
+ if (reader.isEmpty) return common._0n;
98
85
  let value = common._0n;
99
86
  let shift = common._0n;
100
87
  let lower7bits = common._0n;
@@ -102,23 +89,24 @@ function readBigVLQ(reader) {
102
89
  lower7bits = BigInt(reader.readByte());
103
90
  value |= (lower7bits & common._127n) << shift;
104
91
  shift += common._7n;
105
- } while ((lower7bits & common._128n) != common._0n);
92
+ } while ((lower7bits & common._128n) !== common._0n);
106
93
  return value;
107
94
  }
108
95
  function estimateVLQSize(value) {
109
96
  let size = 0;
110
- if (typeof value === "number") {
97
+ let val = value;
98
+ if (typeof val === "number") {
111
99
  do {
112
100
  size++;
113
- value = Math.floor(value / 128);
114
- } while (value > 0);
101
+ val = Math.floor(val / 128);
102
+ } while (val > 0);
115
103
  return size;
116
104
  }
117
- value = common.ensureBigInt(value);
105
+ val = common.ensureBigInt(val);
118
106
  do {
119
107
  size++;
120
- value /= common._128n;
121
- } while (value > common._0n);
108
+ val /= common._128n;
109
+ } while (val > common._0n);
122
110
  return size;
123
111
  }
124
112
  function zigZagEncode(input) {
@@ -134,19 +122,15 @@ function zigZagDecodeBigInt(input) {
134
122
  return input >> common._1n ^ -(input & common._1n);
135
123
  }
136
124
 
137
- // src/coders/sigmaReader.ts
138
- var SigmaReader = class {
125
+ // src/coders/sigmaByteReader.ts
126
+ var SigmaByteReader = class {
139
127
  #bytes;
140
128
  #cursor;
141
129
  get isEmpty() {
142
130
  return common.isEmpty(this.#bytes);
143
131
  }
144
132
  constructor(bytes) {
145
- if (typeof bytes === "string") {
146
- this.#bytes = crypto.hex.decode(bytes);
147
- } else {
148
- this.#bytes = bytes;
149
- }
133
+ this.#bytes = crypto.ensureBytes(bytes);
150
134
  this.#cursor = 0;
151
135
  }
152
136
  readBoolean() {
@@ -158,14 +142,12 @@ var SigmaReader = class {
158
142
  for (let i = 0; i < length; i++) {
159
143
  const bit = this.#bytes[this.#cursor] >> bitOffset++ & 1;
160
144
  bits[i] = bit === 1;
161
- if (bitOffset == 8) {
145
+ if (bitOffset === 8) {
162
146
  bitOffset = 0;
163
147
  this.#cursor++;
164
148
  }
165
149
  }
166
- if (bitOffset > 0) {
167
- this.#cursor++;
168
- }
150
+ if (bitOffset > 0) this.#cursor++;
169
151
  return bits;
170
152
  }
171
153
  readByte() {
@@ -181,8 +163,7 @@ var SigmaReader = class {
181
163
  return Number(zigZagDecode(readVLQ(this)));
182
164
  }
183
165
  readInt() {
184
- const int = this.readLong();
185
- return Number(int);
166
+ return Number(this.readLong());
186
167
  }
187
168
  readLong() {
188
169
  return zigZagDecodeBigInt(readBigVLQ(this));
@@ -192,14 +173,14 @@ var SigmaReader = class {
192
173
  return hexToBigInt(crypto.hex.encode(this.readBytes(len)));
193
174
  }
194
175
  };
195
- var SigmaWriter = class {
176
+ var SigmaByteWriter = class {
196
177
  #bytes;
197
178
  #cursor;
198
179
  get length() {
199
180
  return this.#cursor;
200
181
  }
201
- constructor(maxLength) {
202
- this.#bytes = new Uint8Array(maxLength);
182
+ constructor(length) {
183
+ this.#bytes = new Uint8Array(length);
203
184
  this.#cursor = 0;
204
185
  }
205
186
  writeBoolean(value) {
@@ -244,26 +225,27 @@ var SigmaWriter = class {
244
225
  } else {
245
226
  this.#bytes[this.#cursor] &= ~(1 << bitOffset++);
246
227
  }
247
- if (bitOffset == 8) {
228
+ if (bitOffset === 8) {
248
229
  bitOffset = 0;
249
230
  this.#cursor++;
250
231
  }
251
232
  }
252
- if (bitOffset > 0) {
253
- this.#cursor++;
254
- }
233
+ if (bitOffset > 0) this.#cursor++;
255
234
  return this;
256
235
  }
257
236
  writeBigInt(value) {
258
237
  const hex6 = bigIntToHex(value);
259
- this.writeVLQ(hex6.length / 2);
260
- this.writeHex(hex6);
261
- return this;
238
+ return this.writeVLQ(hex6.length / 2).writeHex(hex6);
262
239
  }
263
- toHex() {
264
- return crypto.hex.encode(this.toBytes());
240
+ writeChecksum(length = 4, hashFn = crypto.blake2b256) {
241
+ const hash = hashFn(this.toBytes());
242
+ return this.writeBytes(length ? hash.subarray(0, length) : hash);
243
+ }
244
+ encode(coder) {
245
+ return coder.encode(this.toBytes());
265
246
  }
266
247
  toBytes() {
248
+ if (this.#cursor === this.#bytes.length) return this.#bytes;
267
249
  return this.#bytes.subarray(0, this.#cursor);
268
250
  }
269
251
  };
@@ -395,7 +377,7 @@ var constructorCode = Object.freeze({
395
377
  });
396
378
  var MAX_PRIMITIVE_TYPE_CODE = 11;
397
379
  var PRIMITIVE_TYPE_RANGE = MAX_PRIMITIVE_TYPE_CODE + 1;
398
- var typeCodeOf = (constructor) => PRIMITIVE_TYPE_RANGE * constructor;
380
+ var typeCodeOf = (ctor) => PRIMITIVE_TYPE_RANGE * ctor;
399
381
  var collDescriptor = Object.freeze({
400
382
  code: typeCodeOf(constructorCode.simpleColl),
401
383
  embeddable: false,
@@ -488,8 +470,7 @@ function monoProxy(ctor, cache, forceConstruction) {
488
470
  return new Proxy(ctor, {
489
471
  apply: (target, _, args) => {
490
472
  const instance = cache ?? new target();
491
- if (!forceConstruction && common.isEmpty(args))
492
- return instance;
473
+ if (!forceConstruction && common.isEmpty(args)) return instance;
493
474
  return new SConstant(instance, ...args);
494
475
  }
495
476
  });
@@ -501,41 +482,56 @@ function genericProxy(ctor, handler) {
501
482
  }
502
483
  var SByte = monoProxy(SByteType, descriptors.byte);
503
484
  var SBool = monoProxy(SBoolType, descriptors.bool);
504
- var SShort = monoProxy(SShortType, descriptors.short);
485
+ var SShort = monoProxy(
486
+ SShortType,
487
+ descriptors.short
488
+ );
505
489
  var SInt = monoProxy(SIntType, descriptors.int);
506
- var SLong = monoProxy(SLongType, descriptors.long);
507
- var SBigInt = monoProxy(SBigIntType, descriptors.bigInt);
508
- var SGroupElement = monoProxy(
509
- SGroupElementType,
510
- descriptors.groupElement
490
+ var SLong = monoProxy(
491
+ SLongType,
492
+ descriptors.long
493
+ );
494
+ var SBigInt = monoProxy(
495
+ SBigIntType,
496
+ descriptors.bigInt
511
497
  );
498
+ var SGroupElement = monoProxy(SGroupElementType, descriptors.groupElement);
512
499
  var SSigmaProp = monoProxy(
513
500
  SSigmaPropType,
514
501
  descriptors.sigmaProp
515
502
  );
516
503
  var SUnit = monoProxy(SUnitType, void 0, true);
517
- var SColl = genericProxy(SCollType, (target, _, args) => {
518
- const [type, elements] = args;
519
- const elementsType = type();
520
- if (!elements)
521
- return () => new target(elementsType);
522
- return new SConstant(new target(elementsType), elements);
523
- });
524
- var SPair = genericProxy(STupleType, (target, _, args) => {
525
- const [left, right] = args;
526
- if (typeof left === "function" && typeof right === "function") {
527
- return () => new target([left(), right()]);
528
- } else if (left instanceof SConstant && right instanceof SConstant) {
529
- return new SConstant(new target([left.type, right.type]), [left.data, right.data]);
530
- }
531
- throw new Error("Invalid tuple declaration.");
532
- });
504
+ var SColl = genericProxy(
505
+ SCollType,
506
+ (target, _, args) => {
507
+ const [type, elements] = args;
508
+ const elementsType = type();
509
+ if (!elements) return () => new target(elementsType);
510
+ return new SConstant(new target(elementsType), elements);
511
+ }
512
+ );
513
+ var SPair = genericProxy(
514
+ STupleType,
515
+ (target, _, args) => {
516
+ const [left, right] = args;
517
+ if (typeof left === "function" && typeof right === "function") {
518
+ return () => new target([left(), right()]);
519
+ }
520
+ if (left instanceof SConstant && right instanceof SConstant) {
521
+ return new SConstant(new target([left.type, right.type]), [
522
+ left.data,
523
+ right.data
524
+ ]);
525
+ }
526
+ throw new Error("Invalid tuple declaration.");
527
+ }
528
+ );
533
529
 
534
530
  // src/serializers/dataSerializer.ts
535
531
  var GROUP_ELEMENT_LENGTH = 33;
536
532
  var PROVE_DLOG_OP = 205;
537
- var DataSerializer = class _DataSerializer {
538
- static serialize(data, type, writer) {
533
+ var dataSerializer = {
534
+ serialize(data, type, writer) {
539
535
  if (type.embeddable) {
540
536
  switch (type.code) {
541
537
  case descriptors.bool.code:
@@ -548,27 +544,33 @@ var DataSerializer = class _DataSerializer {
548
544
  return writer.writeInt(data);
549
545
  case descriptors.long.code:
550
546
  return writer.writeLong(data);
551
- case descriptors.bigInt.code: {
547
+ case descriptors.bigInt.code:
552
548
  return writer.writeBigInt(data);
553
- }
554
549
  case descriptors.groupElement.code:
555
550
  return writer.writeBytes(data);
556
551
  case descriptors.sigmaProp.code: {
557
552
  const node = data;
558
553
  if (node.type === descriptors.groupElement) {
559
554
  writer.write(PROVE_DLOG_OP);
560
- return _DataSerializer.serialize(node.data, node.type, writer);
561
- } else {
562
- throw Error("Serialization error: SigmaProp operation not implemented.");
555
+ return dataSerializer.serialize(node.data, node.type, writer);
563
556
  }
557
+ throw Error(
558
+ "Serialization error: SigmaProp operation not implemented."
559
+ );
564
560
  }
565
561
  }
566
- } else if (isColl(type)) {
562
+ }
563
+ if (isColl(type)) {
567
564
  if (type.elementsType.code === descriptors.byte.code) {
568
- const isUint8Array = data instanceof Uint8Array;
569
- common.assert(isUint8Array, `SColl[Byte] expected an UInt8Array, got ${typeof data}.`);
565
+ common.assert(
566
+ data instanceof Uint8Array,
567
+ `SColl[Byte] expected an UInt8Array, got ${typeof data}.`
568
+ );
570
569
  } else {
571
- common.assert(Array.isArray(data), `SColl expected an array, got ${typeof data}.`);
570
+ common.assert(
571
+ Array.isArray(data),
572
+ `SColl expected an array, got ${typeof data}.`
573
+ );
572
574
  }
573
575
  writer.writeVLQ(data.length);
574
576
  switch (type.elementsType.code) {
@@ -580,27 +582,29 @@ var DataSerializer = class _DataSerializer {
580
582
  }
581
583
  default: {
582
584
  for (let i = 0; i < data.length; i++) {
583
- _DataSerializer.serialize(data[i], type.elementsType, writer);
585
+ dataSerializer.serialize(data[i], type.elementsType, writer);
584
586
  }
585
587
  return writer;
586
588
  }
587
589
  }
588
- } else if (isTuple(type)) {
590
+ }
591
+ if (isTuple(type)) {
589
592
  common.assert(
590
593
  Array.isArray(data),
591
594
  `STupleType serialization expected an array, got ${typeof data}.`
592
595
  );
593
596
  const len = type.elementsType.length;
594
597
  for (let i = 0; i < len; i++) {
595
- _DataSerializer.serialize(data[i], type.elementsType[i], writer);
598
+ dataSerializer.serialize(data[i], type.elementsType[i], writer);
596
599
  }
597
600
  return writer;
598
- } else if (type.code === descriptors.unit.code) {
599
- return writer;
600
601
  }
601
- throw Error(`Serialization error: '0x${type.code.toString(16)}' type not implemented.`);
602
- }
603
- static deserialize(type, reader) {
602
+ if (type.code === descriptors.unit.code) return writer;
603
+ throw Error(
604
+ `Serialization error: '0x${type.code.toString(16)}' type not implemented.`
605
+ );
606
+ },
607
+ deserialize(type, reader) {
604
608
  if (type.embeddable) {
605
609
  switch (type.code) {
606
610
  case descriptors.bool.code:
@@ -644,29 +648,36 @@ var DataSerializer = class _DataSerializer {
644
648
  }
645
649
  }
646
650
  case descriptors.tuple.code: {
647
- return type.elementsType.map((t) => this.deserialize(t, reader));
651
+ return type.elementsType.map(
652
+ (t) => this.deserialize(t, reader)
653
+ );
648
654
  }
649
- case descriptors.unit.code: {
655
+ case descriptors.unit.code:
650
656
  return void 0;
651
- }
652
657
  }
653
658
  }
654
- throw new Error(`Parsing error: '0x${type.code.toString(16)}' type not implemented.`);
659
+ throw new Error(
660
+ `Parsing error: '0x${type.code.toString(16)}' type not implemented.`
661
+ );
655
662
  }
656
663
  };
657
- var TypeSerializer = class {
658
- static serialize(type, writer) {
664
+ var typeSerializer = {
665
+ serialize(type, writer) {
659
666
  if (type.embeddable) {
660
667
  writer.write(type.code);
661
668
  } else if (type.code === descriptors.unit.code) {
662
669
  writer.write(type.code);
663
670
  } else if (isColl(type)) {
664
671
  if (type.elementsType.embeddable) {
665
- writer.write(descriptors.coll.simpleCollTypeCode + type.elementsType.code);
672
+ writer.write(
673
+ descriptors.coll.simpleCollTypeCode + type.elementsType.code
674
+ );
666
675
  } else if (isColl(type.elementsType)) {
667
676
  const nestedColl = type.elementsType;
668
677
  if (nestedColl.elementsType.embeddable) {
669
- writer.write(descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code);
678
+ writer.write(
679
+ descriptors.coll.nestedCollTypeCode + nestedColl.elementsType.code
680
+ );
670
681
  } else {
671
682
  writer.write(descriptors.coll.simpleCollTypeCode);
672
683
  this.serialize(nestedColl, writer);
@@ -705,7 +716,10 @@ var TypeSerializer = class {
705
716
  break;
706
717
  default: {
707
718
  const len = type.elementsType.length;
708
- common.assert(len >= 2 && len <= 255, "Invalid type: tuples must have between 2 and 255 items.");
719
+ common.assert(
720
+ len >= 2 && len <= 255,
721
+ "Invalid type: tuples must have between 2 and 255 items."
722
+ );
709
723
  writer.write(descriptors.tuple.genericTupleTypeCode);
710
724
  writer.writeVLQ(len);
711
725
  }
@@ -716,10 +730,13 @@ var TypeSerializer = class {
716
730
  } else {
717
731
  throw new Error("Serialization error: type not implemented.");
718
732
  }
719
- }
720
- static deserialize(r) {
733
+ },
734
+ deserialize(r) {
721
735
  const byte = r.readByte();
722
- common.assert(byte > 0, `Parsing Error: Unexpected type code '0x${byte.toString(16)}'`);
736
+ common.assert(
737
+ byte > 0,
738
+ `Parsing Error: Unexpected type code '0x${byte.toString(16)}'`
739
+ );
723
740
  if (byte < descriptors.tuple.genericTupleTypeCode) {
724
741
  const ctorCode = Math.floor(byte / PRIMITIVE_TYPE_RANGE);
725
742
  const embdCode = Math.floor(byte % PRIMITIVE_TYPE_RANGE);
@@ -743,23 +760,27 @@ var TypeSerializer = class {
743
760
  return new STupleType(internal);
744
761
  }
745
762
  case constructorCode.symmetricPair: {
746
- const internal = embdCode === 0 ? [this.deserialize(r), this.deserialize(r), this.deserialize(r), this.deserialize(r)] : [getPrimitiveType(embdCode), getPrimitiveType(embdCode)];
763
+ const internal = embdCode === 0 ? [
764
+ this.deserialize(r),
765
+ this.deserialize(r),
766
+ this.deserialize(r),
767
+ this.deserialize(r)
768
+ ] : [getPrimitiveType(embdCode), getPrimitiveType(embdCode)];
747
769
  return new STupleType(internal);
748
770
  }
749
771
  }
750
- } else {
751
- switch (byte) {
752
- case descriptors.tuple.genericTupleTypeCode: {
753
- const len = r.readVlq();
754
- const wrapped = new Array(len);
755
- for (let i = 0; i < len; i++) {
756
- wrapped[i] = this.deserialize(r);
757
- }
758
- return new STupleType(wrapped);
759
- }
760
- case descriptors.unit.code: {
761
- return descriptors.unit;
772
+ }
773
+ switch (byte) {
774
+ case descriptors.tuple.genericTupleTypeCode: {
775
+ const len = r.readVlq();
776
+ const wrapped = new Array(len);
777
+ for (let i = 0; i < len; i++) {
778
+ wrapped[i] = this.deserialize(r);
762
779
  }
780
+ return new STupleType(wrapped);
781
+ }
782
+ case descriptors.unit.code: {
783
+ return descriptors.unit;
763
784
  }
764
785
  }
765
786
  throw new Error("Not implemented.");
@@ -777,9 +798,9 @@ var SConstant = class _SConstant {
777
798
  }
778
799
  static from(bytes) {
779
800
  common.assert(bytes.length > 0, "Empty constant bytes.");
780
- const reader = new SigmaReader(bytes);
781
- const type = TypeSerializer.deserialize(reader);
782
- const data = DataSerializer.deserialize(type, reader);
801
+ const reader = new SigmaByteReader(bytes);
802
+ const type = typeSerializer.deserialize(reader);
803
+ const data = dataSerializer.deserialize(type, reader);
783
804
  return new _SConstant(type, data);
784
805
  }
785
806
  get type() {
@@ -789,9 +810,9 @@ var SConstant = class _SConstant {
789
810
  return this.#data;
790
811
  }
791
812
  toBytes() {
792
- const writer = new SigmaWriter(MAX_CONSTANT_LENGTH);
793
- TypeSerializer.serialize(this.type, writer);
794
- DataSerializer.serialize(this.data, this.type, writer);
813
+ const writer = new SigmaByteWriter(MAX_CONSTANT_LENGTH);
814
+ typeSerializer.serialize(this.type, writer);
815
+ dataSerializer.serialize(this.data, this.type, writer);
795
816
  return writer.toBytes();
796
817
  }
797
818
  toHex() {
@@ -799,18 +820,14 @@ var SConstant = class _SConstant {
799
820
  }
800
821
  };
801
822
  function decode(value, coder) {
802
- if (common.isUndefined(value))
803
- return;
823
+ if (common.isUndefined(value)) return;
804
824
  const data = parse(value, "safe");
805
- if (common.isUndefined(data))
806
- return;
825
+ if (common.isUndefined(data)) return;
807
826
  return coder ? coder(data) : data;
808
827
  }
809
828
  function parse(constant, mode = "strict") {
810
- if (mode === "strict")
811
- return SConstant.from(constant ?? "").data;
812
- if (!constant)
813
- return;
829
+ if (mode === "strict") return SConstant.from(constant ?? "").data;
830
+ if (!constant) return;
814
831
  try {
815
832
  return SConstant.from(constant).data;
816
833
  } catch {
@@ -818,23 +835,15 @@ function parse(constant, mode = "strict") {
818
835
  }
819
836
  }
820
837
  var MAX_UINT16_VALUE = 65535;
821
- function serializeBox(box, writer, distinctTokenIds) {
822
- if (!writer) {
823
- writer = new SigmaWriter(5e4);
824
- }
838
+ function serializeBox(box, writer = new SigmaByteWriter(5e4), distinctTokenIds) {
825
839
  writer.writeBigVLQ(common.ensureBigInt(box.value));
826
840
  writer.writeHex(box.ergoTree);
827
841
  writer.writeVLQ(box.creationHeight);
828
842
  writeTokens(writer, box.assets, distinctTokenIds);
829
843
  writeRegisters(writer, box.additionalRegisters);
830
- if (common.isDefined(distinctTokenIds)) {
831
- return writer;
832
- } else {
833
- if (!isBox(box)) {
834
- throw new Error("Invalid box type.");
835
- }
836
- return writer.writeHex(box.transactionId).writeVLQ(box.index);
837
- }
844
+ if (common.isDefined(distinctTokenIds)) return writer;
845
+ if (!isBox(box)) throw new Error("Invalid box type.");
846
+ return writer.writeHex(box.transactionId).writeVLQ(box.index);
838
847
  }
839
848
  function isBox(box) {
840
849
  const castedBox = box;
@@ -851,26 +860,22 @@ function writeTokens(writer, tokens, tokenIds) {
851
860
  (token) => writer.writeVLQ(tokenIds.indexOf(token.tokenId)).writeBigVLQ(common.ensureBigInt(token.amount))
852
861
  );
853
862
  } else {
854
- tokens.map((token) => writer.writeHex(token.tokenId).writeBigVLQ(common.ensureBigInt(token.amount)));
863
+ tokens.map(
864
+ (token) => writer.writeHex(token.tokenId).writeBigVLQ(common.ensureBigInt(token.amount))
865
+ );
855
866
  }
856
867
  }
857
868
  function writeRegisters(writer, registers) {
858
869
  const keys = Object.keys(registers).sort();
859
870
  let length = 0;
860
871
  for (const key of keys) {
861
- if (registers[key]) {
862
- length++;
863
- }
872
+ if (registers[key]) length++;
864
873
  }
865
874
  writer.writeVLQ(length);
866
- if (length == 0) {
867
- return;
868
- }
875
+ if (length === 0) return;
869
876
  for (const key of keys) {
870
877
  const register = registers[key];
871
- if (common.isDefined(register)) {
872
- writer.writeHex(register);
873
- }
878
+ if (common.isDefined(register)) writer.writeHex(register);
874
879
  }
875
880
  }
876
881
  function estimateBoxSize(box, withValue) {
@@ -882,10 +887,9 @@ function estimateBoxSize(box, withValue) {
882
887
  size += common.byteSizeOf(box.ergoTree);
883
888
  size += estimateVLQSize(box.creationHeight);
884
889
  size += estimateVLQSize(box.assets.length);
885
- size += box.assets.reduce(
886
- (acc, curr) => acc += common.byteSizeOf(curr.tokenId) + estimateVLQSize(curr.amount),
887
- 0
888
- );
890
+ for (const asset of box.assets) {
891
+ size += common.byteSizeOf(asset.tokenId) + estimateVLQSize(asset.amount);
892
+ }
889
893
  let registersLength = 0;
890
894
  for (const key in box.additionalRegisters) {
891
895
  const register = box.additionalRegisters[key];
@@ -900,7 +904,7 @@ function estimateBoxSize(box, withValue) {
900
904
  return size;
901
905
  }
902
906
  function serializeTransaction(transaction) {
903
- const writer = new SigmaWriter(1e5);
907
+ const writer = new SigmaByteWriter(1e5);
904
908
  writer.writeVLQ(transaction.inputs.length);
905
909
  transaction.inputs.map((input) => writeInput(writer, input));
906
910
  writer.writeVLQ(transaction.dataInputs.length);
@@ -909,7 +913,9 @@ function serializeTransaction(transaction) {
909
913
  writer.writeVLQ(distinctTokenIds.length);
910
914
  distinctTokenIds.map((tokenId) => writer.writeHex(tokenId));
911
915
  writer.writeVLQ(transaction.outputs.length);
912
- transaction.outputs.map((output) => serializeBox(output, writer, distinctTokenIds));
916
+ transaction.outputs.map(
917
+ (output) => serializeBox(output, writer, distinctTokenIds)
918
+ );
913
919
  return writer;
914
920
  }
915
921
  function writeInput(writer, input) {
@@ -927,9 +933,7 @@ function writeExtension(writer, extension) {
927
933
  }
928
934
  }
929
935
  writer.writeVLQ(length);
930
- if (length == 0) {
931
- return;
932
- }
936
+ if (length === 0) return;
933
937
  for (const key of keys) {
934
938
  const ext = extension[key];
935
939
  if (common.isDefined(ext)) {
@@ -939,11 +943,12 @@ function writeExtension(writer, extension) {
939
943
  }
940
944
  function getDistinctTokenIds(outputs) {
941
945
  const tokenIds = /* @__PURE__ */ new Set();
942
- outputs.flatMap((output) => output.assets.map((asset) => tokenIds.add(asset.tokenId)));
946
+ outputs.flatMap(
947
+ (output) => output.assets.map((asset) => tokenIds.add(asset.tokenId))
948
+ );
943
949
  return Array.from(tokenIds);
944
950
  }
945
951
 
946
- exports.DataSerializer = DataSerializer;
947
952
  exports.SBigInt = SBigInt;
948
953
  exports.SBigIntType = SBigIntType;
949
954
  exports.SBool = SBool;
@@ -971,7 +976,9 @@ exports.STupleType = STupleType;
971
976
  exports.SType = SType;
972
977
  exports.SUnit = SUnit;
973
978
  exports.SUnitType = SUnitType;
974
- exports.TypeSerializer = TypeSerializer;
979
+ exports.SigmaByteReader = SigmaByteReader;
980
+ exports.SigmaByteWriter = SigmaByteWriter;
981
+ exports.dataSerializer = dataSerializer;
975
982
  exports.decode = decode;
976
983
  exports.estimateBoxSize = estimateBoxSize;
977
984
  exports.estimateVLQSize = estimateVLQSize;
@@ -980,5 +987,6 @@ exports.isTuple = isTuple;
980
987
  exports.parse = parse;
981
988
  exports.serializeBox = serializeBox;
982
989
  exports.serializeTransaction = serializeTransaction;
990
+ exports.typeSerializer = typeSerializer;
983
991
  //# sourceMappingURL=out.js.map
984
992
  //# sourceMappingURL=index.js.map