Stabilize Dart (#50)

## Summary

Fixes #49

- Added tests for Dart, just like Golang
  - Made bool check more strict
- Fixed some parts that were reading container length as Int64, not
Uint64: This wasn't a problem when the number is
small(0x00000000~0x01111111), but was one of the problems that were
causing the tests to fail
  - Made serialization/deserialization consider max bytes length
  - Made serialization/deserialization consider container depth
- Implemented `sortMapEntries` for BCS
- Bumped Dart versions in the CI and package config to 3.5.3(>=3.0.0,
<4.0.0)

## Test Plan

Since the tests were already defined in Golang, I've written some extra
Dart tests that follows the way Golang does.

Author: temeddix

.github/workflows/main.yml

@@ -90,7 +90,7 @@ jobs:
       - name: Setup Additional Languages (dart)
         uses: dart-lang/setup-dart@v1
         with:
-          sdk: 2.14.0
+          sdk: 3.5.3
 
       - name: Setup Additional Languages (swift)
         # TODO: Use the release version again once

serde-generate/runtime/dart/bcs/bcs_deserializer.dart

@@ -3,8 +3,18 @@
 
 part of bcs;
 
+// Maximum length allowed for sequences (vectors, bytes, strings) and maps.
+const maxSequenceLength = (1 << 31) - 1;
+
+// Maximum number of nested structs and enum variants.
+const maxContainerDepth = 500;
+
 class BcsDeserializer extends BinaryDeserializer {
-  BcsDeserializer(Uint8List input) : super(input);
+  BcsDeserializer(Uint8List input)
+      : super(
+          input: input,
+          containerDepthBudget: maxContainerDepth,
+        );
 
   int deserializeUleb128AsUint32() {
     var value = 0;
@@ -27,7 +37,11 @@ class BcsDeserializer extends BinaryDeserializer {
 
   @override
   int deserializeLength() {
-    return deserializeUleb128AsUint32();
+    final length = deserializeUleb128AsUint32();
+    if (length > maxSequenceLength) {
+      throw Exception("length is too large");
+    }
+    return length;
   }
 
   @override

serde-generate/runtime/dart/bcs/bcs_serializer.dart

@@ -4,6 +4,11 @@
 part of bcs;
 
 class BcsSerializer extends BinarySerializer {
+  BcsSerializer()
+      : super(
+          containerDepthBudget: maxContainerDepth,
+        );
+
   void serializeUint32AsUleb128(int value) {
     while (((value & 0xFFFFFFFF) >> 7) != 0) {
       output.add((value & 0x7f) | 0x80);
@@ -22,7 +27,45 @@ class BcsSerializer extends BinarySerializer {
     serializeUint32AsUleb128(value);
   }
 
-  void sortMapEntries(Uint8List offsets) {
-    // TODO(#120)
+  void sortMapEntries(List<int> offsets) {
+    if (offsets.isEmpty) {
+      return;
+    }
+
+    // Prepare a list of slices
+    final data = Uint8List.fromList(output);
+    List<Uint8List> slices = [];
+
+    // Collect slices
+    for (int i = 0; i < offsets.length; i++) {
+      final int startOffset = offsets[i];
+      final int cutOffset;
+      if (i + 1 < offsets.length) {
+        cutOffset = offsets[i + 1];
+      } else {
+        cutOffset = data.length;
+      }
+      slices.add(data.sublist(startOffset, cutOffset));
+    }
+
+    // Sort slices using lexicographic comparison
+    slices.sort((a, b) {
+      for (int i = 0; i < a.length && i < b.length; i++) {
+        if (a[i] != b[i]) {
+          return a[i].compareTo(b[i]);
+        }
+      }
+      return a.length.compareTo(b.length);
+    });
+
+    // Write sorted slices back to output
+    int writePosition = offsets[0];
+    for (final slice in slices) {
+      output.setRange(writePosition, writePosition + slice.length, slice);
+      writePosition += slice.length;
+    }
+
+    // Ensure the final length is correct
+    assert(offsets.last == output.length);
   }
 }

serde-generate/runtime/dart/bincode/bincode_deserializer.dart

@@ -3,14 +3,16 @@
 
 part of bincode;
 
+// Maximum number of nested structs and enum variants.
+const maxContainerDepth = (1 << 31) - 1;
+
 class BincodeDeserializer extends BinaryDeserializer {
-  BincodeDeserializer(Uint8List input) : super(input);
+  BincodeDeserializer(Uint8List input)
+      : super(input: input, containerDepthBudget: maxContainerDepth);
 
   @override
   int deserializeLength() {
-    // bincode sends this as a u64 but since transferred data length should never exceed the upper
-    // bounds of an i64 (9223372036854775807 bytes is 9k petabytes) still deserialize to a Dart int
-    return deserializeInt64();
+    return deserializeUint64().toInt();
   }
 
   @override

serde-generate/runtime/dart/bincode/bincode_serializer.dart

@@ -4,19 +4,22 @@
 part of bincode;
 
 class BincodeSerializer extends BinarySerializer {
+  BincodeSerializer()
+      : super(
+          containerDepthBudget: maxContainerDepth,
+        );
+
   @override
   void serializeLength(int value) {
-    // bincode expects a u64 but since the capacity of a Dart int is less than that
-    // we can safely serialize as int to simplify over constructing Uint8 bytes
-    return serializeInt64(value);
+    serializeUint64(Uint64(BigInt.from(value)));
   }
 
   @override
   void serializeVariantIndex(int value) {
     serializeUint32(value);
   }
 
-  void sortMapEntries(Int32List offsets) {
+  void sortMapEntries(List<int> offsets) {
     // Not required by the format.
   }
 }

serde-generate/runtime/dart/pubspec.yaml

@@ -1,10 +1,10 @@
 name: serde
 
 environment:
-  sdk: '>=2.14.0 <3.0.0'
+  sdk: '>=3.0.0 <4.0.0'
 
 dependencies:
   meta: ^1.0.0
   tuple: ^2.0.0
-dev_dependencies: 
+dev_dependencies:
   test: ^1.19.3

serde-generate/runtime/dart/serde/binary_deserializer.dart

@@ -4,20 +4,32 @@
 part of serde;
 
 abstract class BinaryDeserializer {
-  BinaryDeserializer(Uint8List input) : input = ByteData.view(input.buffer);
+  BinaryDeserializer({
+    required Uint8List input,
+    required this.containerDepthBudget,
+  }) : input = ByteData.view(input.buffer);
 
   @protected
   final ByteData input;
   int _offset = 0;
+  int containerDepthBudget;
 
   int get offset {
     return _offset;
   }
 
   bool deserializeBool() {
-    final result = input.getUint8(_offset) != 0;
+    final result = input.getUint8(_offset);
     _offset += 1;
-    return result;
+    if (result == 0) {
+      return false;
+    } else if (result == 1) {
+      return true;
+    } else {
+      throw Exception(
+        'Invalid boolean: expected 0 or 1, but got ${result}',
+      );
+    }
   }
 
   Unit deserializeUnit() {
@@ -146,4 +158,15 @@ abstract class BinaryDeserializer {
       return number.toUnsigned(byteLength * 8);
     }
   }
+
+  void increaseContainerDepth() {
+    if (containerDepthBudget == 0) {
+      throw Exception('exceeded maximum container depth');
+    }
+    containerDepthBudget -= 1;
+  }
+
+  void decreaseContainerDepth() {
+    containerDepthBudget += 1;
+  }
 }

serde-generate/runtime/dart/serde/binary_serializer.dart

@@ -4,6 +4,11 @@
 part of serde;
 
 abstract class BinarySerializer {
+  BinarySerializer({
+    required this.containerDepthBudget,
+  });
+
+  int containerDepthBudget;
   final List<int> output = List<int>.empty(growable: true);
 
   Uint8List get bytes {
@@ -129,12 +134,25 @@ abstract class BinarySerializer {
   void serializeLength(int len);
 
   void serializeInt128(Int128 value) {
-    serializeInt64(value.low.toInt());
-    serializeInt64(value.high.toInt());
+    serializeUint64(Uint64(value.low));
+    serializeUint64(Uint64(value.high));
   }
 
   void serializeUint128(Uint128 value) {
     serializeUint64(Uint64(value.low));
     serializeUint64(Uint64(value.high));
   }
+
+  void increaseContainerDepth() {
+    if (containerDepthBudget == 0) {
+      throw Exception('exceeded maximum container depth');
+    }
+    containerDepthBudget -= 1;
+  }
+
+  void decreaseContainerDepth() {
+    containerDepthBudget += 1;
+  }
+
+  void sortMapEntries(List<int> offsets);
 }

serde-generate/src/dart.rs

@@ -86,7 +86,7 @@ impl<'a> CodeGenerator<'a> {
             r#"name: {}
 
 environment:
-  sdk: '>=2.14.0 <3.0.0'
+  sdk: '>=3.0.0 <4.0.0'
 
 dependencies:
   meta: ^1.0.0
@@ -670,53 +670,43 @@ return obj;
         }
 
         if self.generator.config.serialization {
-            // a struct (UnitStruct) with zero fields
-            if variant_index.is_none() && fields.is_empty() {
-                writeln!(
-                    self.out,
-                    "\n{}.deserialize(BinaryDeserializer deserializer);",
-                    self.quote_qualified_name(name)
-                )?;
             // Deserialize (struct) or Load (variant)
-            } else if variant_index.is_none() {
-                writeln!(
-                    self.out,
-                    "\n{}.deserialize(BinaryDeserializer deserializer) :",
-                    self.quote_qualified_name(name)
-                )?;
-            } else if !fields.is_empty() {
+            if variant_index.is_none() {
                 writeln!(
                     self.out,
-                    "\n{}.load(BinaryDeserializer deserializer) :",
+                    "\nstatic {} deserialize(BinaryDeserializer deserializer) {{",
                     self.quote_qualified_name(name)
                 )?;
             } else {
                 writeln!(
                     self.out,
-                    "\n{}.load(BinaryDeserializer deserializer);",
+                    "\nstatic {} load(BinaryDeserializer deserializer) {{",
                     self.quote_qualified_name(name)
                 )?;
             }
 
             self.out.indent();
-            for (index, field) in fields.iter().enumerate() {
-                if index == field_count - 1 {
-                    writeln!(
-                        self.out,
-                        "{} = {};",
-                        self.quote_field(&field.name.to_mixed_case()),
-                        self.quote_deserialize(&field.value)
-                    )?;
-                } else {
-                    writeln!(
-                        self.out,
-                        "{} = {},",
-                        self.quote_field(&field.name.to_mixed_case()),
-                        self.quote_deserialize(&field.value)
-                    )?;
-                }
+            writeln!(self.out, "deserializer.increaseContainerDepth();")?;
+            writeln!(
+                self.out,
+                "final instance = {}(",
+                self.quote_qualified_name(name)
+            )?;
+            self.out.indent();
+            for field in fields {
+                writeln!(
+                    self.out,
+                    "{}: {},",
+                    self.quote_field(&field.name.to_mixed_case()),
+                    self.quote_deserialize(&field.value)
+                )?;
             }
             self.out.unindent();
+            writeln!(self.out, ");")?;
+            writeln!(self.out, "deserializer.decreaseContainerDepth();")?;
+            writeln!(self.out, "return instance;")?;
+            self.out.unindent();
+            writeln!(self.out, "}}")?;
 
             if variant_index.is_none() {
                 for encoding in &self.generator.config.encodings {
@@ -780,6 +770,7 @@ return obj;
         if self.generator.config.serialization {
             writeln!(self.out, "\nvoid serialize(BinarySerializer serializer) {{",)?;
             self.out.indent();
+            writeln!(self.out, "serializer.increaseContainerDepth();")?;
             if let Some(index) = variant_index {
                 writeln!(self.out, "serializer.serializeVariantIndex({});", index)?;
             }
@@ -793,6 +784,7 @@ return obj;
                     )
                 )?;
             }
+            writeln!(self.out, "serializer.decreaseContainerDepth();")?;
             self.out.unindent();
             writeln!(self.out, "}}")?;