chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/cmds/wallet_funcs.py

@@ -6,10 +6,10 @@ import os
 import pathlib
 import sys
 import time
-from collections.abc import Awaitable, Sequence
+from collections.abc import Awaitable, Callable, Sequence
 from datetime import datetime, timezone
 from decimal import Decimal
-from typing import Any, Callable, Optional, Union
+from typing import Any
 
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint16, uint32, uint64
@@ -45,6 +45,7 @@ from chia.wallet.util.wallet_types import WalletType
 from chia.wallet.vc_wallet.vc_store import VCProofs
 from chia.wallet.wallet_coin_store import GetCoinRecords
 from chia.wallet.wallet_request_types import (
+    CancelOffer,
     CATAssetIDToName,
     CATAssetIDToNameResponse,
     CATGetName,
@@ -52,6 +53,10 @@ from chia.wallet.wallet_request_types import (
     CATSpend,
     CATSpendResponse,
     ClawbackPuzzleDecoratorOverride,
+    CRCATApprovePending,
+    CreateNewWallet,
+    CreateNewWalletType,
+    CreateOfferForIDs,
     DeleteNotifications,
     DeleteUnconfirmedTransactions,
     DIDFindLostDID,
@@ -60,11 +65,14 @@ from chia.wallet.wallet_request_types import (
     DIDMessageSpend,
     DIDSetWalletName,
     DIDTransferDID,
+    DIDType,
     DIDUpdateMetadata,
     ExtendDerivationIndex,
     FungibleAsset,
+    GetAllOffers,
     GetNextAddress,
     GetNotifications,
+    GetOffer,
     GetTransaction,
     GetTransactions,
     GetWalletBalance,
@@ -87,6 +95,7 @@ from chia.wallet.wallet_request_types import (
     SignMessageByID,
     SignMessageByIDResponse,
     SpendClawbackCoins,
+    TakeOffer,
     VCAddProofs,
     VCGet,
     VCGetList,
@@ -94,6 +103,7 @@ from chia.wallet.wallet_request_types import (
     VCMint,
     VCRevoke,
     VCSpend,
+    WalletCreationMode,
 )
 from chia.wallet.wallet_rpc_client import WalletRpcClient
 
@@ -122,7 +132,7 @@ def print_transaction(
     name: str,
     address_prefix: str,
     mojo_per_unit: int,
-    coin_record: Optional[dict[str, Any]] = None,
+    coin_record: dict[str, Any] | None = None,
 ) -> None:
     if verbose:
         print(tx)
@@ -197,7 +207,7 @@ async def get_unit_name_for_wallet_id(
 
 
 async def get_transaction(
-    *, root_path: pathlib.Path, wallet_rpc_port: Optional[int], fingerprint: Optional[int], tx_id: str, verbose: int
+    *, root_path: pathlib.Path, wallet_rpc_port: int | None, fingerprint: int | None, tx_id: str, verbose: int
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fingerprint) as (wallet_client, _, config):
         transaction_id = bytes32.from_hexstr(tx_id)
@@ -231,11 +241,11 @@ async def get_transaction(
 async def get_transactions(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
     verbose: int,
-    paginate: Optional[bool],
+    paginate: bool | None,
     offset: int,
     limit: int,
     sort_key: SortKey,
@@ -256,8 +266,8 @@ async def get_transactions(
             await wallet_client.get_transactions(
                 GetTransactions(
                     uint32(wallet_id),
-                    start=uint16(offset),
-                    end=uint16(offset + limit),
+                    start=uint32(offset),
+                    end=uint32(offset + limit),
                     sort_key=sort_key.name,
                     reverse=reverse,
                     type_filter=type_filter,
@@ -288,7 +298,7 @@ async def get_transactions(
             for j in range(num_per_screen):
                 if i + j + skipped >= len(txs):
                     break
-                coin_record: Optional[dict[str, Any]] = None
+                coin_record: dict[str, Any] | None = None
                 if txs[i + j + skipped].type in CLAWBACK_INCOMING_TRANSACTION_TYPES:
                     coin_records = await wallet_client.get_coin_records(
                         GetCoinRecords(coin_id_filter=HashFilter.include([txs[i + j + skipped].additions[0].name()]))
@@ -327,18 +337,18 @@ def check_unusual_transaction(amount: uint64, fee: uint64) -> bool:
 async def send(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
     amount: CliAmount,
-    memo: Optional[str],
+    memo: str | None,
     fee: uint64,
     address: CliAddress,
     override: bool,
     min_coin_amount: CliAmount,
     max_coin_amount: CliAmount,
     excluded_coin_ids: Sequence[bytes32],
-    reuse_puzhash: Optional[bool],
+    reuse_puzhash: bool | None,
     clawback_time_lock: int,
     push: bool,
     condition_valid_times: ConditionValidTimes,
@@ -373,7 +383,7 @@ async def send(
 
         if typ == WalletType.STANDARD_WALLET:
             print("Submitting transaction...")
-            res: Union[CATSpendResponse, SendTransactionResponse] = await wallet_client.send_transaction(
+            res: CATSpendResponse | SendTransactionResponse = await wallet_client.send_transaction(
                 SendTransaction(
                     wallet_id=uint32(wallet_id),
                     amount=final_amount,
@@ -441,7 +451,7 @@ async def send(
 
 
 async def get_address(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], wallet_id: int, new_address: bool
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, wallet_id: int, new_address: bool
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         res = (await wallet_client.get_next_address(GetNextAddress(uint32(wallet_id), new_address))).address
@@ -449,21 +459,21 @@ async def get_address(
 
 
 async def delete_unconfirmed_transactions(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], wallet_id: int
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, wallet_id: int
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, _):
         await wallet_client.delete_unconfirmed_transactions(DeleteUnconfirmedTransactions(uint32(wallet_id)))
         print(f"Successfully deleted all unconfirmed transactions for wallet id {wallet_id} on key {fingerprint}")
 
 
-async def get_derivation_index(root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int]) -> None:
+async def get_derivation_index(root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         res = await wallet_client.get_current_derivation_index()
         print(f"Last derivation index: {res.index}")
 
 
 async def update_derivation_index(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], index: int
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, index: int
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         print("Updating derivation index... This may take a while.")
@@ -473,14 +483,22 @@ async def update_derivation_index(
 
 
 async def add_token(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], asset_id: bytes32, token_name: str
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, asset_id: bytes32, token_name: str
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, _):
         existing_info = await wallet_client.cat_asset_id_to_name(CATAssetIDToName(asset_id))
 
         if existing_info.wallet_id is None:
-            response = await wallet_client.create_wallet_for_existing_cat(asset_id)
-            wallet_id = response["wallet_id"]
+            response = await wallet_client.create_new_wallet(
+                CreateNewWallet(
+                    wallet_type=CreateNewWalletType.CAT_WALLET,
+                    mode=WalletCreationMode.EXISTING,
+                    asset_id=asset_id,
+                    push=True,
+                ),
+                tx_config=DEFAULT_TX_CONFIG,
+            )
+            wallet_id = response.wallet_id
             await wallet_client.set_cat_name(CATSetName(wallet_id, token_name))
             print(f"Successfully added {token_name} with wallet id {wallet_id} on key {fingerprint}")
         else:
@@ -494,21 +512,21 @@ async def add_token(
 async def make_offer(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     fee: uint64,
     offers: Sequence[str],
     requests: Sequence[str],
     filepath: pathlib.Path,
-    reuse_puzhash: Optional[bool],
+    reuse_puzhash: bool | None,
     condition_valid_times: ConditionValidTimes,
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, config):
         if offers == [] or requests == []:
             print("Not creating offer: Must be offering and requesting at least one asset")
         else:
-            offer_dict: dict[Union[uint32, str], int] = {}
-            driver_dict: dict[str, Any] = {}
+            offer_dict: dict[str, str] = {}
+            driver_dict: dict[bytes32, PuzzleInfo] = {}
             printable_dict: dict[str, tuple[str, int, int]] = {}  # dict[asset_name, tuple[amount, unit, multiplier]]
             royalty_assets: list[RoyaltyAsset] = []
             fungible_assets: list[FungibleAsset] = []
@@ -516,7 +534,7 @@ async def make_offer(
                 name, amount = tuple(item.split(":")[0:2])
                 try:
                     b32_id = bytes32.from_hexstr(name)
-                    id: Union[uint32, str] = b32_id.hex()
+                    id: str = b32_id.hex()
                     result = await wallet_client.cat_asset_id_to_name(CATAssetIDToName(b32_id))
                     if result.name is not None:
                         name = result.name
@@ -535,7 +553,7 @@ async def make_offer(
                             id = info.launcher_id.hex()
                             assert isinstance(id, str)
                             if item in requests:
-                                driver_dict[id] = {
+                                puzzle_info_dict: dict[str, Any] = {
                                     "type": "singleton",
                                     "launcher_id": "0x" + id,
                                     "launcher_ph": "0x" + info.launcher_puzhash.hex(),
@@ -548,7 +566,7 @@ async def make_offer(
                                 if info.supports_did:
                                     assert info.royalty_puzzle_hash is not None
                                     assert info.royalty_percentage is not None
-                                    driver_dict[id]["also"]["also"] = {
+                                    puzzle_info_dict["also"]["also"] = {
                                         "type": "ownership",
                                         "owner": "()",
                                         "transfer_program": {
@@ -565,17 +583,18 @@ async def make_offer(
                                             info.royalty_percentage,
                                         )
                                     )
+                                driver_dict[info.launcher_id] = PuzzleInfo(puzzle_info_dict)
                         else:
                             id = decode_puzzle_hash(name).hex()
                             assert hrp is not None
                             unit = units[hrp]
                     except ValueError:
-                        id = uint32(name)
-                        if id == 1:
+                        id = str(uint32(name))
+                        if id == "1":
                             name = "XCH"
                             unit = units["chia"]
                         else:
-                            name = (await wallet_client.get_cat_name(CATGetName(id))).name
+                            name = (await wallet_client.get_cat_name(CATGetName(uint32(name)))).name
                             unit = units["cat"]
                         if item in offers:
                             fungible_assets.append(FungibleAsset(name, uint64(abs(int(Decimal(amount) * unit)))))
@@ -585,7 +604,7 @@ async def make_offer(
                     print("Not creating offer: Cannot offer and request the same asset in a trade")
                     break
                 else:
-                    offer_dict[id] = int(Decimal(amount) * unit) * multiplier
+                    offer_dict[id] = str(int(Decimal(amount) * unit) * multiplier)
             else:
                 print("Creating Offer")
                 print("--------------")
@@ -642,9 +661,11 @@ async def make_offer(
 
                 with filepath.open(mode="w") as file:
                     res = await wallet_client.create_offer_for_ids(
-                        offer_dict,
-                        driver_dict=driver_dict,
-                        fee=fee,
+                        CreateOfferForIDs(
+                            offer=offer_dict,
+                            driver_dict=driver_dict,
+                            fee=fee,
+                        ),
                         tx_config=CMDTXConfigLoader(
                             reuse_puzhash=reuse_puzhash,
                         ).to_tx_config(units["chia"], config, fingerprint),
@@ -666,7 +687,7 @@ def timestamp_to_time(timestamp: int) -> str:
 
 
 async def print_offer_summary(
-    cat_name_resolver: CATNameResolver, sum_dict: dict[str, int], has_fee: bool = False, network_xch: str = "XCH"
+    cat_name_resolver: CATNameResolver, sum_dict: dict[str, str], has_fee: bool = False, network_xch: str = "XCH"
 ) -> None:
     for asset_id, amount in sum_dict.items():
         description: str = ""
@@ -717,7 +738,7 @@ async def print_trade_record(record: TradeRecord, wallet_client: WalletRpcClient
         print("Summary:")
         offer = Offer.from_bytes(record.offer)
         offered, requested, _, _ = offer.summary()
-        outbound_balances: dict[str, int] = offer.get_pending_amounts()
+        outbound_balances: dict[str, str] = {k: str(v) for k, v in offer.get_pending_amounts().items()}
         fees: Decimal = Decimal(offer.fees())
         cat_name_resolver = wallet_client.cat_asset_id_to_name
         print("  OFFERED:")
@@ -742,10 +763,10 @@ async def print_trade_record(record: TradeRecord, wallet_client: WalletRpcClient
 async def get_offers(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
-    offer_id: Optional[bytes32],
-    filepath: Optional[str],
+    wallet_rpc_port: int | None,
+    fp: int | None,
+    offer_id: bytes32 | None,
+    filepath: str | None,
     exclude_my_offers: bool = False,
     exclude_taken_offers: bool = False,
     include_completed: bool = False,
@@ -763,16 +784,20 @@ async def get_offers(
 
             # Traverse offers page by page
             while True:
-                new_records: list[TradeRecord] = await wallet_client.get_all_offers(
-                    start,
-                    end,
-                    sort_key="RELEVANCE" if sort_by_relevance else "CONFIRMED_AT_HEIGHT",
-                    reverse=reverse,
-                    file_contents=file_contents,
-                    exclude_my_offers=exclude_my_offers,
-                    exclude_taken_offers=exclude_taken_offers,
-                    include_completed=include_completed,
-                )
+                new_records: list[TradeRecord] = (
+                    await wallet_client.get_all_offers(
+                        GetAllOffers(
+                            start=uint16(start),
+                            end=uint16(end),
+                            sort_key="RELEVANCE" if sort_by_relevance else "CONFIRMED_AT_HEIGHT",
+                            reverse=reverse,
+                            file_contents=file_contents,
+                            exclude_my_offers=exclude_my_offers,
+                            exclude_taken_offers=exclude_taken_offers,
+                            include_completed=include_completed,
+                        )
+                    )
+                ).trade_records
                 records.extend(new_records)
 
                 # If fewer records were returned than requested, we're done
@@ -782,7 +807,7 @@ async def get_offers(
                 start = end
                 end += batch_size
         else:
-            records = [await wallet_client.get_offer(offer_id, file_contents)]
+            records = [(await wallet_client.get_offer(GetOffer(offer_id, file_contents))).trade_record]
             if filepath is not None:
                 with open(pathlib.Path(filepath), "w") as file:
                     file.write(Offer.from_bytes(records[0].offer).to_bech32())
@@ -794,8 +819,8 @@ async def get_offers(
 
 async def take_offer(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     fee: uint64,
     file: str,
     examine_only: bool,
@@ -888,11 +913,9 @@ async def take_offer(
             print()
             cli_confirm("Would you like to take this offer? (y/n): ")
             res = await wallet_client.take_offer(
-                offer,
-                fee=fee,
-                tx_config=CMDTXConfigLoader().to_tx_config(units["chia"], config, fingerprint),
-                push=push,
+                TakeOffer(offer=offer.to_bech32(), fee=fee, push=push),
                 timelock_info=condition_valid_times,
+                tx_config=CMDTXConfigLoader().to_tx_config(units["chia"], config, fingerprint),
             )
             if push:
                 print(f"Accepted offer with ID {res.trade_record.trade_id}")
@@ -907,8 +930,8 @@ async def take_offer(
 
 async def cancel_offer(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     fee: uint64,
     offer_id: bytes32,
     secure: bool,
@@ -916,16 +939,13 @@ async def cancel_offer(
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, config):
-        trade_record = await wallet_client.get_offer(offer_id, file_contents=True)
+        trade_record = (await wallet_client.get_offer(GetOffer(offer_id, file_contents=True))).trade_record
         await print_trade_record(trade_record, wallet_client, summaries=True)
 
         cli_confirm(f"Are you sure you wish to cancel offer with ID: {trade_record.trade_id}? (y/n): ")
         res = await wallet_client.cancel_offer(
-            offer_id,
-            CMDTXConfigLoader().to_tx_config(units["chia"], config, fingerprint),
-            secure=secure,
-            fee=fee,
-            push=push,
+            CancelOffer(trade_id=offer_id, secure=secure, fee=fee, push=push),
+            tx_config=CMDTXConfigLoader().to_tx_config(units["chia"], config, fingerprint),
             timelock_info=condition_valid_times,
         )
         if push or not secure:
@@ -956,7 +976,7 @@ def print_balance(amount: int, scale: int, address_prefix: str, *, decimal_only:
 
 
 async def print_balances(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], wallet_type: Optional[WalletType] = None
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, wallet_type: WalletType | None = None
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, config):
         summaries_response = await wallet_client.get_wallets(GetWallets(uint16.construct_optional(wallet_type)))
@@ -992,7 +1012,7 @@ async def print_balances(
                     balances.unconfirmed_wallet_balance, scale, address_prefix
                 )
                 spendable_balance: str = print_balance(balances.spendable_balance, scale, address_prefix)
-                my_did: Optional[str] = None
+                my_did: str | None = None
                 ljust = 23
                 if typ == WalletType.CRCAT:
                     ljust = 36
@@ -1028,26 +1048,30 @@ async def print_balances(
 
 async def create_did_wallet(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     fee: uint64,
-    name: Optional[str],
+    name: str | None,
     amount: int,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, config):
         try:
-            response = await wallet_client.create_new_did_wallet(
-                amount,
-                CMDTXConfigLoader().to_tx_config(units["chia"], config, fingerprint),
-                fee,
-                name,
-                push=push,
+            response = await wallet_client.create_new_wallet(
+                CreateNewWallet(
+                    wallet_type=CreateNewWalletType.DID_WALLET,
+                    did_type=DIDType.NEW,
+                    amount=uint64(amount),
+                    fee=fee,
+                    wallet_name=name,
+                    push=push,
+                ),
+                tx_config=CMDTXConfigLoader().to_tx_config(units["chia"], config, fingerprint),
                 timelock_info=condition_valid_times,
             )
-            wallet_id = response["wallet_id"]
-            my_did = response["my_did"]
+            wallet_id = response.wallet_id
+            my_did = response.my_did
             print(f"Successfully created a DID wallet with name {name} and id {wallet_id} on key {fingerprint}")
             print(f"Successfully created a DID {my_did} in the newly created DID wallet")
             return []  # TODO: fix this endpoint to return transactions
@@ -1057,7 +1081,7 @@ async def create_did_wallet(
 
 
 async def did_set_wallet_name(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], wallet_id: int, name: str
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, wallet_id: int, name: str
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         try:
@@ -1067,9 +1091,7 @@ async def did_set_wallet_name(
             print(f"Failed to set DID wallet name: {e}")
 
 
-async def get_did(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], did_wallet_id: int
-) -> None:
+async def get_did(root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, did_wallet_id: int) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         try:
             response = await wallet_client.get_did_id(DIDGetDID(uint32(did_wallet_id)))
@@ -1080,7 +1102,7 @@ async def get_did(
 
 
 async def get_did_info(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], coin_id: str, latest: bool
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, coin_id: str, latest: bool
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         did_padding_length = 23
@@ -1107,8 +1129,8 @@ async def get_did_info(
 
 async def update_did_metadata(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     did_wallet_id: int,
     metadata: str,
     reuse_puzhash: bool,
@@ -1141,8 +1163,8 @@ async def update_did_metadata(
 
 async def did_message_spend(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     did_wallet_id: int,
     puzzle_announcements: list[str],
     coin_announcements: list[str],
@@ -1169,13 +1191,13 @@ async def did_message_spend(
 
 async def transfer_did(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     did_wallet_id: int,
     fee: uint64,
     target_cli_address: CliAddress,
     with_recovery: bool,
-    reuse_puzhash: Optional[bool],
+    reuse_puzhash: bool | None,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
@@ -1208,12 +1230,12 @@ async def transfer_did(
 async def find_lost_did(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     coin_id: str,
-    metadata: Optional[str],
-    recovery_list_hash: Optional[str],
-    num_verification: Optional[int],
+    metadata: str | None,
+    recovery_list_hash: str | None,
+    num_verification: int | None,
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         try:
@@ -1232,16 +1254,23 @@ async def find_lost_did(
 
 async def create_nft_wallet(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
-    did_id: Optional[CliAddress] = None,
-    name: Optional[str] = None,
+    wallet_rpc_port: int | None,
+    fp: int | None,
+    did_id: CliAddress | None = None,
+    name: str | None = None,
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, fingerprint, _):
         try:
-            response = await wallet_client.create_new_nft_wallet(did_id.original_address if did_id else None, name)
-            wallet_id = response["wallet_id"]
-            print(f"Successfully created an NFT wallet with id {wallet_id} on key {fingerprint}")
+            response = await wallet_client.create_new_wallet(
+                CreateNewWallet(
+                    wallet_type=CreateNewWalletType.NFT_WALLET,
+                    did_id=(did_id.original_address if did_id else None),
+                    name=name,
+                    push=True,
+                ),
+                DEFAULT_TX_CONFIG,
+            )
+            print(f"Successfully created an NFT wallet with id {response.wallet_id} on key {fingerprint}")
         except Exception as e:
             print(f"Failed to create NFT wallet: {e}")
 
@@ -1249,23 +1278,23 @@ async def create_nft_wallet(
 async def mint_nft(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
-    royalty_cli_address: Optional[CliAddress],
-    target_cli_address: Optional[CliAddress],
+    royalty_cli_address: CliAddress | None,
+    target_cli_address: CliAddress | None,
     no_did_ownership: bool,
     hash: str,
     uris: list[str],
-    metadata_hash: Optional[str],
+    metadata_hash: str | None,
     metadata_uris: list[str],
-    license_hash: Optional[str],
+    license_hash: str | None,
     license_uris: list[str],
-    edition_total: Optional[int],
-    edition_number: Optional[int],
+    edition_total: int | None,
+    edition_number: int | None,
     fee: uint64,
     royalty_percentage: int,
-    reuse_puzhash: Optional[bool],
+    reuse_puzhash: bool | None,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
@@ -1276,7 +1305,7 @@ async def mint_nft(
             response = await wallet_client.get_nft_wallet_did(NFTGetWalletDID(uint32(wallet_id)))
             wallet_did = response.did_id
             wallet_has_did = wallet_did is not None
-            did_id: Optional[str] = wallet_did
+            did_id: str | None = wallet_did
             # Handle the case when the user wants to disable DID ownership
             if no_did_ownership:
                 if wallet_has_did:
@@ -1321,15 +1350,15 @@ async def mint_nft(
 async def add_uri_to_nft(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
     fee: uint64,
     nft_coin_id: str,
-    uri: Optional[str],
-    metadata_uri: Optional[str],
-    license_uri: Optional[str],
-    reuse_puzhash: Optional[bool],
+    uri: str | None,
+    metadata_uri: str | None,
+    license_uri: str | None,
+    reuse_puzhash: bool | None,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
@@ -1374,13 +1403,13 @@ async def add_uri_to_nft(
 async def transfer_nft(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
     fee: uint64,
     nft_coin_id: str,
     target_cli_address: CliAddress,
-    reuse_puzhash: Optional[bool],
+    reuse_puzhash: bool | None,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
@@ -1449,8 +1478,8 @@ def print_nft_info(nft: NFTInfo, *, config: dict[str, Any]) -> None:
 
 async def list_nfts(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
     num: int,
     start_index: int,
@@ -1471,13 +1500,13 @@ async def list_nfts(
 async def set_nft_did(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     wallet_id: int,
     fee: uint64,
     nft_coin_id: str,
     did_id: str,
-    reuse_puzhash: Optional[bool],
+    reuse_puzhash: bool | None,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
@@ -1504,9 +1533,7 @@ async def set_nft_did(
             return []
 
 
-async def get_nft_info(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], nft_coin_id: str
-) -> None:
+async def get_nft_info(root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, nft_coin_id: str) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, config):
         try:
             response = await wallet_client.get_nft_info(NFTGetInfo(nft_coin_id))
@@ -1562,7 +1589,7 @@ def nft_coin_ids_supporting_royalties_from_offer(offer: Offer) -> list[bytes32]:
     ]
 
 
-def fungible_assets_from_offer(offer: Offer) -> list[Optional[bytes32]]:
+def fungible_assets_from_offer(offer: Offer) -> list[bytes32 | None]:
     return [
         asset for asset in offer.arbitrage() if asset is None or driver_dict_asset_is_fungible(offer.driver_dict, asset)
     ]
@@ -1570,8 +1597,8 @@ def fungible_assets_from_offer(offer: Offer) -> list[Optional[bytes32]]:
 
 async def send_notification(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     fee: uint64,
     address: CliAddress,
     message: bytes,
@@ -1605,11 +1632,11 @@ async def send_notification(
 
 async def get_notifications(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
-    ids: Optional[Sequence[bytes32]],
-    start: Optional[int],
-    end: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
+    ids: Sequence[bytes32] | None,
+    start: int | None,
+    end: int | None,
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         if ids is not None:
@@ -1625,7 +1652,7 @@ async def get_notifications(
 
 
 async def delete_notifications(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], ids: Sequence[bytes32], delete_all: bool
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, ids: Sequence[bytes32], delete_all: bool
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         if delete_all:
@@ -1639,16 +1666,16 @@ async def delete_notifications(
 async def sign_message(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     addr_type: AddressType,
     message: str,
-    address: Optional[CliAddress] = None,
-    did_id: Optional[CliAddress] = None,
-    nft_id: Optional[CliAddress] = None,
+    address: CliAddress | None = None,
+    did_id: CliAddress | None = None,
+    nft_id: CliAddress | None = None,
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
-        response: Union[SignMessageByAddressResponse, SignMessageByIDResponse]
+        response: SignMessageByAddressResponse | SignMessageByIDResponse
         if addr_type == AddressType.XCH:
             if address is None:
                 print("Address is required for XCH address type.")
@@ -1679,8 +1706,8 @@ async def sign_message(
 async def spend_clawback(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     fee: uint64,
     tx_ids_str: str,
     force: bool = False,
@@ -1708,11 +1735,11 @@ async def spend_clawback(
 
 async def mint_vc(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     did: CliAddress,
     fee: uint64,
-    target_address: Optional[CliAddress],
+    target_address: CliAddress | None,
     push: bool,
     condition_valid_times: ConditionValidTimes,
 ) -> list[TransactionRecord]:
@@ -1743,9 +1770,7 @@ async def mint_vc(
         return res.transactions
 
 
-async def get_vcs(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], start: int, count: int
-) -> None:
+async def get_vcs(root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, start: int, count: int) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, config):
         get_list_response = await wallet_client.vc_get_list(VCGetList(uint32(start), uint32(count)))
         print("Proofs:")
@@ -1771,11 +1796,11 @@ async def get_vcs(
 async def spend_vc(
     *,
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
+    wallet_rpc_port: int | None,
+    fp: int | None,
     vc_id: bytes32,
     fee: uint64,
-    new_puzhash: Optional[bytes32],
+    new_puzhash: bytes32 | None,
     new_proof_hash: str,
     reuse_puzhash: bool,
     push: bool,
@@ -1814,7 +1839,7 @@ async def spend_vc(
 
 
 async def add_proof_reveal(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], proofs: Sequence[str], root_only: bool
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, proofs: Sequence[str], root_only: bool
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         if len(proofs) == 0:
@@ -1832,7 +1857,7 @@ async def add_proof_reveal(
 
 
 async def get_proofs_for_root(
-    root_path: pathlib.Path, wallet_rpc_port: Optional[int], fp: Optional[int], proof_hash: str
+    root_path: pathlib.Path, wallet_rpc_port: int | None, fp: int | None, proof_hash: str
 ) -> None:
     async with get_wallet_client(root_path, wallet_rpc_port, fp) as (wallet_client, _, _):
         proof_dict: dict[str, str] = (
@@ -1847,10 +1872,10 @@ async def get_proofs_for_root(
 
 async def revoke_vc(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
-    fp: Optional[int],
-    parent_coin_id: Optional[bytes32],
-    vc_id: Optional[bytes32],
+    wallet_rpc_port: int | None,
+    fp: int | None,
+    parent_coin_id: bytes32 | None,
+    vc_id: bytes32 | None,
     fee: uint64,
     reuse_puzhash: bool,
     push: bool,
@@ -1899,7 +1924,7 @@ async def revoke_vc(
 
 async def approve_r_cats(
     root_path: pathlib.Path,
-    wallet_rpc_port: Optional[int],
+    wallet_rpc_port: int | None,
     fingerprint: int,
     wallet_id: uint32,
     min_amount_to_claim: CliAmount,
@@ -1913,18 +1938,22 @@ async def approve_r_cats(
     async with get_wallet_client(root_path, wallet_rpc_port, fingerprint) as (wallet_client, fp, config):
         if wallet_client is None:
             return
-        txs = await wallet_client.crcat_approve_pending(
-            wallet_id=wallet_id,
-            min_amount_to_claim=min_amount_to_claim.convert_amount(units["cat"]),
-            fee=fee,
-            tx_config=CMDTXConfigLoader(
-                min_coin_amount=min_coin_amount,
-                max_coin_amount=max_coin_amount,
-                reuse_puzhash=reuse,
-            ).to_tx_config(units["cat"], config, fp),
-            push=push,
-            timelock_info=condition_valid_times,
-        )
+        txs = (
+            await wallet_client.crcat_approve_pending(
+                CRCATApprovePending(
+                    wallet_id=wallet_id,
+                    min_amount_to_claim=min_amount_to_claim.convert_amount(units["cat"]),
+                    fee=fee,
+                    push=push,
+                ),
+                tx_config=CMDTXConfigLoader(
+                    min_coin_amount=min_coin_amount,
+                    max_coin_amount=max_coin_amount,
+                    reuse_puzhash=reuse,
+                ).to_tx_config(units["cat"], config, fp),
+                timelock_info=condition_valid_times,
+            )
+        ).transactions
 
         if push:
             print("VC successfully approved R-CATs!")