Add 'add_minting_script' to txbuilder

cffls · cffls · commit 03c74b2f8ca1 · 2022-05-28T15:28:45.000-07:00
diff --git a/integration-test/test/test_all.py b/integration-test/test/test_all.py
@@ -57,6 +57,23 @@ def assert_output(self, target_address, target_output):
 
         assert found, f"Cannot find target UTxO in address: {target_address}"
 
+    @retry(tries=4, delay=6, backoff=2, jitter=(1, 3))
+    def fund(self, source_address, source_key, target_address, amount=5000000):
+        builder = TransactionBuilder(self.chain_context)
+
+        builder.add_input_address(source_address)
+        output = TransactionOutput(target_address, amount)
+        builder.add_output(output)
+
+        signed_tx = builder.build_and_sign([source_key], source_address)
+
+        print("############### Transaction created ###############")
+        print(signed_tx)
+        print(signed_tx.to_cbor())
+        print("############### Submitting transaction ###############")
+        self.chain_context.submit_tx(signed_tx.to_cbor())
+        self.assert_output(target_address, target_output=output)
+
     @retry(tries=4, delay=6, backoff=2, jitter=(1, 3))
     def test_mint(self):
         address = Address(self.payment_vkey.hash(), network=self.NETWORK)
@@ -372,3 +389,94 @@ def test_stake_delegation(self):
         print(signed_tx.to_cbor())
         print("############### Submitting transaction ###############")
         self.chain_context.submit_tx(signed_tx.to_cbor())
+
+    @retry(tries=4, delay=6, backoff=2, jitter=(1, 3))
+    def test_mint_nft_with_script(self):
+        address = Address(self.payment_vkey.hash(), network=self.NETWORK)
+
+        with open("./plutus_scripts/fortytwo.plutus", "r") as f:
+            script_hex = f.read()
+            forty_two_script = cbor2.loads(bytes.fromhex(script_hex))
+
+        policy_id = plutus_script_hash(forty_two_script)
+
+        my_nft = MultiAsset.from_primitive(
+            {
+                policy_id.payload: {
+                    b"MY_SCRIPT_NFT_1": 1,  # Name of our NFT1  # Quantity of this NFT
+                    b"MY_SCRIPT_NFT_2": 1,  # Name of our NFT2  # Quantity of this NFT
+                }
+            }
+        )
+
+        metadata = {
+            721: {
+                policy_id.payload.hex(): {
+                    "MY_SCRIPT_NFT_1": {
+                        "description": "This is my first NFT thanks to PyCardano",
+                        "name": "PyCardano NFT example token 1",
+                        "id": 1,
+                        "image": "ipfs://QmRhTTbUrPYEw3mJGGhQqQST9k86v1DPBiTTWJGKDJsVFw",
+                    },
+                    "MY_SCRIPT_NFT_2": {
+                        "description": "This is my second NFT thanks to PyCardano",
+                        "name": "PyCardano NFT example token 2",
+                        "id": 2,
+                        "image": "ipfs://QmRhTTbUrPYEw3mJGGhQqQST9k86v1DPBiTTWJGKDJsVFw",
+                    },
+                }
+            }
+        }
+
+        # Place metadata in AuxiliaryData, the format acceptable by a transaction.
+        auxiliary_data = AuxiliaryData(AlonzoMetadata(metadata=Metadata(metadata)))
+
+        # Create a transaction builder
+        builder = TransactionBuilder(self.chain_context)
+
+        # Add our own address as the input address
+        builder.add_input_address(address)
+
+        # Add minting script with an empty datum and a minting redeemer
+        builder.add_minting_script(
+            forty_two_script, redeemer=Redeemer(RedeemerTag.MINT, 42)
+        )
+
+        # Set nft we want to mint
+        builder.mint = my_nft
+
+        # Set transaction metadata
+        builder.auxiliary_data = auxiliary_data
+
+        # Calculate the minimum amount of lovelace that need to hold the NFT we are going to mint
+        min_val = min_lovelace(Value(0, my_nft), self.chain_context)
+
+        # Send the NFT to our own address
+        nft_output = TransactionOutput(address, Value(min_val, my_nft))
+        builder.add_output(nft_output)
+
+        # Create a collateral
+        self.fund(address, self.payment_skey, address)
+
+        non_nft_utxo = None
+        for utxo in self.chain_context.utxos(str(address)):
+            # multi_asset should be empty for collateral utxo
+            if not utxo.output.amount.multi_asset:
+                non_nft_utxo = utxo
+                break
+
+        builder.collaterals.append(non_nft_utxo)
+
+        # Build and sign transaction
+        signed_tx = builder.build_and_sign([self.payment_skey], address)
+        # signed_tx.transaction_witness_set.plutus_data
+
+        print("############### Transaction created ###############")
+        print(signed_tx)
+        print(signed_tx.to_cbor())
+
+        # Submit signed transaction to the network
+        print("############### Submitting transaction ###############")
+        self.chain_context.submit_tx(signed_tx.to_cbor())
+
+        self.assert_output(address, nft_output)
diff --git a/pycardano/txbuilder.py b/pycardano/txbuilder.py
@@ -2,7 +2,7 @@
 
 from copy import copy, deepcopy
 from dataclasses import dataclass, field, fields
-from typing import Dict, List, Optional, Set, Union
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 from pycardano.address import Address, AddressType
 from pycardano.backend.base import ChainContext
@@ -115,6 +115,10 @@ class TransactionBuilder:
         init=False, default_factory=lambda: {}
     )
 
+    _minting_script_to_redeemers: List[Tuple[bytes, Redeemer]] = field(
+        init=False, default_factory=lambda: []
+    )
+
     _inputs_to_scripts: Dict[UTxO, bytes] = field(
         init=False, default_factory=lambda: {}
     )
@@ -160,7 +164,11 @@ def _consolidate_redeemer(self, redeemer):
                     redeemer.ex_units = ExecutionUnits(0, 0)
 
     def add_script_input(
-        self, utxo: UTxO, script: bytes, datum: Datum, redeemer: Redeemer
+        self,
+        utxo: UTxO,
+        script: bytes,
+        datum: Optional[Datum] = None,
+        redeemer: Optional[Redeemer] = None,
     ) -> TransactionBuilder:
         """Add a script UTxO to transaction's inputs.
 
@@ -178,18 +186,44 @@ def add_script_input(
                 f"Expect the output address of utxo to be script type, "
                 f"but got {utxo.output.address.address_type} instead."
             )
-        if utxo.output.datum_hash != datum.hash():
+        if utxo.output.datum_hash and utxo.output.datum_hash != datum_hash(datum):
             raise InvalidArgumentException(
                 f"Datum hash in transaction output is {utxo.output.datum_hash}, "
-                f"but actual datum hash from input datum is {datum.hash()}."
+                f"but actual datum hash from input datum is {datum_hash(datum)}."
             )
-        self.datums[datum.hash()] = datum
-        self._consolidate_redeemer(redeemer)
-        self._inputs_to_redeemers[utxo] = redeemer
+        if datum:
+            self.datums[datum_hash(datum)] = datum
+        if redeemer:
+            self._consolidate_redeemer(redeemer)
+            self._inputs_to_redeemers[utxo] = redeemer
         self._inputs_to_scripts[utxo] = script
         self.inputs.append(utxo)
         return self
 
+    def add_minting_script(
+        self,
+        script: bytes,
+        redeemer: Optional[Redeemer] = None,
+    ) -> TransactionBuilder:
+        """Add a minting script along with its datum and redeemer to this transaction.
+
+        Args:
+            script (Optional[bytes]): A plutus script.
+            redeemer (Optional[Redeemer]): A plutus redeemer to unlock the UTxO.
+
+        Returns:
+            TransactionBuilder: Current transaction builder.
+        """
+        if redeemer:
+            if redeemer.tag != RedeemerTag.MINT:
+                raise InvalidArgumentException(
+                    f"Expect the redeemer tag's type to be {RedeemerTag.MINT}, "
+                    f"but got {redeemer.tag} instead."
+                )
+            self._consolidate_redeemer(redeemer)
+        self._minting_script_to_redeemers.append((script, redeemer))
+        return self
+
     def add_input_address(self, address: Union[Address, str]) -> TransactionBuilder:
         """Add an address to transaction's input address.
         Unlike :meth:`add_input`, which deterministically adds a UTxO to the transaction's inputs, `add_input_address`
@@ -225,7 +259,7 @@ def add_output(
             tx_out.datum_hash = datum_hash(datum)
         self.outputs.append(tx_out)
         if add_datum_to_witness:
-            self.datums[datum.hash()] = datum
+            self.datums[datum_hash(datum)] = datum
         return self
 
     @property
@@ -258,15 +292,20 @@ def fee(self, fee: int):
 
     @property
     def scripts(self) -> List[bytes]:
-        return list(set(self._inputs_to_scripts.values()))
+        return list(
+            set(self._inputs_to_scripts.values())
+            | {s for s, _ in self._minting_script_to_redeemers}
+        )
 
     @property
     def datums(self) -> Dict[DatumHash, Datum]:
         return self._datums
 
     @property
     def redeemers(self) -> List[Redeemer]:
-        return list(self._inputs_to_redeemers.values())
+        return list(self._inputs_to_redeemers.values()) + [
+            r for _, r in self._minting_script_to_redeemers
+        ]
 
     @property
     def script_data_hash(self) -> Optional[ScriptDataHash]:
@@ -585,6 +624,10 @@ def _set_redeemer_index(self):
                 redeemer.index = sorted_mint_policies.index(
                     plutus_script_hash(self._inputs_to_scripts[utxo])
                 )
+
+        for script, redeemer in self._minting_script_to_redeemers:
+            redeemer.index = sorted_mint_policies.index(plutus_script_hash(script))
+
         self.redeemers.sort(key=lambda r: r.index)
 
     def _build_tx_body(self) -> TransactionBody:
diff --git a/pycardano/utils.py b/pycardano/utils.py
@@ -135,7 +135,10 @@ def script_data_hash(
         cost_models = COST_MODELS
 
     redeemer_bytes = cbor2.dumps(redeemers, default=default_encoder)
-    datum_bytes = cbor2.dumps(datums, default=default_encoder)
+    if datums:
+        datum_bytes = cbor2.dumps(datums, default=default_encoder)
+    else:
+        datum_bytes = b""
     cost_models_bytes = cbor2.dumps(cost_models, default=default_encoder)
 
     return ScriptDataHash(
diff --git a/test/pycardano/test_txbuilder.py b/test/pycardano/test_txbuilder.py
@@ -9,6 +9,7 @@
 from pycardano.coinselection import RandomImproveMultiAsset
 from pycardano.exception import (
     InsufficientUTxOBalanceException,
+    InvalidArgumentException,
     InvalidTransactionException,
     UTxOSelectionException,
 )
@@ -482,6 +483,112 @@ def test_add_script_input(chain_context):
     )
 
 
+def test_wrong_redeemer_execution_units(chain_context):
+    tx_builder = TransactionBuilder(chain_context)
+    tx_in1 = TransactionInput.from_primitive(
+        ["18cbe6cadecd3f89b60e08e68e5e6c7d72d730aaa1ad21431590f7e6643438ef", 0]
+    )
+    tx_in2 = TransactionInput.from_primitive(
+        ["18cbe6cadecd3f89b60e08e68e5e6c7d72d730aaa1ad21431590f7e6643438ef", 1]
+    )
+    plutus_script = b"dummy test script"
+    script_hash = plutus_script_hash(plutus_script)
+    script_address = Address(script_hash)
+    datum = PlutusData()
+    utxo1 = UTxO(
+        tx_in1, TransactionOutput(script_address, 10000000, datum_hash=datum.hash())
+    )
+    mint = MultiAsset.from_primitive({script_hash.payload: {b"TestToken": 1}})
+    utxo2 = UTxO(
+        tx_in2,
+        TransactionOutput(
+            script_address, Value(10000000, mint), datum_hash=datum.hash()
+        ),
+    )
+    redeemer1 = Redeemer(RedeemerTag.SPEND, PlutusData())
+    redeemer2 = Redeemer(RedeemerTag.MINT, PlutusData())
+    redeemer3 = Redeemer(
+        RedeemerTag.MINT, PlutusData(), ExecutionUnits(1000000, 1000000)
+    )
+    tx_builder.mint = mint
+    tx_builder.add_script_input(utxo1, plutus_script, datum, redeemer1)
+    tx_builder.add_script_input(utxo1, plutus_script, datum, redeemer2)
+    with pytest.raises(InvalidArgumentException):
+        tx_builder.add_script_input(utxo2, plutus_script, datum, redeemer3)
+
+
+def test_all_redeemer_should_provide_execution_units(chain_context):
+    tx_builder = TransactionBuilder(chain_context)
+    tx_in1 = TransactionInput.from_primitive(
+        ["18cbe6cadecd3f89b60e08e68e5e6c7d72d730aaa1ad21431590f7e6643438ef", 0]
+    )
+    tx_in2 = TransactionInput.from_primitive(
+        ["18cbe6cadecd3f89b60e08e68e5e6c7d72d730aaa1ad21431590f7e6643438ef", 1]
+    )
+    plutus_script = b"dummy test script"
+    script_hash = plutus_script_hash(plutus_script)
+    script_address = Address(script_hash)
+    datum = PlutusData()
+    utxo1 = UTxO(
+        tx_in1, TransactionOutput(script_address, 10000000, datum_hash=datum.hash())
+    )
+    mint = MultiAsset.from_primitive({script_hash.payload: {b"TestToken": 1}})
+    redeemer1 = Redeemer(
+        RedeemerTag.SPEND, PlutusData(), ExecutionUnits(1000000, 1000000)
+    )
+    redeemer2 = Redeemer(RedeemerTag.MINT, PlutusData())
+    tx_builder.mint = mint
+    tx_builder.add_script_input(utxo1, plutus_script, datum, redeemer1)
+    with pytest.raises(InvalidArgumentException):
+        tx_builder.add_script_input(utxo1, plutus_script, datum, redeemer2)
+
+
+def test_add_minting_script(chain_context):
+    tx_builder = TransactionBuilder(chain_context)
+    tx_in1 = TransactionInput.from_primitive(
+        ["18cbe6cadecd3f89b60e08e68e5e6c7d72d730aaa1ad21431590f7e6643438ef", 0]
+    )
+    plutus_script = b"dummy test script"
+    script_hash = plutus_script_hash(plutus_script)
+    script_address = Address(script_hash)
+    utxo1 = UTxO(tx_in1, TransactionOutput(script_address, 10000000))
+    mint = MultiAsset.from_primitive({script_hash.payload: {b"TestToken": 1}})
+    redeemer1 = Redeemer(
+        RedeemerTag.MINT, PlutusData(), ExecutionUnits(1000000, 1000000)
+    )
+    tx_builder.mint = mint
+    tx_builder.add_input(utxo1)
+    tx_builder.add_minting_script(plutus_script, redeemer1)
+    receiver = Address.from_primitive(
+        "addr_test1vrm9x2zsux7va6w892g38tvchnzahvcd9tykqf3ygnmwtaqyfg52x"
+    )
+    tx_builder.add_output(TransactionOutput(receiver, Value(5000000, mint)))
+    tx_body = tx_builder.build(change_address=receiver)
+    witness = tx_builder.build_witness_set()
+    assert [plutus_script] == witness.plutus_script
+    assert (
+        "a5008182582018cbe6cadecd3f89b60e08e68e5e6c7d72d730aaa1ad2143159"
+        "0f7e6643438ef00018282581d60f6532850e1bccee9c72a9113ad98bcc5dbb3"
+        "0d2ac960262444f6e5f4821a004c4b40a1581c876f19078b059c928258d848c"
+        "8cd871864d281eb6776ed7f80b68536a14954657374546f6b656e0182581d60"
+        "f6532850e1bccee9c72a9113ad98bcc5dbb30d2ac960262444f6e5f41a0048d"
+        "8f3021a0003724d09a1581c876f19078b059c928258d848c8cd871864d281eb"
+        "6776ed7f80b68536a14954657374546f6b656e010b58205fcf68adc7eb6e507"
+        "d15fb07d1c4e39d908bc9dfe642368afcddd881c5d46517" == tx_body.to_cbor()
+    )
+
+
+def test_add_minting_script_wrong_redeemer_type(chain_context):
+    tx_builder = TransactionBuilder(chain_context)
+    plutus_script = b"dummy test script"
+    redeemer1 = Redeemer(
+        RedeemerTag.SPEND, PlutusData(), ExecutionUnits(1000000, 1000000)
+    )
+
+    with pytest.raises(InvalidArgumentException):
+        tx_builder.add_minting_script(plutus_script, redeemer1)
+
+
 def test_excluded_input(chain_context):
     tx_builder = TransactionBuilder(chain_context, [RandomImproveMultiAsset([0, 0])])
     sender = "addr_test1vrm9x2zsux7va6w892g38tvchnzahvcd9tykqf3ygnmwtaqyfg52x"
diff --git a/test/pycardano/test_util.py b/test/pycardano/test_util.py
@@ -145,7 +145,14 @@ def test_script_data_hash():
 
 def test_script_data_hash_datum_only():
     unit = PlutusData()
-    redeemers = []
     assert ScriptDataHash.from_primitive(
         "2f50ea2546f8ce020ca45bfcf2abeb02ff18af2283466f888ae489184b3d2d39"
-    ) == script_data_hash(redeemers=redeemers, datums=[unit])
+    ) == script_data_hash(redeemers=[], datums=[unit])
+
+
+def test_script_data_hash_redeemer_only():
+    unit = PlutusData()
+    redeemers = []
+    assert ScriptDataHash.from_primitive(
+        "a88fe2947b8d45d1f8b798e52174202579ecf847b8f17038c7398103df2d27b0"
+    ) == script_data_hash(redeemers=redeemers, datums=[])
