Fix OrderedSet serialization

Author: cffls

pycardano/serialization.py

@@ -160,6 +160,7 @@ class RawCBOR:
     Fraction,
     FrozenList,
     IndefiniteFrozenList,
+    ByteString,
 )
 """
 A list of types that could be encoded by
@@ -1128,33 +1129,53 @@ def list_hook(
     return lambda vals: [cls.from_primitive(v) for v in vals]
 
 
-class OrderedSet(list, IndefiniteList, Generic[T], CBORSerializable):  # type: ignore
+class OrderedSet(Generic[T], CBORSerializable):  # type: ignore
     def __init__(
         self,
         iterable: Optional[Union[List[T], IndefiniteList]] = None,
         use_tag: bool = True,
     ):
         super().__init__()
-        self._set: Set[str] = set()
+        self._dict: Dict[bytes, int] = {}
+        self._list: List[T] = []
         self._use_tag = use_tag
         self._is_indefinite_list = False
         if iterable:
             self._is_indefinite_list = isinstance(iterable, IndefiniteList)
             self.extend(iterable)
 
     def append(self, item: T) -> None:
-        item_key = str(item)
-        if item_key not in self._set:
-            super().append(item)
-            self._set.add(item_key)
+        if item in self:
+            return
+        self._list.append(item)
+        self._dict[dumps(item, default=default_encoder)] = len(self._list) - 1
 
     def extend(self, items: Iterable[T]) -> None:
         self._is_indefinite_list = isinstance(items, IndefiniteList)
         for item in items:
             self.append(item)
 
+    def remove(self, item: T) -> None:
+        if item not in self:
+            return
+        index = self._dict.pop(dumps(item, default=default_encoder))
+        self._list.pop(index)
+        # Update the indices in the dictionary
+        for key, idx in self._dict.items():
+            if idx > index:
+                self._dict[key] = idx - 1
+
     def __contains__(self, item: object) -> bool:
-        return str(item) in self._set
+        return dumps(item, default=default_encoder) in self._dict
+
+    def __iter__(self):
+        return iter(self._list)
+
+    def __getitem__(self, index: int) -> T:
+        return self._list[index]
+
+    def __len__(self) -> int:
+        return len(self._list)
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, OrderedSet):

pycardano/utils.py

@@ -260,13 +260,7 @@ def script_data_hash(
     redeemer_bytes = cbor2.dumps(redeemers, default=default_encoder)
 
     if datums:
-        if not isinstance(datums, NonEmptyOrderedSet):
-            # If datums is not a NonEmptyOrderedSet, handle it as a list
-            datum_bytes = cbor2.dumps(datums, default=default_encoder)
-        else:
-            datum_bytes = cbor2.dumps(
-                datums.to_shallow_primitive(), default=default_encoder
-            )
+        datum_bytes = cbor2.dumps(datums, default=default_encoder)
     else:
         datum_bytes = b""
 

test/pycardano/test_serialization.py

@@ -638,6 +638,23 @@ def test_ordered_set():
     assert list(s) == [1, 2, 3]
     assert s._use_tag
 
+    # Test remove
+    s = OrderedSet([1, 2, 3, 4])
+    s.remove(2)
+    assert list(s) == [1, 3, 4]
+    assert 2 not in s
+    assert 1 in s
+    assert 3 in s
+    assert 4 in s
+    s.remove(2)
+    assert list(s) == [1, 3, 4]
+    assert 2 not in s
+    s.remove(3)
+    assert list(s) == [1, 4]
+    assert 3 not in s
+    s.remove(4)
+    assert list(s) == [1]
+
 
 def test_ordered_set_with_complex_types():
     # Test with VerificationKeyWitness
@@ -909,9 +926,9 @@ class MyOrderedSet(OrderedSet):
     assert 4 not in s
 
     # Test with complex objects
-    class TestObj:
-        def __init__(self, value):
-            self.value = value
+    @dataclass(repr=False)
+    class TestObj(ArrayCBORSerializable):
+        value: str
 
         def __str__(self):
             return f"TestObj({self.value})"

test/pycardano/test_txbuilder.py

@@ -411,12 +411,12 @@ def test_tx_builder_mint_multi_asset(chain_context):
             [
                 sender_address.to_primitive(),
                 [
-                    5809111,
+                    5809155,
                     {b"1111111111111111111111111111": {b"Token1": 1, b"Token2": 2}},
                 ],
             ],
         ],
-        2: 190889,
+        2: 190845,
         3: 123456789,
         8: 1000,
         9: mint,