chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/cmds/farm_funcs.py

@@ -5,14 +5,15 @@ import traceback
 from pathlib import Path
 from typing import Any, Optional
 
+from chia_rs import BlockRecord
+
 from chia.cmds.cmds_util import format_bytes, format_minutes, get_any_service_client
 from chia.cmds.units import units
-from chia.consensus.block_record import BlockRecord
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
-from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 from chia.util.errors import CliRpcConnectionError
 from chia.util.network import is_localhost
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 SECONDS_PER_BLOCK = (24 * 3600) / 4608
 

chia/cmds/init_funcs.py

@@ -9,8 +9,15 @@ from typing import Any, Optional
 import yaml
 
 from chia.cmds.configure import configure
-from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.ssl.create_ssl import create_all_ssl
+from chia.ssl.ssl_check import (
+    DEFAULT_PERMISSIONS_CERT_FILE,
+    DEFAULT_PERMISSIONS_KEY_FILE,
+    RESTRICT_MASK_CERT_FILE,
+    RESTRICT_MASK_KEY_FILE,
+    check_and_fix_permissions_for_ssl_file,
+    fix_ssl,
+)
 from chia.util.bech32m import encode_puzzle_hash
 from chia.util.config import (
     create_default_chia_config,
@@ -23,14 +30,6 @@ from chia.util.config import (
 from chia.util.db_version import set_db_version
 from chia.util.keychain import Keychain
 from chia.util.path import path_from_root
-from chia.util.ssl_check import (
-    DEFAULT_PERMISSIONS_CERT_FILE,
-    DEFAULT_PERMISSIONS_KEY_FILE,
-    RESTRICT_MASK_CERT_FILE,
-    RESTRICT_MASK_KEY_FILE,
-    check_and_fix_permissions_for_ssl_file,
-    fix_ssl,
-)
 from chia.wallet.derive_keys import (
     _derive_path,
     _derive_path_unhardened,
@@ -38,6 +37,7 @@ from chia.wallet.derive_keys import (
     master_sk_to_wallet_sk_intermediate,
     master_sk_to_wallet_sk_unhardened_intermediate,
 )
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 
 def dict_add_new_default(updated: dict[str, Any], default: dict[str, Any], do_not_migrate_keys: dict[str, Any]) -> None:
@@ -94,11 +94,11 @@ def check_keys(new_root: Path, keychain: Optional[Keychain] = None) -> None:
 
                 all_targets.append(
                     encode_puzzle_hash(
-                        create_puzzlehash_for_pk(_derive_path_unhardened(intermediate_o, [i]).get_g1()), prefix
+                        puzzle_hash_for_pk(_derive_path_unhardened(intermediate_o, [i]).get_g1()), prefix
                     )
                 )
                 all_targets.append(
-                    encode_puzzle_hash(create_puzzlehash_for_pk(_derive_path(intermediate_n, [i]).get_g1()), prefix)
+                    encode_puzzle_hash(puzzle_hash_for_pk(_derive_path(intermediate_n, [i]).get_g1()), prefix)
                 )
                 if all_targets[-1] == config["farmer"].get("xch_target_address") or all_targets[-2] == config[
                     "farmer"

chia/cmds/keys.py

@@ -379,11 +379,11 @@ def _resolve_fingerprint_and_sk(
 
     if non_observer_derivation and resolved_sk is None:
         print("Could not resolve private key for non-observer derivation")
-        raise ResolutionError()
+        raise ResolutionError
 
     if reolved_fp is None:
         print("A fingerprint of a root key to derive from is required")
-        raise ResolutionError()
+        raise ResolutionError
 
     return reolved_fp, resolved_sk
 

chia/cmds/keys_funcs.py

@@ -10,7 +10,6 @@ from typing import Any, Optional, Union
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.coinbase import create_puzzlehash_for_pk
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import bech32_encode, convertbits, encode_puzzle_hash
 from chia.util.config import load_config
@@ -31,6 +30,7 @@ from chia.wallet.derive_keys import (
     master_sk_to_pool_sk,
     master_sk_to_wallet_sk,
 )
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 
 def unlock_keyring() -> None:
@@ -197,7 +197,7 @@ def show_keys(
             first_wallet_pk = master_pk_to_wallet_pk_unhardened(key_data.public_key, uint32(0))
 
         if first_wallet_pk is not None:
-            wallet_address: str = encode_puzzle_hash(create_puzzlehash_for_pk(first_wallet_pk), prefix)
+            wallet_address: str = encode_puzzle_hash(puzzle_hash_for_pk(first_wallet_pk), prefix)
             key["wallet_address"] = wallet_address
         else:
             key["wallet_address"] = None
@@ -423,7 +423,7 @@ def _search_derived(
             # Generate a wallet address using the standard p2_delegated_puzzle_or_hidden_puzzle puzzle
             assert child_pk is not None
             # TODO: consider generating addresses using other puzzles
-            address = encode_puzzle_hash(create_puzzlehash_for_pk(child_pk), prefix)
+            address = encode_puzzle_hash(puzzle_hash_for_pk(child_pk), prefix)
 
         for term in remaining_search_terms:
             found_item: Any = None
@@ -682,7 +682,7 @@ def derive_wallet_address(
             pubkey = master_pk_to_wallet_pk_unhardened(pk, uint32(i))
         # Generate a wallet address using the standard p2_delegated_puzzle_or_hidden_puzzle puzzle
         # TODO: consider generating addresses using other puzzles
-        address = encode_puzzle_hash(create_puzzlehash_for_pk(pubkey), prefix)
+        address = encode_puzzle_hash(puzzle_hash_for_pk(pubkey), prefix)
         if show_hd_path:
             print(
                 f"Wallet address {i} "

chia/cmds/netspace_funcs.py

@@ -6,7 +6,7 @@ from typing import Optional
 from chia_rs.sized_bytes import bytes32
 
 from chia.cmds.cmds_util import format_bytes, get_any_service_client
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 
 
 async def netstorge_async(root_path: Path, rpc_port: Optional[int], delta_block_height: str, start: str) -> None:

chia/cmds/peer_funcs.py

@@ -26,7 +26,7 @@ async def add_node_connection(rpc_client: RpcClient, add_connection: str) -> Non
 
 
 async def remove_node_connection(rpc_client: RpcClient, remove_connection: str) -> None:
-    from chia.server.outbound_message import NodeType
+    from chia.protocols.outbound_message import NodeType
 
     result_txt = ""
     if len(remove_connection) != 8:
@@ -52,7 +52,7 @@ async def remove_node_connection(rpc_client: RpcClient, remove_connection: str)
 async def print_connections(rpc_client: RpcClient, trusted_peers: dict[str, Any], trusted_cidrs: list[str]) -> None:
     import time
 
-    from chia.server.outbound_message import NodeType
+    from chia.protocols.outbound_message import NodeType
     from chia.util.network import is_trusted_peer
 
     connections = await rpc_client.get_connections()

chia/cmds/plotnft_funcs.py

@@ -11,6 +11,7 @@ from pprint import pprint
 from typing import Any, Callable, Optional
 
 import aiohttp
+import click
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
@@ -23,11 +24,15 @@ from chia.cmds.cmds_util import (
 )
 from chia.cmds.param_types import CliAddress
 from chia.cmds.wallet_funcs import print_balance, wallet_coin_unit
-from chia.pools.pool_config import PoolWalletConfig, load_pool_config, update_pool_config
+from chia.farmer.farmer_rpc_client import FarmerRpcClient
+from chia.pools.pool_config import (
+    PoolWalletConfig,
+    load_pool_config,
+    update_pool_config,
+)
 from chia.pools.pool_wallet_info import PoolSingletonState, PoolWalletInfo
 from chia.protocols.pool_protocol import POOL_PROTOCOL_VERSION
-from chia.rpc.farmer_rpc_client import FarmerRpcClient
-from chia.rpc.wallet_rpc_client import WalletRpcClient
+from chia.rpc.rpc_client import ResponseFailureError
 from chia.server.server import ssl_context_for_root
 from chia.ssl.create_ssl import get_mozilla_ca_crt
 from chia.util.bech32m import encode_puzzle_hash
@@ -35,7 +40,16 @@ from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.errors import CliRpcConnectionError
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.address_type import AddressType
+from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
 from chia.wallet.util.wallet_types import WalletType
+from chia.wallet.wallet_request_types import (
+    PWAbsorbRewards,
+    PWJoinPool,
+    PWSelfPool,
+    PWStatus,
+    TransactionEndpointResponse,
+)
+from chia.wallet.wallet_rpc_client import WalletRpcClient
 
 
 async def create_pool_args(pool_url: str) -> dict[str, Any]:
@@ -190,7 +204,7 @@ async def pprint_all_pool_wallet_state(
         pool_wallet_id = wallet_info["id"]
         typ = WalletType(int(wallet_info["type"]))
         if typ == WalletType.POOLING_WALLET:
-            pool_wallet_info, _ = await wallet_client.pw_status(pool_wallet_id)
+            pool_wallet_info = (await wallet_client.pw_status(PWStatus(uint32(pool_wallet_id)))).state
             await pprint_pool_wallet_state(
                 wallet_client,
                 pool_wallet_id,
@@ -223,7 +237,7 @@ async def show(
                 for pool_state_item in pool_state_list
             }
             if wallet_id_passed_in is not None:
-                pool_wallet_info, _ = await wallet_info.client.pw_status(wallet_id_passed_in)
+                pool_wallet_info = (await wallet_info.client.pw_status(PWStatus(uint32(wallet_id_passed_in)))).state
                 await pprint_pool_wallet_state(
                     wallet_info.client,
                     wallet_id_passed_in,
@@ -251,7 +265,7 @@ async def get_login_link(launcher_id: bytes32, root_path: Path) -> None:
 async def submit_tx_with_confirmation(
     message: str,
     prompt: bool,
-    func: Callable[[], Awaitable[dict[str, Any]]],
+    func: Callable[[], Awaitable[TransactionEndpointResponse]],
     wallet_client: WalletRpcClient,
     fingerprint: int,
     wallet_id: int,
@@ -261,15 +275,19 @@ async def submit_tx_with_confirmation(
         cli_confirm("Confirm (y/n): ", "Aborting.")
     try:
         result = await func()
-        tx_record: TransactionRecord = result["transaction"]
         start = time.time()
-        while time.time() - start < 10:
-            await asyncio.sleep(0.1)
-            tx = await wallet_client.get_transaction(tx_record.name)
-            if len(tx.sent_to) > 0:
-                print(transaction_submitted_msg(tx))
-                print(transaction_status_msg(fingerprint, tx_record.name))
-                return None
+        for tx_record in result.transactions:
+            if tx_record.spend_bundle is None:
+                continue
+            while time.time() - start < 10:
+                await asyncio.sleep(0.1)
+                tx = await wallet_client.get_transaction(tx_record.name)
+                if len(tx.sent_to) > 0:
+                    print(transaction_submitted_msg(tx))
+                    print(transaction_status_msg(fingerprint, tx_record.name))
+                    return
+    except ResponseFailureError:
+        raise
     except Exception as e:
         print(f"Error performing operation on Plot NFT -f {fingerprint} wallet id: {wallet_id}: {e}")
 
@@ -307,6 +325,17 @@ async def join_pool(
 ) -> None:
     selected_wallet_id = await wallet_id_lookup_and_check(wallet_info.client, wallet_id)
 
+    sync_status = await wallet_info.client.get_sync_status()
+    if not sync_status.synced:
+        raise click.ClickException("Wallet must be synced before joining a pool.")
+
+    pool_wallet_info = (await wallet_info.client.pw_status(PWStatus(uint32(selected_wallet_id)))).state
+    if (
+        pool_wallet_info.current.state == PoolSingletonState.FARMING_TO_POOL.value
+        and pool_wallet_info.current.pool_url == pool_url
+    ):
+        raise click.ClickException(f"Wallet id: {wallet_id} is already farming to pool {pool_url}")
+
     enforce_https = wallet_info.config["selected_network"] == "mainnet"
 
     if enforce_https and not pool_url.startswith("https://"):
@@ -333,15 +362,24 @@ async def join_pool(
     msg = f"\nWill join pool: {pool_url} with Plot NFT {wallet_info.fingerprint}."
     func = functools.partial(
         wallet_info.client.pw_join_pool,
-        selected_wallet_id,
-        bytes32.from_hexstr(json_dict["target_puzzle_hash"]),
-        pool_url,
-        json_dict["relative_lock_height"],
-        fee,
+        PWJoinPool(
+            wallet_id=uint32(selected_wallet_id),
+            target_puzzlehash=bytes32.from_hexstr(json_dict["target_puzzle_hash"]),
+            pool_url=pool_url,
+            relative_lock_height=json_dict["relative_lock_height"],
+            fee=fee,
+            push=True,
+        ),
+        DEFAULT_TX_CONFIG,
     )
 
     await submit_tx_with_confirmation(
-        msg, prompt, func, wallet_info.client, wallet_info.fingerprint, selected_wallet_id
+        msg,
+        prompt,
+        func,
+        wallet_info.client,
+        wallet_info.fingerprint,
+        selected_wallet_id,
     )
 
 
@@ -351,7 +389,11 @@ async def self_pool(*, wallet_info: WalletClientInfo, fee: uint64, wallet_id: Op
         "Will start self-farming with Plot NFT on wallet id "
         f"{selected_wallet_id} fingerprint {wallet_info.fingerprint}."
     )
-    func = functools.partial(wallet_info.client.pw_self_pool, selected_wallet_id, fee)
+    func = functools.partial(
+        wallet_info.client.pw_self_pool,
+        PWSelfPool(wallet_id=uint32(selected_wallet_id), fee=fee, push=True),
+        DEFAULT_TX_CONFIG,
+    )
     await submit_tx_with_confirmation(
         msg, prompt, func, wallet_info.client, wallet_info.fingerprint, selected_wallet_id
     )
@@ -359,13 +401,13 @@ async def self_pool(*, wallet_info: WalletClientInfo, fee: uint64, wallet_id: Op
 
 async def inspect_cmd(wallet_info: WalletClientInfo, wallet_id: Optional[int]) -> None:
     selected_wallet_id = await wallet_id_lookup_and_check(wallet_info.client, wallet_id)
-    pool_wallet_info, unconfirmed_transactions = await wallet_info.client.pw_status(selected_wallet_id)
+    res = await wallet_info.client.pw_status(PWStatus(uint32(selected_wallet_id)))
     print(
         json.dumps(
             {
-                "pool_wallet_info": pool_wallet_info.to_json_dict(),
+                "pool_wallet_info": res.state.to_json_dict(),
                 "unconfirmed_transactions": [
-                    {"sent_to": tx.sent_to, "transaction_id": tx.name.hex()} for tx in unconfirmed_transactions
+                    {"sent_to": tx.sent_to, "transaction_id": tx.name.hex()} for tx in res.unconfirmed_transactions
                 ],
             }
         )
@@ -377,8 +419,12 @@ async def claim_cmd(*, wallet_info: WalletClientInfo, fee: uint64, wallet_id: Op
     msg = f"\nWill claim rewards for wallet ID: {selected_wallet_id}."
     func = functools.partial(
         wallet_info.client.pw_absorb_rewards,
-        selected_wallet_id,
-        fee,
+        PWAbsorbRewards(
+            wallet_id=uint32(selected_wallet_id),
+            fee=fee,
+            push=True,
+        ),
+        DEFAULT_TX_CONFIG,
     )
     await submit_tx_with_confirmation(msg, False, func, wallet_info.client, wallet_info.fingerprint, selected_wallet_id)
 

chia/cmds/rpc.py

@@ -131,7 +131,7 @@ def status_cmd(ctx: click.Context, json_output: bool) -> None:
         status = "ACTIVE"
         try:
             if not get_routes(service, config, root_path=root_path, quiet=True)["success"]:
-                raise Exception()
+                raise Exception
         except Exception:
             status = "INACTIVE"
         status_data[service] = status

chia/cmds/show_funcs.py

@@ -6,16 +6,16 @@ from typing import Any, Optional, Union
 
 from chia_rs.sized_bytes import bytes32
 
-from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.full_node.full_node_rpc_client import FullNodeRpcClient
 
 
 async def print_blockchain_state(node_client: FullNodeRpcClient, config: dict[str, Any]) -> bool:
     import time
 
+    from chia_rs import BlockRecord
     from chia_rs.sized_ints import uint64
 
     from chia.cmds.cmds_util import format_bytes
-    from chia.consensus.block_record import BlockRecord
 
     blockchain_state = await node_client.get_blockchain_state()
     if blockchain_state is None:
@@ -99,10 +99,9 @@ async def print_block_from_hash(
 ) -> None:
     import time
 
+    from chia_rs import BlockRecord, FullBlock
     from chia_rs.sized_bytes import bytes32
 
-    from chia.consensus.block_record import BlockRecord
-    from chia.types.full_block import FullBlock
     from chia.util.bech32m import encode_puzzle_hash
 
     block: Optional[BlockRecord] = await node_client.get_block_record(bytes32.from_hexstr(block_by_header_hash))
@@ -153,7 +152,8 @@ async def print_block_from_hash(
             f"Total VDF Iterations   {block.total_iters}\n"
             f"Is a Transaction Block?{block.is_transaction_block}\n"
             f"Deficit                {block.deficit}\n"
-            f"PoSpace 'k' Size       {full_block.reward_chain_block.proof_of_space.size}\n"
+            f"PoSpace 'k' Size (v1)  {full_block.reward_chain_block.proof_of_space.size().size_v1}\n"
+            f"PoSpace 'k' Size (v2)  {full_block.reward_chain_block.proof_of_space.size().size_v2}\n"
             f"Plot Public Key        0x{full_block.reward_chain_block.proof_of_space.plot_public_key}\n"
             f"Pool Public Key        {pool_pk}\n"
             f"Tx Filter Hash         {tx_filter_hash}\n"

chia/cmds/signer.py

@@ -17,23 +17,24 @@ from segno import QRCode, make_qr
 from chia.cmds.cmd_classes import chia_command, command_helper, option
 from chia.cmds.cmd_helpers import NeedsWalletRPC, TransactionsIn, TransactionsOut
 from chia.rpc.util import ALL_TRANSLATION_LAYERS
-from chia.rpc.wallet_request_types import (
-    ApplySignatures,
-    ExecuteSigningInstructions,
-    GatherSigningInfo,
-    PushTransactions,
-)
 from chia.util.streamable import Streamable
 from chia.wallet.signer_protocol import SignedTransaction, SigningInstructions, SigningResponse, Spend
 from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.clvm_streamable import byte_deserialize_clvm_streamable, byte_serialize_clvm_streamable
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
+from chia.wallet.wallet_request_types import (
+    ApplySignatures,
+    ExecuteSigningInstructions,
+    GatherSigningInfo,
+    PushTransactions,
+)
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
 def _clear_screen() -> None:
     # Cross-platform screen clear
-    os.system("cls" if os.name == "nt" else "clear")
+    # TODO: consider if not-nt anyways could avoid os.system()
+    os.system("cls" if os.name == "nt" else "clear")  # noqa: S605
 
 
 @click.group("signer", help="Get information for an external signer")

chia/cmds/sim_funcs.py

@@ -14,12 +14,12 @@ from chia_rs.sized_ints import uint32
 
 from chia.cmds.cmds_util import get_any_service_client
 from chia.cmds.start_funcs import async_start
-from chia.consensus.coinbase import create_puzzlehash_for_pk
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
+from chia.server.resolve_peer_info import set_peer_info
 from chia.simulator.simulator_full_node_rpc_client import SimulatorFullNodeRpcClient
 from chia.types.coin_record import CoinRecord
 from chia.util.bech32m import decode_puzzle_hash, encode_puzzle_hash
-from chia.util.config import load_config, save_config, set_peer_info
+from chia.util.config import load_config, save_config
 from chia.util.errors import KeychainFingerprintExists
 from chia.util.keychain import Keychain, bytes_to_mnemonic
 from chia.wallet.derive_keys import (
@@ -28,6 +28,7 @@ from chia.wallet.derive_keys import (
     master_sk_to_wallet_sk,
     master_sk_to_wallet_sk_unhardened,
 )
+from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 
 
 def get_ph_from_fingerprint(fingerprint: int, key_id: int = 1) -> bytes32:
@@ -36,7 +37,7 @@ def get_ph_from_fingerprint(fingerprint: int, key_id: int = 1) -> bytes32:
         raise Exception("Fingerprint not found")
     private_key = priv_key_and_entropy[0]
     sk_for_wallet_id: PrivateKey = master_sk_to_wallet_sk(private_key, uint32(key_id))
-    puzzle_hash: bytes32 = create_puzzlehash_for_pk(sk_for_wallet_id.get_g1())
+    puzzle_hash: bytes32 = puzzle_hash_for_pk(sk_for_wallet_id.get_g1())
     return puzzle_hash
 
 
@@ -76,6 +77,7 @@ def create_chia_directory(
         config["network_overrides"]["config"]["simulator0"] = config["network_overrides"]["config"]["testnet0"].copy()
         sim_genesis = "eb8c4d20b322be8d9fddbf9412016bdffe9a2901d7edb0e364e94266d0e095f7"
         config["network_overrides"]["constants"]["simulator0"]["GENESIS_CHALLENGE"] = sim_genesis
+        config["network_overrides"]["constants"]["simulator0"]["AGG_SIG_ME_ADDITIONAL_DATA"] = sim_genesis
         # tell services to use simulator0
         config["selected_network"] = "simulator0"
         config["wallet"]["selected_network"] = "simulator0"
@@ -130,10 +132,7 @@ def create_chia_directory(
     # get fork heights then write back to config
     if "HARD_FORK_HEIGHT" not in sim_config:  # this meh code is done so that we also write to the config file.
         sim_config["HARD_FORK_HEIGHT"] = 0
-    if "SOFT_FORK6_HEIGHT" not in sim_config:
-        sim_config["SOFT_FORK6_HEIGHT"] = 0
     simulator_consts["HARD_FORK_HEIGHT"] = sim_config["HARD_FORK_HEIGHT"]
-    simulator_consts["SOFT_FORK6_HEIGHT"] = sim_config["SOFT_FORK6_HEIGHT"]
 
     # save config and return the config
     save_config(chia_root, "config.yaml", config)
@@ -155,7 +154,7 @@ def display_key_info(fingerprint: int, prefix: str) -> None:
     print("Farmer public key (m/12381/8444/0/0):", master_sk_to_farmer_sk(sk).get_g1())
     print("Pool public key (m/12381/8444/1/0):", master_sk_to_pool_sk(sk).get_g1())
     first_wallet_sk: PrivateKey = master_sk_to_wallet_sk_unhardened(sk, uint32(0))
-    wallet_address: str = encode_puzzle_hash(create_puzzlehash_for_pk(first_wallet_sk.get_g1()), prefix)
+    wallet_address: str = encode_puzzle_hash(puzzle_hash_for_pk(first_wallet_sk.get_g1()), prefix)
     print(f"First wallet address: {wallet_address}")
     assert seed is not None
     print("Master private key (m):", bytes(sk).hex())
@@ -364,7 +363,7 @@ async def print_coin_records(
         num_per_screen = 5 if paginate else len(coin_records)
         # ripped from cmds/wallet_funcs.
         for i in range(0, len(coin_records), num_per_screen):
-            for j in range(0, num_per_screen):
+            for j in range(num_per_screen):
                 if i + j >= len(coin_records):
                     break
                 print_coin_record(

chia/cmds/wallet.py

@@ -1171,9 +1171,9 @@ def nft_sign_message(
 @click.option("--no-did-ownership", help="Disable DID ownership support", is_flag=True, default=False)
 @click.option("-nh", "--hash", help="NFT content hash", type=str, required=True)
 @click.option("-u", "--uris", help="Comma separated list of URIs", type=str, required=True)
-@click.option("-mh", "--metadata-hash", help="NFT metadata hash", type=str, default="")
+@click.option("-mh", "--metadata-hash", help="NFT metadata hash", type=str, default=None)
 @click.option("-mu", "--metadata-uris", help="Comma separated list of metadata URIs", type=str)
-@click.option("-lh", "--license-hash", help="NFT license hash", type=str, default="")
+@click.option("-lh", "--license-hash", help="NFT license hash", type=str, default=None)
 @click.option("-lu", "--license-uris", help="Comma separated list of license URIs", type=str)
 @click.option("-et", "--edition-total", help="NFT edition total", type=int, show_default=True, default=1)
 @click.option("-en", "--edition-number", help="NFT edition number", show_default=True, default=1, type=int)