Support redeemer map

pycardano/backend/blockfrost.py

@@ -24,8 +24,8 @@
     ExecutionUnits,
     PlutusV1Script,
     PlutusV2Script,
-    script_hash,
     PlutusV3Script,
+    script_hash,
 )
 from pycardano.serialization import RawCBOR
 from pycardano.transaction import (
@@ -189,10 +189,10 @@
             )
             return _try_fix_script(script_hash, v2script)
         elif script_type == "plutusV3":
             v3script = PlutusV3Script(
                 bytes.fromhex(self.api.script_cbor(script_hash).cbor)
             )
             return _try_fix_script(script_hash, v3script)
         else:
             script_json: JsonDict = self.api.script_json(
                 script_hash, return_type="json"

pycardano/plutus.py

@@ -8,12 +8,13 @@
 from dataclasses import dataclass, field, fields
 from enum import Enum
 from hashlib import sha256
-from typing import Any, Optional, Type, Union
+from typing import Any, List, Optional, Type, Union
 
 import cbor2
 from cbor2 import CBORTag
 from nacl.encoding import RawEncoder
 from nacl.hash import blake2b
+from typeguard import typechecked
 
 from pycardano.exception import DeserializeException, InvalidArgumentException
 from pycardano.hash import DATUM_HASH_SIZE, SCRIPT_HASH_SIZE, DatumHash, ScriptHash
@@ -44,6 +45,10 @@
     "PlutusV3Script",
     "RawPlutusData",
     "Redeemer",
+    "RedeemerKey",
+    "RedeemerValue",
+    "RedeemerMap",
+    "Redeemers",
     "ScriptType",
     "datum_hash",
     "plutus_script_hash",
@@ -993,6 +998,57 @@
         return redeemer
 
 
+@dataclass(repr=False)
+class RedeemerKey(ArrayCBORSerializable):
+    tag: RedeemerTag
+
+    index: int = field(default=0)
+
+    @classmethod
+    @limit_primitive_type(list, tuple)
+    def from_primitive(cls: Type[RedeemerKey], values: list) -> RedeemerKey:
+        tag = RedeemerTag.from_primitive(values[0])
+        index = values[1]
+        return cls(tag, index)
+
+    def __eq__(self, other):
+        if not isinstance(other, RedeemerKey):
+            return False
+        return self.tag == other.tag and self.index == other.index
+
+    def __hash__(self):
+        return hash(self.to_cbor())
+
+
+@dataclass(repr=False)
+class RedeemerValue(ArrayCBORSerializable):
+    data: Any
+
+    ex_units: ExecutionUnits
+
+    @classmethod
+    @limit_primitive_type(list)
+    def from_primitive(cls: Type[RedeemerValue], values: list) -> RedeemerValue:
+        if isinstance(values[0], CBORTag) and cls is RedeemerValue:
+            values[0] = RawPlutusData.from_primitive(values[0])
+        return super(RedeemerValue, cls).from_primitive([values[0], values[1]])
+
+    def __eq__(self, other):
+        if not isinstance(other, RedeemerValue):
+            return False
+        return self.data == other.data and self.ex_units == other.ex_units
+
+
+@typechecked
+class RedeemerMap(DictCBORSerializable):
+    KEY_TYPE = RedeemerKey
+
+    VALUE_TYPE = RedeemerValue
+
+
+Redeemers = Union[List[Redeemer], RedeemerMap]
+
+
 def plutus_script_hash(
     script: Union[bytes, PlutusV1Script, PlutusV2Script]
 ) -> ScriptHash:

pycardano/txbuilder.py

@@ -4,6 +4,7 @@
 from dataclasses import dataclass, field, fields
 from typing import Dict, List, Optional, Set, Tuple, Union
 
+from pycardano import RedeemerMap
 from pycardano.address import Address, AddressType
 from pycardano.backend.base import ChainContext
 from pycardano.certificate import (
@@ -42,7 +43,10 @@
     PlutusV2Script,
     PlutusV3Script,
     Redeemer,
+    RedeemerKey,
+    Redeemers,
     RedeemerTag,
+    RedeemerValue,
     ScriptType,
     datum_hash,
     script_hash,
@@ -186,15 +190,15 @@
                 raise InvalidArgumentException(
                     f"All redeemers need to provide execution units if the firstly "
                     f"added redeemer specifies execution units. \n"
-                    f"Added redeemers: {self.redeemers} \n"
+                    f"Added redeemers: {self._redeemer_list} \n"
                     f"New redeemer: {redeemer}"
                 )
             if self._should_estimate_execution_units:
                 if redeemer.ex_units:
                     raise InvalidArgumentException(
                         f"No redeemer should provide execution units if the firstly "
                         f"added redeemer didn't provide execution units. \n"
-                        f"Added redeemers: {self.redeemers} \n"
+                        f"Added redeemers: {self._redeemer_list} \n"
                         f"New redeemer: {redeemer}"
                     )
                 else:
@@ -485,16 +489,32 @@
         return self._datums
 
     @property
-    def redeemers(self) -> List[Redeemer]:
+    def _redeemer_list(self) -> List[Redeemer]:
         return (
             [r for r in self._inputs_to_redeemers.values() if r is not None]
             + [r for _, r in self._minting_script_to_redeemers if r is not None]
             + [r for _, r in self._withdrawal_script_to_redeemers if r is not None]
         )
 
+    def redeemers(self) -> RedeemerMap:
+        redeemers = RedeemerMap()
+        for r in self._redeemer_list:
+            if r.tag is None:
+                raise InvalidArgumentException(
+                    f"Redeemer tag is not set. Redeemer: {r}"
+                )
+            if r.ex_units is None:
+                raise InvalidArgumentException(
+                    f"Execution units are not set. Redeemer: {r}"
+                )
+            k = RedeemerKey(r.tag, r.index)
+            v = RedeemerValue(r.data, r.ex_units)
+            redeemers[k] = v
+        return redeemers
+
     @property
     def script_data_hash(self) -> Optional[ScriptDataHash]:
-        if self.datums or self.redeemers:
+        if self.datums or self._redeemer_list:
             cost_models = {}
             for s in self.all_scripts:
                 if isinstance(s, PlutusV1Script) or type(s) is bytes:
@@ -512,7 +532,7 @@
                         "PlutusV3", {}
                     )
             return script_data_hash(
-                self.redeemers, list(self.datums.values()), CostModels(cost_models)
+                self.redeemers(), list(self.datums.values()), CostModels(cost_models)
             )
         else:
             return None
@@ -878,7 +898,7 @@
                     script_staking_credential.to_primitive()
                 )
 
-        self.redeemers.sort(key=lambda r: r.index)
+        self._redeemer_list.sort(key=lambda r: r.index)
 
     def _build_tx_body(self) -> TransactionBody:
         tx_body = TransactionBody(
@@ -946,13 +966,16 @@
             )
         return tx
 
-    def build_witness_set(self, remove_dup_script=False) -> TransactionWitnessSet:
+    def build_witness_set(
+        self, remove_dup_script: bool = False, post_chang: bool = True
+    ) -> TransactionWitnessSet:
         """Build a transaction witness set, excluding verification key witnesses.
         This function is especially useful when the transaction involves Plutus scripts.
 
         Args:
             remove_dup_script (bool): Whether to remove scripts, that are already attached to inputs,
              from the witness set.
+            post_chang (bool): Whether to use chang serialization for the witness.
 
         Returns:
             TransactionWitnessSet: A transaction witness set without verification key witnesses.
@@ -986,16 +1009,23 @@
                 elif isinstance(script, PlutusV3Script):
                     plutus_v3_scripts.append(script)
                 else:
                     raise InvalidArgumentException(
                         f"Unsupported script type: {type(script)}"
                     )
 
+        redeemers: Optional[Redeemers] = None
+        if self._redeemer_list:
+            if not post_chang:
+                redeemers = self._redeemer_list
+            else:
+                redeemers = self.redeemers()
+
         return TransactionWitnessSet(
             native_scripts=native_scripts if native_scripts else None,
             plutus_v1_script=plutus_v1_scripts if plutus_v1_scripts else None,
             plutus_v2_script=plutus_v2_scripts if plutus_v2_scripts else None,
             plutus_v3_script=plutus_v3_scripts if plutus_v3_scripts else None,
-            redeemer=self.redeemers if self.redeemers else None,
+            redeemer=redeemers,
             plutus_data=list(self.datums.values()) if self.datums else None,
         )
 
@@ -1009,13 +1039,13 @@
 
     def _estimate_fee(self):
         plutus_execution_units = ExecutionUnits(0, 0)
-        for redeemer in self.redeemers:
+        for redeemer in self._redeemer_list:
             plutus_execution_units += redeemer.ex_units
 
         ref_script_size = 0
         for s in self._reference_scripts:
             if isinstance(s, NativeScript):
                 ref_script_size += len(s.to_cbor())
             else:
                 ref_script_size += len(s)
 
@@ -1357,7 +1387,7 @@
             estimated_execution_units = self._estimate_execution_units(
                 change_address, merge_change, collateral_change_address
             )
-            for r in self.redeemers:
+            for r in self._redeemer_list:
                 assert (
                     r.tag is not None
                 ), "Expected tag of redeemer to be set, but found None"

pycardano/utils.py

@@ -11,7 +11,7 @@
 
 from pycardano.backend.base import ChainContext
 from pycardano.hash import SCRIPT_DATA_HASH_SIZE, SCRIPT_HASH_SIZE, ScriptDataHash
-from pycardano.plutus import COST_MODELS, CostModels, Datum, Redeemer
+from pycardano.plutus import COST_MODELS, CostModels, Datum, Redeemers
 from pycardano.serialization import default_encoder
 from pycardano.transaction import MultiAsset, TransactionOutput, Value
 
@@ -231,14 +231,14 @@ def min_lovelace_post_alonzo(output: TransactionOutput, context: ChainContext) -
 
 
 def script_data_hash(
-    redeemers: List[Redeemer],
+    redeemers: Redeemers,
     datums: List[Datum],
     cost_models: Optional[Union[CostModels, Dict]] = None,
 ) -> ScriptDataHash:
     """Calculate plutus script data hash
 
     Args:
-        redeemers (List[Redeemer]): Redeemers to include.
+        redeemers (Redeemers): Redeemers to include.
         datums (List[Datum]): Datums to include.
         cost_models (Optional[CostModels]): Cost models.
 

pycardano/witness.py

@@ -13,6 +13,7 @@
     PlutusV3Script,
     RawPlutusData,
     Redeemer,
+    Redeemers,
 )
 from pycardano.serialization import (
     ArrayCBORSerializable,
@@ -76,9 +77,9 @@ class TransactionWitnessSet(MapCBORSerializable):
         metadata={"optional": True, "key": 4, "object_hook": list_hook(RawPlutusData)},
     )
 
-    redeemer: Optional[List[Redeemer]] = field(
+    redeemer: Optional[Redeemers] = field(
         default=None,
-        metadata={"optional": True, "key": 5, "object_hook": list_hook(Redeemer)},
+        metadata={"optional": True, "key": 5},
     )
 
     plutus_v2_script: Optional[List[PlutusV2Script]] = field(

test/pycardano/test_plutus.py

@@ -17,7 +17,10 @@
     PlutusData,
     RawPlutusData,
     Redeemer,
+    RedeemerKey,
+    RedeemerMap,
     RedeemerTag,
+    RedeemerValue,
     Unit,
     id_map,
     plutus_script_hash,
@@ -520,3 +523,64 @@ class B(PlutusData):
     )
 
     assert B.from_cbor(cbor).to_cbor_hex() == cbor
+
+
+def test_redeemer_key():
+    # Test creation and equality
+    key1 = RedeemerKey(RedeemerTag.SPEND, 0)
+    key2 = RedeemerKey(RedeemerTag.SPEND, 0)
+    key3 = RedeemerKey(RedeemerTag.MINT, 1)
+
+    assert key1 == key2
+    assert key1 != key3
+
+    # Test hashing
+    assert hash(key1) == hash(key2)
+    assert hash(key1) != hash(key3)
+
+    # Test serialization and deserialization
+    serialized = key1.to_primitive()
+    deserialized = RedeemerKey.from_primitive(serialized)
+    assert key1 == deserialized
+
+
+def test_redeemer_value():
+    # Test creation
+    data = RawPlutusData(42)
+    ex_units = ExecutionUnits(10, 20)
+    value = RedeemerValue(data, ex_units)
+
+    assert value.data == data
+    assert value.ex_units == ex_units
+
+    # Test serialization and deserialization
+    serialized = value.to_primitive()
+    deserialized = RedeemerValue.from_primitive(serialized)
+    assert value.data.data == deserialized.data
+    assert value.ex_units == deserialized.ex_units
+
+
+def test_redeemer_map():
+    # Test creation and adding items
+    redeemer_map = RedeemerMap()
+    key1 = RedeemerKey(RedeemerTag.SPEND, 0)
+    value1 = RedeemerValue(42, ExecutionUnits(10, 20))
+    key2 = RedeemerKey(RedeemerTag.MINT, 1)
+    value2 = RedeemerValue(b"test", ExecutionUnits(30, 40))
+
+    redeemer_map[key1] = value1
+    redeemer_map[key2] = value2
+
+    assert len(redeemer_map) == 2
+    assert redeemer_map[key1] == value1
+    assert redeemer_map[key2] == value2
+
+    # Test serialization and deserialization
+    serialized = redeemer_map.to_cbor()
+    deserialized = RedeemerMap.from_cbor(serialized)
+
+    assert len(deserialized) == 2
+    assert deserialized[key1].data == value1.data
+    assert deserialized[key1].ex_units == value1.ex_units
+    assert deserialized[key2].data == value2.data
+    assert deserialized[key2].ex_units == value2.ex_units