Merge branch 'feat/next' into attributes-for-token-amount

multiversx_sdk/abi/abi_test.py

@@ -474,6 +474,7 @@ def test_decode_custom_enum():
         ),
     )
     setattr(expected_output, "__discriminant__", 5)
+    setattr(expected_output, "__name__", "SendTransferExecuteEgld")
     assert decoded_type == expected_output
 
 

multiversx_sdk/abi/enum_value.py

@@ -144,6 +144,11 @@ def get_payload(self) -> Any:
 
         setattr(obj, ENUM_DISCRIMINANT_FIELD_NAME, self.discriminant)
 
+        if self.names_to_discriminants is not None:
+            for name, discriminant in self.names_to_discriminants.items():
+                if discriminant == self.discriminant:
+                    setattr(obj, ENUM_NAME_FIELD_NAME, name)
+
         return obj
 
     def __eq__(self, other: Any) -> bool:

multiversx_sdk/abi/enum_value_test.py

@@ -97,7 +97,7 @@ def test_set_payload_and_get_payload_using_names():
     value = EnumValue(fields_provider=lambda discriminant: [], names_to_discriminants={"TypeB": 42})
     value.set_payload("TypeB")
     assert value.discriminant == 42
-    assert value.get_payload() == SimpleNamespace(__discriminant__=42)
+    assert value.get_payload() == SimpleNamespace(__discriminant__=42, __name__="TypeB")
 
     # With fields (from SimpleNamespace, object, dictionary or list)
     def provide_fields(discriminant: int) -> list[Field]:
@@ -124,7 +124,7 @@ def provide_fields(discriminant: int) -> list[Field]:
     value.set_payload(SimpleNamespace(__name__="TypeA", a=1, b=2))
     assert value.discriminant == 41
     assert value.fields == [Field("a", U32Value(1)), Field("b", BigUIntValue(2))]
-    assert value.get_payload() == SimpleNamespace(__discriminant__=41, a=1, b=2)
+    assert value.get_payload() == SimpleNamespace(__discriminant__=41, __name__="TypeA", a=1, b=2)
     assert int(value.get_payload()) == 41
 
     class Payload:
@@ -137,19 +137,19 @@ def __init__(self, c: int, d: int):
     value.set_payload(Payload(3, 4))
     assert value.discriminant == 42
     assert value.fields == [Field("c", U32Value(3)), Field("d", BigUIntValue(4))]
-    assert value.get_payload() == SimpleNamespace(__discriminant__=42, c=3, d=4)
+    assert value.get_payload() == SimpleNamespace(__discriminant__=42, __name__="TypeB", c=3, d=4)
     assert int(value.get_payload()) == 42
 
     # Then, from dictionary
     value.set_payload({"__name__": "TypeC", "e": 5, "f": 6})
     assert value.discriminant == 43
     assert value.fields == [Field("e", U32Value(5)), Field("f", BigUIntValue(6))]
-    assert value.get_payload() == SimpleNamespace(__discriminant__=43, e=5, f=6)
+    assert value.get_payload() == SimpleNamespace(__discriminant__=43, __name__="TypeC", e=5, f=6)
     assert int(value.get_payload()) == 43
 
     # Finally, from list (first element is the name)
     value.set_payload(["TypeD", 7, 8])
     assert value.discriminant == 44
     assert value.fields == [Field("g", U32Value(7)), Field("h", BigUIntValue(8))]
-    assert value.get_payload() == SimpleNamespace(__discriminant__=44, g=7, h=8)
+    assert value.get_payload() == SimpleNamespace(__discriminant__=44, __name__="TypeD", g=7, h=8)
     assert int(value.get_payload()) == 44

multiversx_sdk/core/transaction_events_parser_test.py

@@ -135,6 +135,7 @@ def test_parse_multisig_start_perform_action():
                     arguments=[bytes.fromhex("07")],
                 ),
                 "__discriminant__": 5,
+                "__name__": "SendTransferExecuteEgld",
             }
         ),
         signers=[
@@ -284,6 +285,7 @@ def test_multisig_start_perform_action():
                     }
                 ),
                 "__discriminant__": 5,
+                "__name__": "SendTransferExecuteEgld",
             },
         ),
         signers=[

multiversx_sdk/token_management/token_management_controller.py

@@ -913,6 +913,249 @@ def await_completed_burn_quantity(self, transaction_hash: Union[str, bytes]) ->
         transaction = self.network_provider.await_transaction_completed(transaction_hash)
         return self.parse_burn_quantity(transaction)
 
+    def create_transaction_for_modifying_royalties(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        token_nonce: int,
+        new_royalties: int,
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_modifying_royalties(
+            sender=sender.address,
+            token_identifier=token_identifier,
+            token_nonce=token_nonce,
+            new_royalties=new_royalties,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_setting_new_uris(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        token_nonce: int,
+        new_uris: list[str],
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_setting_new_uris(
+            sender=sender.address,
+            token_identifier=token_identifier,
+            token_nonce=token_nonce,
+            new_uris=new_uris,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_modifying_creator(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        token_nonce: int,
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_modifying_creator(
+            sender=sender.address, token_identifier=token_identifier, token_nonce=token_nonce
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_updating_metadata(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        token_nonce: int,
+        new_token_name: str,
+        new_royalties: int,
+        new_hash: str,
+        new_attributes: bytes,
+        new_uris: list[str],
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_updating_metadata(
+            sender=sender.address,
+            token_identifier=token_identifier,
+            token_nonce=token_nonce,
+            new_token_name=new_token_name,
+            new_royalties=new_royalties,
+            new_hash=new_hash,
+            new_attributes=new_attributes,
+            new_uris=new_uris,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_nft_metadata_recreate(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        token_nonce: int,
+        new_token_name: str,
+        new_royalties: int,
+        new_hash: str,
+        new_attributes: bytes,
+        new_uris: list[str],
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_nft_metadata_recreate(
+            sender=sender.address,
+            token_identifier=token_identifier,
+            token_nonce=token_nonce,
+            new_token_name=new_token_name,
+            new_royalties=new_royalties,
+            new_hash=new_hash,
+            new_attributes=new_attributes,
+            new_uris=new_uris,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_changing_token_to_dynamic(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        """The following token types cannot be changed to dynamic: FungibleESDT, NonFungibleESDT, NonFungibleESDTv2"""
+        transaction = self.factory.create_transaction_for_changing_token_to_dynamic(
+            sender=sender.address,
+            token_identifier=token_identifier,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_updating_token_id(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_identifier: str,
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_updating_token_id(
+            sender=sender.address,
+            token_identifier=token_identifier,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_registering_dynamic_token(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_name: str,
+        token_ticker: str,
+        token_type: TokenType,
+        denominator: Optional[int] = None,
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_registering_dynamic_token(
+            sender=sender.address,
+            token_name=token_name,
+            token_ticker=token_ticker,
+            token_type=token_type,
+            denominator=denominator,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
+    def create_transaction_for_registering_dynamic_and_setting_roles(
+        self,
+        sender: IAccount,
+        nonce: int,
+        token_name: str,
+        token_ticker: str,
+        token_type: TokenType,
+        denominator: Optional[int] = None,
+        guardian: Optional[Address] = None,
+        relayer: Optional[Address] = None,
+    ) -> Transaction:
+        transaction = self.factory.create_transaction_for_registering_dynamic_and_setting_roles(
+            sender=sender.address,
+            token_name=token_name,
+            token_ticker=token_ticker,
+            token_type=token_type,
+            denominator=denominator,
+        )
+
+        transaction.guardian = guardian
+        transaction.relayer = relayer
+        transaction.nonce = nonce
+
+        self._set_version_and_options_for_hash_signing(sender, transaction)
+        transaction.signature = sender.sign_transaction(transaction)
+
+        return transaction
+
     def create_transaction_for_transferring_ownership(
         self,
         sender: IAccount,