chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/wallet/test_new_wallet_protocol.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from asyncio import Queue
+from collections import OrderedDict
+from collections.abc import AsyncGenerator
 from dataclasses import dataclass
 from random import Random
-from typing import TYPE_CHECKING, AsyncGenerator, Dict, List, Optional, OrderedDict, Set, Tuple
+from typing import Optional
 
 import pytest
 from chia_rs import AugSchemeMPL, Coin, CoinSpend, CoinState, Program
@@ -32,19 +34,15 @@ from chia.util.ints import uint8, uint16, uint32, uint64
 IDENTITY_PUZZLE = Program.to(1)
 IDENTITY_PUZZLE_HASH = IDENTITY_PUZZLE.get_tree_hash()
 
-OneNode = Tuple[List[SimulatorFullNodeService], List[WalletService], BlockTools]
-# python 3.8 workaround follows - can be removed when 3.8 support is removed
-if TYPE_CHECKING:
-    Mpu = Tuple[FullNodeSimulator, Queue[Message], WSChiaConnection]
-else:
-    Mpu = Tuple[FullNodeSimulator, Queue, WSChiaConnection]
+OneNode = tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools]
+Mpu = tuple[FullNodeSimulator, Queue[Message], WSChiaConnection]
 
 ALL_FILTER = wallet_protocol.CoinStateFilters(True, True, True, uint64(0))
 
 
 async def connect_to_simulator(
     one_node: OneNode, self_hostname: str, mempool_updates: bool = True
-) -> Tuple[FullNodeSimulator, Queue[Message], WSChiaConnection]:
+) -> tuple[FullNodeSimulator, Queue[Message], WSChiaConnection]:
     [full_node_service], _, _ = one_node
 
     full_node_api = full_node_service._api
@@ -265,7 +263,7 @@ async def test_request_coin_state(one_node: OneNode, self_hostname: str) -> None
     # Add coin records
     coin_records = [
         CoinRecord(
-            coin=Coin(bytes32(b"\0" * 32), bytes32(b"\0" * 32), uint64(i)),
+            coin=Coin(bytes32.zeros, bytes32.zeros, uint64(i)),
             confirmed_block_index=uint32(1),
             spent_block_index=uint32(1 if i % 2 == 0 else 0),
             coinbase=False,
@@ -280,7 +278,7 @@ async def test_request_coin_state(one_node: OneNode, self_hostname: str) -> None
         coinbase=False,
         timestamp=uint64(1),
     )
-    await simulator.full_node.coin_store._add_coin_records(coin_records + [ignored_coin])
+    await simulator.full_node.coin_store._add_coin_records([*coin_records, ignored_coin])
 
     # Request no coin states
     resp = await simulator.request_coin_state(wallet_protocol.RequestCoinState([], None, genesis, False), peer)
@@ -342,7 +340,7 @@ async def test_request_coin_state_reorg(one_node: OneNode, self_hostname: str) -
 
     # Reorg
     await simulator.reorg_from_index_to_new_index(
-        simulator_protocol.ReorgProtocol(uint32(3), uint32(10), bytes32(b"\1" * 32), bytes32(b"\0" * 32))
+        simulator_protocol.ReorgProtocol(uint32(3), uint32(10), bytes32(b"\1" * 32), bytes32.zeros)
     )
 
     # Request coin state, should reject due to reorg
@@ -406,7 +404,7 @@ async def test_request_puzzle_state(one_node: OneNode, self_hostname: str) -> No
     simulator, _, peer = await connect_to_simulator(one_node, self_hostname)
 
     # Farm block to a puzzle hash we aren't looking at
-    await simulator.farm_blocks_to_puzzlehash(3, farm_to=bytes32(b"\x0A" * 32))
+    await simulator.farm_blocks_to_puzzlehash(3, farm_to=bytes32(b"\x0a" * 32))
 
     genesis = simulator.full_node.blockchain.constants.GENESIS_CHALLENGE
 
@@ -417,8 +415,8 @@ async def test_request_puzzle_state(one_node: OneNode, self_hostname: str) -> No
     assert peak_header_hash is not None
 
     # Add coin records
-    coin_records: List[CoinRecord] = []
-    puzzle_hashes: List[bytes32] = []
+    coin_records: list[CoinRecord] = []
+    puzzle_hashes: list[bytes32] = []
 
     for ph_i in range(10):
         puzzle_hash = bytes32(ph_i.to_bytes(1, "big") * 32)
@@ -427,7 +425,7 @@ async def test_request_puzzle_state(one_node: OneNode, self_hostname: str) -> No
         for i in range(5):
             coin_records.append(
                 CoinRecord(
-                    coin=Coin(bytes32(b"\0" * 32), puzzle_hash, uint64(i)),
+                    coin=Coin(bytes32.zeros, puzzle_hash, uint64(i)),
                     confirmed_block_index=uint32(1),
                     spent_block_index=uint32(1 if i % 2 == 0 else 0),
                     coinbase=False,
@@ -443,7 +441,7 @@ async def test_request_puzzle_state(one_node: OneNode, self_hostname: str) -> No
         timestamp=uint64(1),
     )
 
-    await simulator.full_node.coin_store._add_coin_records(coin_records + [ignored_coin])
+    await simulator.full_node.coin_store._add_coin_records([*coin_records, ignored_coin])
 
     # We already test permutations of CoinStateFilters in the CoinStore tests
     # So it's redundant to do so here
@@ -527,7 +525,7 @@ async def test_request_puzzle_state_reorg(one_node: OneNode, self_hostname: str)
 
     # Reorg
     await simulator.reorg_from_index_to_new_index(
-        simulator_protocol.ReorgProtocol(uint32(3), uint32(10), bytes32(b"\1" * 32), bytes32(b"\0" * 32))
+        simulator_protocol.ReorgProtocol(uint32(3), uint32(10), bytes32(b"\1" * 32), bytes32.zeros)
     )
 
     # Request coin state, should reject due to reorg
@@ -621,14 +619,14 @@ async def test_request_puzzle_state_limit(one_node: OneNode, self_hostname: str)
 
 @dataclass(frozen=True)
 class PuzzleStateData:
-    coin_states: List[CoinState]
+    coin_states: list[CoinState]
     end_of_batch: bool
     previous_height: Optional[uint32]
     header_hash: bytes32
 
 
 async def sync_puzzle_hashes(
-    puzzle_hashes: List[bytes32],
+    puzzle_hashes: list[bytes32],
     *,
     initial_previous_height: Optional[uint32],
     initial_header_hash: bytes32,
@@ -693,9 +691,9 @@ async def test_sync_puzzle_state(
     simulator.full_node.config["max_subscribe_response_items"] = 7400
 
     # Generate coin records
-    puzzle_hashes: List[bytes32] = []
-    hints: List[Tuple[bytes32, bytes]] = []
-    coin_records: Dict[bytes32, CoinRecord] = dict()
+    puzzle_hashes: list[bytes32] = []
+    hints: list[tuple[bytes32, bytes]] = []
+    coin_records: dict[bytes32, CoinRecord] = dict()
 
     rng = Random(0)
 
@@ -713,7 +711,7 @@ async def test_sync_puzzle_state(
             if rng.choice([True, False, False, False, False]):
                 coin_ph = std_hash(coin_ph)
 
-            coin = Coin(bytes32(b"\0" * 32), coin_ph, uint64(base_amount + added_amount))
+            coin = Coin(bytes32.zeros, coin_ph, uint64(base_amount + added_amount))
 
             coin_records[coin.name()] = CoinRecord(
                 coin=coin,
@@ -736,7 +734,7 @@ async def test_sync_puzzle_state(
 
     async def run_test(include_spent: bool, include_unspent: bool, include_hinted: bool, min_amount: uint64) -> None:
         # Calculate expected coin records based on filters
-        expected_coin_records: Dict[bytes32, CoinRecord] = dict()
+        expected_coin_records: dict[bytes32, CoinRecord] = dict()
 
         for coin_id, coin_record in coin_records.items():
             if not include_spent and coin_record.spent_block_index > 0:
@@ -751,7 +749,7 @@ async def test_sync_puzzle_state(
             expected_coin_records[coin_id] = coin_record
 
         # Sync all coin states
-        coin_ids: Set[bytes32] = set()
+        coin_ids: set[bytes32] = set()
         last_height = -1
 
         async for batch in sync_puzzle_hashes(
@@ -784,7 +782,7 @@ async def test_sync_puzzle_state(
                     await run_test(include_spent, include_unspent, include_hinted, uint64(min_amount))
 
 
-async def assert_mempool_added(queue: Queue[Message], transaction_ids: Set[bytes32]) -> None:
+async def assert_mempool_added(queue: Queue[Message], transaction_ids: set[bytes32]) -> None:
     message = await queue.get()
     assert message.type == ProtocolMessageTypes.mempool_items_added.value
 
@@ -794,7 +792,7 @@ async def assert_mempool_added(queue: Queue[Message], transaction_ids: Set[bytes
 
 async def assert_mempool_removed(
     queue: Queue[Message],
-    removed_items: Set[wallet_protocol.RemovedMempoolItem],
+    removed_items: set[wallet_protocol.RemovedMempoolItem],
 ) -> None:
     message = await queue.get()
     assert message.type == ProtocolMessageTypes.mempool_items_removed.value
@@ -818,7 +816,7 @@ async def raw_mpu_setup(one_node: OneNode, self_hostname: str, no_capability: bo
     await simulator.farm_blocks_to_puzzlehash(1)
     await queue.get()
 
-    new_coins: List[Tuple[Coin, bytes32]] = []
+    new_coins: list[tuple[Coin, bytes32]] = []
 
     for i in range(10):
         puzzle = Program.to(2)
@@ -847,10 +845,10 @@ async def raw_mpu_setup(one_node: OneNode, self_hostname: str, no_capability: bo
     return simulator, queue, peer
 
 
-async def make_coin(full_node: FullNode) -> Tuple[Coin, bytes32]:
+async def make_coin(full_node: FullNode) -> tuple[Coin, bytes32]:
     ph = IDENTITY_PUZZLE_HASH
-    coin = Coin(bytes32(b"\0" * 32), ph, uint64(1000))
-    hint = bytes32(b"\0" * 32)
+    coin = Coin(bytes32.zeros, ph, uint64(1000))
+    hint = bytes32.zeros
 
     height = full_node.blockchain.get_peak_height()
     assert height is not None

chia/_tests/wallet/test_nft_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field
-from typing import Dict, List
 
 import pytest
 
@@ -29,7 +28,7 @@ def get_dummy_nft(random_: random.Random) -> NFTCoinInfo:
 @dataclass
 class DummyNFTs:
     seeded_random: random.Random
-    nfts_per_wallet: Dict[uint32, List[NFTCoinInfo]] = field(default_factory=dict)
+    nfts_per_wallet: dict[uint32, list[NFTCoinInfo]] = field(default_factory=dict)
 
     def generate(self, wallet_id: int, count: int) -> None:
         nfts = self.nfts_per_wallet.setdefault(uint32(wallet_id), [])

chia/_tests/wallet/test_notifications.py

@@ -36,7 +36,7 @@ async def test_notification_store_backwards_compat() -> None:
                 cursor = await conn.execute(
                     "INSERT OR REPLACE INTO notifications (coin_id, msg, amount) VALUES(?, ?, ?)",
                     (
-                        bytes32([0] * 32),
+                        bytes32.zeros,
                         bytes([0] * 10),
                         bytes([0]),
                     ),
@@ -121,7 +121,7 @@ async def test_notifications(
             wallet_node_2.config["enable_notifications"] = True
             AMOUNT = uint64(1)
             FEE = uint64(0)
-        elif case in ("allow", "allow_larger"):
+        elif case in {"allow", "allow_larger"}:
             wallet_node_2.config["required_notification_amount"] = 750000000000
             if case == "allow_larger":
                 AMOUNT = uint64(1000000000000)

chia/_tests/wallet/test_offer_parsing_performance.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 import cProfile
+from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Iterator
 
 from chia._tests.util.misc import BenchmarkRunner
 from chia.wallet.trading.offer import Offer

chia/_tests/wallet/test_puzzle_store.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import random
 from dataclasses import dataclass, field
-from typing import Dict, List
 
 import pytest
 from chia_rs import AugSchemeMPL
@@ -29,8 +28,8 @@ def get_dummy_record(index: int, wallet_id: int, seeded_random: random.Random) -
 @dataclass
 class DummyDerivationRecords:
     seeded_random: random.Random
-    index_per_wallet: Dict[int, int] = field(default_factory=dict)
-    records_per_wallet: Dict[int, List[DerivationRecord]] = field(default_factory=dict)
+    index_per_wallet: dict[int, int] = field(default_factory=dict)
+    records_per_wallet: dict[int, list[DerivationRecord]] = field(default_factory=dict)
 
     def generate(self, wallet_id: int, count: int) -> None:
         records = self.records_per_wallet.setdefault(wallet_id, [])

chia/_tests/wallet/test_sign_coin_spends.py

@@ -45,7 +45,7 @@ msg2: bytes = b"msg2"
 
 additional_data: bytes32 = bytes32(DEFAULT_CONSTANTS.AGG_SIG_ME_ADDITIONAL_DATA)
 
-coin: Coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+coin: Coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
 puzzle = SerializedProgram.from_bytes(b"\x01")
 solution_h = SerializedProgram.from_program(
     Program.to([[ConditionOpcode.AGG_SIG_UNSAFE, pk1_h, msg1], [ConditionOpcode.AGG_SIG_ME, pk2_h_synth, msg2]])
@@ -90,7 +90,7 @@ async def test_wsm_sign_transaction() -> None:
                 [
                     DerivationRecord(
                         uint32(1),
-                        bytes32([0] * 32),
+                        bytes32.zeros,
                         pk1_h,
                         WalletType.STANDARD_WALLET,
                         uint32(1),
@@ -129,7 +129,7 @@ async def test_wsm_sign_transaction() -> None:
                 [
                     DerivationRecord(
                         uint32(1),
-                        bytes32([0] * 32),
+                        bytes32.zeros,
                         pk1_u,
                         WalletType.STANDARD_WALLET,
                         uint32(1),

chia/_tests/wallet/test_signer_protocol.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import List, Optional
+from typing import Optional
 
 import click
 import pytest
@@ -11,7 +11,8 @@ from click.testing import CliRunner
 from chia._tests.cmds.test_cmd_framework import check_click_parsing
 from chia._tests.cmds.wallet.test_consts import STD_TX
 from chia._tests.environments.wallet import WalletStateTransition, WalletTestFramework
-from chia.cmds.cmd_classes import NeedsWalletRPC, WalletClientInfo, chia_command
+from chia.cmds.cmd_classes import chia_command
+from chia.cmds.cmd_helpers import NeedsWalletRPC, TransactionsIn, TransactionsOut, WalletClientInfo
 from chia.cmds.cmds_util import TransactionBundle
 from chia.cmds.signer import (
     ApplySignaturesCMD,
@@ -21,8 +22,6 @@ from chia.cmds.signer import (
     QrCodeDisplay,
     SPIn,
     SPOut,
-    TransactionsIn,
-    TransactionsOut,
 )
 from chia.rpc.util import ALL_TRANSLATION_LAYERS
 from chia.rpc.wallet_request_types import (
@@ -87,7 +86,7 @@ def test_unsigned_transaction_type() -> None:
     pubkey: G1Element = G1Element()
     message: bytes = b"message"
 
-    coin: ConsensusCoin = ConsensusCoin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+    coin: ConsensusCoin = ConsensusCoin(bytes32.zeros, bytes32.zeros, uint64(0))
     puzzle: Program = Program.to(1)
     solution: Program = Program.to([AggSigMe(pubkey, message).to_program()])
 
@@ -147,9 +146,9 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
         solution,
     )
 
-    derivation_record: Optional[DerivationRecord] = (
-        await wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(coin.puzzle_hash)
-    )
+    derivation_record: Optional[
+        DerivationRecord
+    ] = await wallet_state_manager.puzzle_store.get_derivation_record_for_puzzle_hash(coin.puzzle_hash)
     assert derivation_record is not None
     pubkey: G1Element = derivation_record.pubkey
     atom = puzzle.uncurry()[1].at("f").atom
@@ -180,7 +179,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
     assert utx.signing_instructions.targets[0].fingerprint == synthetic_pubkey.get_fingerprint().to_bytes(4, "big")
     assert utx.signing_instructions.targets[0].message == message
 
-    signing_responses: List[SigningResponse] = (
+    signing_responses: list[SigningResponse] = (
         await wallet_rpc.execute_signing_instructions(ExecuteSigningInstructions(utx.signing_instructions))
     ).signing_responses
     assert len(signing_responses) == 1
@@ -194,7 +193,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
     not_our_pubkey: G1Element = not_our_private_key.get_g1()
     not_our_message: bytes = b"not our message"
     not_our_coin: ConsensusCoin = ConsensusCoin(
-        bytes32([0] * 32),
+        bytes32.zeros,
         ACS_PH,
         uint64(0),
     )
@@ -256,7 +255,7 @@ async def test_p2dohp_wallet_signer_protocol(wallet_environments: WalletTestFram
         == signing_responses[0].signature
     )
 
-    signed_txs: List[SignedTransaction] = (
+    signed_txs: list[SignedTransaction] = (
         await wallet_rpc.apply_signatures(
             ApplySignatures(spends=[Spend.from_coin_spend(coin_spend)], signing_responses=signing_responses)
         )
@@ -322,7 +321,7 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
     # Test just a path hint
     test_name: bytes32 = std_hash(b"path hint only")
     child_sk: PrivateKey = _derive_path_unhardened(root_sk, [uint64(1), uint64(2), uint64(3), uint64(4)])
-    signing_responses: List[SigningResponse] = await wallet.execute_signing_instructions(
+    signing_responses: list[SigningResponse] = await wallet.execute_signing_instructions(
         SigningInstructions(
             KeyHints(
                 [],
@@ -505,16 +504,16 @@ async def test_p2blsdohp_execute_signing_instructions(wallet_environments: Walle
 
 
 def test_blind_signer_translation_layer() -> None:
-    sum_hints: List[SumHint] = [
+    sum_hints: list[SumHint] = [
         SumHint([b"a", b"b", b"c"], b"offset", b"final"),
         SumHint([b"c", b"b", b"a"], b"offset2", b"final"),
     ]
-    path_hints: List[PathHint] = [
+    path_hints: list[PathHint] = [
         PathHint(b"root1", [uint64(1), uint64(2), uint64(3)]),
         PathHint(b"root2", [uint64(4), uint64(5), uint64(6)]),
     ]
-    signing_targets: List[SigningTarget] = [
-        SigningTarget(b"pubkey", b"message", bytes32([0] * 32)),
+    signing_targets: list[SigningTarget] = [
+        SigningTarget(b"pubkey", b"message", bytes32.zeros),
         SigningTarget(b"pubkey2", b"message2", bytes32([1] * 32)),
     ]
 
@@ -531,16 +530,16 @@ def test_blind_signer_translation_layer() -> None:
         bytes32([1] * 32),
     )
 
-    bstl_sum_hints: List[BSTLSumHint] = [
+    bstl_sum_hints: list[BSTLSumHint] = [
         BSTLSumHint([b"a", b"b", b"c"], b"offset", b"final"),
         BSTLSumHint([b"c", b"b", b"a"], b"offset2", b"final"),
     ]
-    bstl_path_hints: List[BSTLPathHint] = [
+    bstl_path_hints: list[BSTLPathHint] = [
         BSTLPathHint(b"root1", [uint64(1), uint64(2), uint64(3)]),
         BSTLPathHint(b"root2", [uint64(4), uint64(5), uint64(6)]),
     ]
-    bstl_signing_targets: List[BSTLSigningTarget] = [
-        BSTLSigningTarget(b"pubkey", b"message", bytes32([0] * 32)),
+    bstl_signing_targets: list[BSTLSigningTarget] = [
+        BSTLSigningTarget(b"pubkey", b"message", bytes32.zeros),
         BSTLSigningTarget(b"pubkey2", b"message2", bytes32([1] * 32)),
     ]
 
@@ -616,7 +615,7 @@ async def test_signer_commands(wallet_environments: WalletTestFramework) -> None
 
     AMOUNT = uint64(1)
     async with wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, sign=False, push=False) as action_scope:
-        await wallet.generate_signed_transaction(AMOUNT, bytes32([0] * 32), action_scope)
+        await wallet.generate_signed_transaction(AMOUNT, bytes32.zeros, action_scope)
     [tx] = action_scope.side_effects.transactions
 
     runner = CliRunner()
@@ -698,7 +697,7 @@ def test_signer_command_default_parsing() -> None:
             ),
             txs_in=TransactionsIn(transaction_file_in="in"),
         ),
-        "-i",
+        "--transaction-file-in",
         "in",
     )
 
@@ -729,9 +728,9 @@ def test_signer_command_default_parsing() -> None:
             ),
             txs_out=TransactionsOut(transaction_file_out="out"),
         ),
-        "-i",
+        "--transaction-file-in",
         "in",
-        "-o",
+        "--transaction-file-out",
         "out",
         "-p",
         "sp-in",
@@ -742,7 +741,7 @@ def test_signer_command_default_parsing() -> None:
             rpc_info=NeedsWalletRPC(client_info=None, wallet_rpc_port=None, fingerprint=None),
             txs_in=TransactionsIn(transaction_file_in="in"),
         ),
-        "-i",
+        "--transaction-file-in",
         "in",
     )
 
@@ -752,7 +751,7 @@ def test_transactions_in() -> None:
     def cmd() -> None:
         pass
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD(TransactionsIn):
         def run(self) -> None:
             assert self.transaction_bundle == TransactionBundle([STD_TX])
@@ -771,7 +770,7 @@ def test_transactions_out() -> None:
     def cmd() -> None:
         pass
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD(TransactionsOut):
         def run(self) -> None:
             self.handle_transaction_output([STD_TX])
@@ -797,8 +796,8 @@ class FooCoin(Streamable):
     @staticmethod
     def to_wallet_api(_from: FooCoin) -> Coin:
         return Coin(
-            bytes32([0] * 32),
-            bytes32([0] * 32),
+            bytes32.zeros,
+            bytes32.zeros,
             _from.amount,
         )
 
@@ -822,9 +821,9 @@ def test_signer_protocol_in(monkeypatch: pytest.MonkeyPatch) -> None:
     def cmd() -> None:
         pass
 
-    coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(13))
+    coin = Coin(bytes32.zeros, bytes32.zeros, uint64(13))
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD(SPIn):
         def run(self) -> None:
             assert self.read_sp_input(Coin) == [coin, coin]
@@ -878,10 +877,10 @@ def test_signer_protocol_out(monkeypatch: pytest.MonkeyPatch) -> None:
     def cmd() -> None:
         pass
 
-    coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(0))
+    coin = Coin(bytes32.zeros, bytes32.zeros, uint64(0))
     coin_bytes = byte_serialize_clvm_streamable(coin)
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD(SPOut):
         def run(self) -> None:
             self.handle_clvm_output([coin, coin])
@@ -930,7 +929,7 @@ def test_qr_code_display() -> None:
 
     bytes_to_encode = b"foo bar qat qux bam bat"
 
-    @chia_command(cmd, "temp_cmd", "blah")
+    @chia_command(group=cmd, name="temp_cmd", short_help="blah", help="n/a")
     class TempCMD(QrCodeDisplay):
         def run(self) -> None:
             self.display_qr_codes([bytes_to_encode, bytes_to_encode])