Merge remote-tracking branch 'origin/main' into fine_william___fine

Author: emlowe

.github/workflows/test-install-scripts.yml

@@ -241,6 +241,16 @@ jobs:
         run: |
           yum install --assumeyes git
 
+      - name: Set rocky8 repo
+        if: ${{ matrix.distribution.name == 'rockylinux:8' }}
+        run: |
+          sed -i -e 's|^mirrorlist=|#mirrorlist=|' -e 's|^#baseurl=http://dl\.rockylinux\.org/|baseurl=https://dl.rockylinux.org/|' /etc/yum.repos.d/Rocky-*.repo
+
+      - name: Set rocky9 repo
+        if: ${{ matrix.distribution.name == 'rockylinux:9' }}
+        run: |
+          sed -i -e 's|^mirrorlist=|#mirrorlist=|' -e 's|^#baseurl=http://dl\.rockylinux\.org/|baseurl=https://dl.rockylinux.org/|' /etc/yum.repos.d/rocky-*.repo
+
       - name: Prepare Rocky
         if: ${{ matrix.distribution.type == 'rocky' }}
         run: |

chia/_tests/cmds/wallet/test_wallet.py

@@ -29,6 +29,7 @@
 from chia.types.signing_mode import SigningMode
 from chia.util.bech32m import encode_puzzle_hash
 from chia.wallet.conditions import Condition, ConditionValidTimes
+from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.trade_record import TradeRecord
 from chia.wallet.trading.offer import Offer
 from chia.wallet.trading.trade_status import TradeStatus
@@ -49,6 +50,7 @@
     CATSpend,
     CATSpendResponse,
     ClawbackPuzzleDecoratorOverride,
+    CreateOfferForIDs,
     CreateOfferForIDsResponse,
     DeleteUnconfirmedTransactions,
     ExtendDerivationIndex,
@@ -79,6 +81,29 @@
 )
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
+TEMP = PuzzleInfo(
+    {
+        "type": "singleton",
+        "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
+        "launcher_ph": "0xeff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
+        "also": {
+            "type": "metadata",
+            "metadata": "",
+            "updater_hash": "0x0707070707070707070707070707070707070707070707070707070707070707",
+            "also": {
+                "type": "ownership",
+                "owner": "()",
+                "transfer_program": {
+                    "type": "royalty transfer program",
+                    "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
+                    "royalty_address": "0x0303030303030303030303030303030303030303030303030303030303030303",
+                    "royalty_percentage": "1000",
+                },
+            },
+        },
+    }
+)
+
 test_offer_file_path = importlib_resources.files(__name__.rpartition(".")[0]).joinpath("test_offer.toffer")
 test_offer_file_bech32 = test_offer_file_path.read_text(encoding="utf-8")
 test_offer_id: str = "0xdfb7e8643376820ec995b0bcdb3fc1f764c16b814df5e074631263fcf1e00839"
@@ -763,17 +788,22 @@ def test_make_offer(capsys: object, get_test_cli_clients: tuple[TestRpcClients,
     class MakeOfferRpcClient(TestWalletRpcClient):
         async def create_offer_for_ids(
             self,
-            offer_dict: dict[uint32, int],
+            request: CreateOfferForIDs,
             tx_config: TXConfig,
-            driver_dict: Optional[dict[str, Any]] = None,
-            solver: Optional[dict[str, Any]] = None,
-            fee: uint64 = uint64(0),
-            validate_only: bool = False,
+            extra_conditions: tuple[Condition, ...] = tuple(),
             timelock_info: ConditionValidTimes = ConditionValidTimes(),
         ) -> CreateOfferForIDsResponse:
             self.add_to_log(
                 "create_offer_for_ids",
-                (offer_dict, tx_config, driver_dict, solver, fee, validate_only, timelock_info),
+                (
+                    request.offer,
+                    tx_config,
+                    request.driver_dict,
+                    request.solver,
+                    request.fee,
+                    request.validate_only,
+                    timelock_info,
+                ),
             )
 
             created_offer = Offer({}, WalletSpendBundle([], G2Element()), {})
@@ -866,35 +896,39 @@ async def create_offer_for_ids(
         "create_offer_for_ids": [
             (
                 {
-                    1: -10000000000000,
-                    3: -100000,
-                    "0404040404040404040404040404040404040404040404040404040404040404": -100000,
-                    "0202020202020202020202020202020202020202020202020202020202020202": 10000,
-                    "0101010101010101010101010101010101010101010101010101010101010101": 1,
+                    "1": "-10000000000000",
+                    "3": "-100000",
+                    "0404040404040404040404040404040404040404040404040404040404040404": "-100000",
+                    "0202020202020202020202020202020202020202020202020202020202020202": "10000",
+                    "0101010101010101010101010101010101010101010101010101010101010101": "1",
                 },
                 DEFAULT_TX_CONFIG.override(reuse_puzhash=True),
                 {
-                    "0101010101010101010101010101010101010101010101010101010101010101": {
-                        "type": "singleton",
-                        "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
-                        "launcher_ph": "0xeff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
-                        "also": {
-                            "type": "metadata",
-                            "metadata": "",
-                            "updater_hash": "0x0707070707070707070707070707070707070707070707070707070707070707",
+                    bytes32([1] * 32): PuzzleInfo(
+                        {
+                            "type": "singleton",
+                            "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
+                            "launcher_ph": "0xeff07522495060c066f66f32acc2a77e3a3e737aca8baea4d1a64ea4cdc13da9",
                             "also": {
-                                "type": "ownership",
-                                "owner": "()",
-                                "transfer_program": {
-                                    "type": "royalty transfer program",
-                                    "launcher_id": "0x0101010101010101010101010101010101010101010101010101010101010101",
-                                    "royalty_address": "0x0303030303030303030303030303030303030303030"
-                                    "303030303030303030303",
-                                    "royalty_percentage": "1000",
+                                "type": "metadata",
+                                "metadata": "",
+                                "updater_hash": "0x0707070707070707070707070707070707070707070707070707070707070707",
+                                "also": {
+                                    "type": "ownership",
+                                    "owner": "()",
+                                    "transfer_program": {
+                                        "type": "royalty transfer program",
+                                        "launcher_id": (
+                                            "0x0101010101010101010101010101010101010101010101010101010101010101"
+                                        ),
+                                        "royalty_address": "0x0303030303030303030303030303030303030303030"
+                                        "303030303030303030303",
+                                        "royalty_percentage": "1000",
+                                    },
                                 },
                             },
-                        },
-                    }
+                        }
+                    )
                 },
                 None,
                 500000000000,

chia/_tests/core/custom_types/test_proof_of_space.py

@@ -66,15 +66,15 @@ def b32(key: str) -> bytes32:
         plot_size=PlotSize.make_v1(31),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
-        expected_error="Plot size is lower than the minimum",
+        expected_error="Plot size (31) is lower than the minimum (32)",
     ),
     ProofOfSpaceCase(
         id="Higher than maximum plot size",
         pos_challenge=bytes32(b"1" * 32),
         plot_size=PlotSize.make_v1(51),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
-        expected_error="Plot size is higher than the maximum",
+        expected_error="Plot size (51) is higher than the maximum (50)",
     ),
     ProofOfSpaceCase(
         id="Different challenge",
@@ -115,15 +115,15 @@ def b32(key: str) -> bytes32:
         plot_size=PlotSize.make_v2(0),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
-        expected_error="Plot size is lower than the minimum",
+        expected_error="Plot size (0) is lower than the minimum (28)",
     ),
     ProofOfSpaceCase(
         id="v2 plot size 34",
         pos_challenge=bytes32(b"1" * 32),
         plot_size=PlotSize.make_v2(34),
         plot_public_key=G1Element(),
         pool_public_key=G1Element(),
-        expected_error="Plot size is higher than the maximum",
+        expected_error="Plot size (34) is higher than the maximum (32)",
     ),
     ProofOfSpaceCase(
         id="Not passing the plot filter v2",

chia/_tests/core/full_node/test_full_node.py

@@ -2713,7 +2713,7 @@ def check_nodes_in_sync() -> bool:
         p2 = full_node_1.full_node.blockchain.get_peak()
         return p1 == p2
 
-    await time_out_assert(300, check_nodes_in_sync)
+    await time_out_assert(600, check_nodes_in_sync)
     peak = full_node_2.full_node.blockchain.get_peak()
     assert peak is not None
     print(f"peak: {str(peak.header_hash)[:6]}")

chia/_tests/util/config.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-job_timeout = 60
+job_timeout = 90

chia/_tests/util/test_full_block_utils.py

@@ -255,6 +255,9 @@ def get_full_blocks() -> Iterator[FullBlock]:
 
 
 @pytest.mark.anyio
+@pytest.mark.skip(
+    "Very slow test with limited usefulness: was used to ensure the cheap parser for FullBlock matched the regular one"
+)
 async def test_parser():
     # loop over every combination of Optionals being set and not set
     # along with random values for the FullBlock fields. Ensure

chia/_tests/wallet/rpc/test_wallet_rpc.py

@@ -81,6 +81,7 @@
 from chia.wallet.derive_keys import master_sk_to_wallet_sk, master_sk_to_wallet_sk_unhardened
 from chia.wallet.did_wallet.did_wallet import DIDWallet
 from chia.wallet.nft_wallet.nft_wallet import NFTWallet
+from chia.wallet.puzzle_drivers import PuzzleInfo
 from chia.wallet.puzzles.clawback.metadata import AutoClaimSettings
 from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
 from chia.wallet.signer_protocol import UnsignedTransaction
@@ -101,7 +102,7 @@
 from chia.wallet.wallet import Wallet
 from chia.wallet.wallet_coin_record import WalletCoinRecord
 from chia.wallet.wallet_coin_store import GetCoinRecords
-from chia.wallet.wallet_node import WalletNode
+from chia.wallet.wallet_node import WalletNode, get_wallet_db_path
 from chia.wallet.wallet_protocol import WalletProtocol
 from chia.wallet.wallet_request_types import (
     AddKey,
@@ -114,6 +115,7 @@
     CheckOfferValidity,
     ClawbackPuzzleDecoratorOverride,
     CombineCoins,
+    CreateOfferForIDs,
     DefaultCAT,
     DeleteKey,
     DeleteNotifications,
@@ -1586,28 +1588,29 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
         )
     # Create an offer of 5 chia for one CAT
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1}, wallet_environments.tx_config, validate_only=True
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, validate_only=True),
+        tx_config=wallet_environments.tx_config,
     )
     all_offers = await env_1.rpc_client.get_all_offers()
     assert len(all_offers) == 0
 
-    driver_dict: dict[str, Any] = {
-        cat_asset_id.hex(): {
-            "type": "CAT",
-            "tail": "0x" + cat_asset_id.hex(),
-            **(
-                {}
-                if wallet_type is CATWallet
-                else {"also": {"type": "revocation layer", "hidden_puzzle_hash": "0x" + bytes32.zeros.hex()}}
-            ),
-        }
+    driver_dict = {
+        cat_asset_id: PuzzleInfo(
+            {
+                "type": "CAT",
+                "tail": "0x" + cat_asset_id.hex(),
+                **(
+                    {}
+                    if wallet_type is CATWallet
+                    else {"also": {"type": "revocation layer", "hidden_puzzle_hash": "0x" + bytes32.zeros.hex()}}
+                ),
+            }
+        )
     }
 
     create_res = await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
-        fee=uint64(1),
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict, fee=uint64(1)),
+        tx_config=wallet_environments.tx_config,
     )
     offer = create_res.offer
 
@@ -1618,7 +1621,7 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     assert summary == {
         "offered": {"xch": 5},
         "requested": {cat_asset_id.hex(): 1},
-        "infos": driver_dict,
+        "infos": {key.hex(): info.info for key, info in driver_dict.items()},
         "fees": 1,
         "additions": [c.name().hex() for c in offer.additions()],
         "removals": [c.name().hex() for c in offer.removals()],
@@ -1662,7 +1665,8 @@ async def test_offer_endpoints(wallet_environments: WalletTestFramework, wallet_
     assert TradeStatus(trade_record.status) == TradeStatus.PENDING_CANCEL
 
     create_res = await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_wallet_id: 1}, wallet_environments.tx_config, fee=uint64(1)
+        CreateOfferForIDs(offer={str(1): "-5", str(cat_wallet_id): "1"}, fee=uint64(1)),
+        tx_config=wallet_environments.tx_config,
     )
     all_offers = await env_1.rpc_client.get_all_offers()
     assert len(all_offers) == 2
@@ -1776,9 +1780,8 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
     assert len(all_offers) == 2
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
         len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
@@ -1814,14 +1817,12 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
     )
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): -5, cat_asset_id.hex(): 1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "-5", cat_asset_id.hex(): "1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): 5, cat_asset_id.hex(): -1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "5", cat_asset_id.hex(): "-1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
         len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 2
@@ -1868,9 +1869,8 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
     )
 
     await env_1.rpc_client.create_offer_for_ids(
-        {uint32(1): 5, cat_asset_id.hex(): -1},
-        wallet_environments.tx_config,
-        driver_dict=driver_dict,
+        CreateOfferForIDs(offer={str(1): "5", cat_asset_id.hex(): "-1"}, driver_dict=driver_dict),
+        tx_config=wallet_environments.tx_config,
     )
     assert (
         len([o for o in await env_1.rpc_client.get_all_offers() if o.status == TradeStatus.PENDING_ACCEPT.value]) == 1
@@ -1886,9 +1886,11 @@ def only_ids(trades: list[TradeRecord]) -> list[bytes32]:
 
     with pytest.raises(ValueError, match="not currently supported"):
         await env_1.rpc_client.create_offer_for_ids(
-            {uint32(1): -5, cat_asset_id.hex(): 1},
+            CreateOfferForIDs(
+                offer={str(1): "-5", cat_asset_id.hex(): "1"},
+                driver_dict=driver_dict,
+            ),
             wallet_environments.tx_config,
-            driver_dict=driver_dict,
             timelock_info=ConditionValidTimes(min_secs_since_created=uint64(1)),
         )
 
@@ -2340,7 +2342,9 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
     assert delete_key_resp.used_for_farmer_rewards is False
     assert delete_key_resp.used_for_pool_rewards is False
 
+    assert get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[0])).exists()
     await client.delete_key(DeleteKey(pks[0]))
+    assert not get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[0])).exists()
     await client.log_in(LogIn(uint32(pks[1])))
     assert len((await client.get_public_keys()).pk_fingerprints) == 1
 
@@ -2357,7 +2361,13 @@ async def test_key_and_address_endpoints(wallet_rpc_environment: WalletRpcTestEn
         )
 
     # Delete all keys
+    resp = await client.generate_mnemonic()
+    add_key_resp = await client.add_key(AddKey(resp.mnemonic))
+    assert get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[1])).exists()
+    assert get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(add_key_resp.fingerprint)).exists()
     await client.delete_all_keys()
+    assert not get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(pks[1])).exists()
+    assert not get_wallet_db_path(wallet_node.root_path, wallet_node.config, str(add_key_resp.fingerprint)).exists()
     assert len((await client.get_public_keys()).pk_fingerprints) == 0
 
 

chia/_tests/weight_proof/config.py

@@ -1,3 +1,4 @@
 from __future__ import annotations
 
 checkout_blocks_and_plots = True
+job_timeout = 45

chia/cmds/peer_funcs.py

@@ -20,7 +20,7 @@ async def add_node_connection(rpc_client: RpcClient, add_connection: str) -> Non
         except Exception:
             print(f"Failed to connect to {host}:{port}")
     except ValueError:
-        print("Enter a valid IP and port in the following format: 10.5.4.3:8000")
+        print("Enter a valid IP and port in the following format: 10.5.4.3:8444 or [2606:f6c0:80:5::a]:8444")
 
 
 async def remove_node_connection(rpc_client: RpcClient, remove_connection: str) -> None: