chia-blockchain 2.4.3rc1__tar.gz → 2.4.3rc3__tar.gz

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chia-blockchain
-Version: 2.4.3rc1
+Version: 2.4.3rc3
 Summary: Chia blockchain full node, farmer, timelord, and wallet.
 Home-page: https://chia.net/
 License: Apache License

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/_tests/cmds/test_daemon.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -9,7 +10,7 @@ from click.testing import CliRunner
 from pytest_mock import MockerFixture
 
 from chia.cmds.chia import cli
-from chia.cmds.start_funcs import create_start_daemon_connection
+from chia.cmds.start_funcs import create_start_daemon_connection, launch_start_daemon
 
 
 @pytest.mark.anyio
@@ -52,6 +53,20 @@ async def test_daemon(
         assert not captured.out.endswith("Skipping to unlock keyring\n")
 
 
+@pytest.mark.anyio
+def test_launch_start_daemon(tmp_path: Path) -> None:
+    sys.argv[0] = "not-exist"
+    with pytest.raises(FileNotFoundError):
+        launch_start_daemon(tmp_path)
+
+    helper: Path = Path(sys.executable)
+    sys.argv[0] = str(helper.parent) + "/chia"
+    process = launch_start_daemon(tmp_path)
+    assert process is not None
+    process.kill()
+    process.wait()
+
+
 def test_start_daemon(tmp_path: Path, empty_keyring: Any, mocker: MockerFixture) -> None:
     class DummyDaemon:
         @staticmethod

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/_tests/core/data_layer/test_data_rpc.py

@@ -5,6 +5,7 @@ import contextlib
 import copy
 import enum
 import json
+import logging
 import os
 import random
 import sqlite3
@@ -14,7 +15,7 @@ from copy import deepcopy
 from dataclasses import dataclass
 from enum import IntEnum
 from pathlib import Path
-from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, cast
+from typing import Any, AsyncIterator, Dict, List, Optional, Set, Tuple, cast
 
 import anyio
 import pytest
@@ -2239,6 +2240,16 @@ async def test_maximum_full_file_count(
                         assert filename not in filenames
 
 
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_unsubscribe_unknown(
+    bare_data_layer_api: DataLayerRpcApi,
+    seeded_random: random.Random,
+) -> None:
+    with pytest.raises(RuntimeError, match="No subscription found for the given store_id."):
+        await bare_data_layer_api.unsubscribe(request={"id": bytes32.random(seeded_random).hex(), "retain": False})
+
+
 @pytest.mark.parametrize("retain", [True, False])
 @pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
 @pytest.mark.anyio
@@ -2266,6 +2277,8 @@ async def test_unsubscribe_removes_files(
         store_id = bytes32.from_hexstr(res["id"])
         await farm_block_check_singleton(data_layer, full_node_api, ph, store_id, wallet=wallet_rpc_api.service)
 
+        # subscribe to ourselves
+        await data_rpc_api.subscribe(request={"id": store_id.hex()})
         update_count = 10
         for batch_count in range(update_count):
             key = batch_count.to_bytes(2, "big")
@@ -3712,3 +3725,90 @@ async def test_unsubmitted_batch_db_migration(
         await farm_block_with_spend(full_node_api, ph, update_tx_rec1, wallet_rpc_api)
         keys = await data_rpc_api.get_keys({"id": store_id.hex()})
         assert keys == {"keys": ["0x30303031", "0x30303030"]}
+
+
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@boolean_datacases(name="auto_subscribe_to_local_stores", false="do not auto subscribe", true="auto subscribe")
+@pytest.mark.anyio
+async def test_auto_subscribe_to_local_stores(
+    self_hostname: str,
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    tmp_path: Path,
+    monkeypatch: Any,
+    auto_subscribe_to_local_stores: bool,
+) -> None:
+    wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(
+        self_hostname, one_wallet_and_one_simulator_services
+    )
+    manage_data_interval = 5
+    fake_store = bytes32([1] * 32)
+
+    async def mock_get_store_ids(self: Any) -> Set[bytes32]:
+        return {fake_store}
+
+    async def mock_dl_track_new(self: Any, request: Dict[str, Any]) -> Dict[str, Any]:
+        # ignore and just return empty response
+        return {}
+
+    with monkeypatch.context() as m:
+        m.setattr("chia.data_layer.data_store.DataStore.get_store_ids", mock_get_store_ids)
+        m.setattr("chia.rpc.wallet_rpc_client.WalletRpcClient.dl_track_new", mock_dl_track_new)
+
+        config = bt.config
+        config["data_layer"]["auto_subscribe_to_local_stores"] = auto_subscribe_to_local_stores
+        bt.change_config(new_config=config)
+
+        async with init_data_layer(
+            wallet_rpc_port=wallet_rpc_port,
+            bt=bt,
+            db_path=tmp_path,
+            manage_data_interval=manage_data_interval,
+            maximum_full_file_count=100,
+        ) as data_layer:
+            data_rpc_api = DataLayerRpcApi(data_layer)
+
+            await asyncio.sleep(manage_data_interval)
+
+            response = await data_rpc_api.subscriptions(request={})
+
+            if auto_subscribe_to_local_stores:
+                assert fake_store.hex() in response["store_ids"]
+            else:
+                assert fake_store.hex() not in response["store_ids"]
+
+
+@pytest.mark.limit_consensus_modes(reason="does not depend on consensus rules")
+@pytest.mark.anyio
+async def test_local_store_exception(
+    self_hostname: str,
+    one_wallet_and_one_simulator_services: SimulatorsAndWalletsServices,
+    tmp_path: Path,
+    monkeypatch: Any,
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    wallet_rpc_api, full_node_api, wallet_rpc_port, ph, bt = await init_wallet_and_node(
+        self_hostname, one_wallet_and_one_simulator_services
+    )
+    manage_data_interval = 5
+    fake_store = bytes32([1] * 32)
+
+    async def mock_get_store_ids(self: Any) -> Set[bytes32]:
+        return {fake_store}
+
+    with monkeypatch.context() as m, caplog.at_level(logging.INFO):
+        m.setattr("chia.data_layer.data_store.DataStore.get_store_ids", mock_get_store_ids)
+
+        config = bt.config
+        config["data_layer"]["auto_subscribe_to_local_stores"] = True
+        bt.change_config(new_config=config)
+
+        async with init_data_layer(
+            wallet_rpc_port=wallet_rpc_port,
+            bt=bt,
+            db_path=tmp_path,
+            manage_data_interval=manage_data_interval,
+            maximum_full_file_count=100,
+        ):
+            await asyncio.sleep(manage_data_interval)
+
+            assert f"Can't subscribe to local store {fake_store.hex()}:" in caplog.text

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/_tests/wallet/test_wallet_node.py

@@ -751,3 +751,36 @@ async def test_start_with_multiple_key_types(
 
     await restart_with_fingerprint(fingerprint_pk)
     assert wallet_node.wallet_state_manager.private_key == initial_sk
+
+
+@pytest.mark.anyio
+@pytest.mark.standard_block_tools
+async def test_start_with_multiple_keys(
+    simulator_and_wallet: OldSimulatorsAndWallets, self_hostname: str, default_400_blocks: List[FullBlock]
+) -> None:
+    [full_node_api], [(wallet_node, wallet_server)], bt = simulator_and_wallet
+
+    async def restart_with_fingerprint(fingerprint: Optional[int]) -> None:
+        wallet_node._close()
+        await wallet_node._await_closed(shutting_down=False)
+        await wallet_node._start_with_fingerprint(fingerprint=fingerprint)
+
+    initial_sk = wallet_node.wallet_state_manager.private_key
+
+    sk_2: PrivateKey = await wallet_node.keychain_proxy.add_key(
+        (
+            "cup smoke miss park baby say island tomorrow segment lava bitter easily settle gift "
+            "renew arrive kangaroo dilemma organ skin design salt history awesome"
+        ),
+        None,
+        private=True,
+    )
+    fingerprint_2: int = sk_2.get_g1().get_fingerprint()
+
+    await restart_with_fingerprint(fingerprint_2)
+    assert wallet_node.wallet_state_manager.private_key == sk_2
+
+    await wallet_node.keychain_proxy.delete_key_by_fingerprint(fingerprint_2)
+
+    await restart_with_fingerprint(fingerprint_2)
+    assert wallet_node.wallet_state_manager.private_key == initial_sk

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/cmds/start_funcs.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import os
+import shutil
 import subprocess
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -21,8 +22,17 @@ def launch_start_daemon(root_path: Path) -> subprocess.Popen:
     if sys.platform == "win32":
         creationflags = subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.CREATE_NO_WINDOW
 
+    path_helper: Path = Path(sys.argv[0])
+    cmd_to_execute = None
+    if len(path_helper.suffix) == 0:
+        cmd_to_execute = shutil.which(cmd=path_helper.name, path=path_helper.parent)
+
+    if cmd_to_execute is None:
+        cmd_to_execute = sys.argv[0]
+
+    print(f"Starting daemon: {cmd_to_execute} run_daemon --wait-for-unlock", flush=True)
     process = subprocess.Popen(
-        [sys.argv[0], "run_daemon", "--wait-for-unlock"],
+        [cmd_to_execute, "run_daemon", "--wait-for-unlock"],
         encoding="utf-8",
         stdout=subprocess.PIPE,
         creationflags=creationflags,
@@ -36,7 +46,7 @@ async def create_start_daemon_connection(
 ) -> Optional[DaemonProxy]:
     connection = await connect_to_daemon_and_validate(root_path, config)
     if connection is None:
-        print("Starting daemon")
+        print("Starting daemon", flush=True)
         # launch a daemon
         process = launch_start_daemon(root_path)
         # give the daemon a chance to start up

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/daemon/server.py

@@ -5,6 +5,7 @@ import dataclasses
 import json
 import logging
 import os
+import shutil
 import signal
 import ssl
 import subprocess
@@ -112,7 +113,8 @@ else:
     application_path = os.path.dirname(__file__)
 
     def executable_for_service(service_name: str) -> str:
-        return service_name
+        cmd_to_exec = shutil.which(service_name)
+        return cmd_to_exec if cmd_to_exec is not None else service_name
 
 
 async def ping() -> Dict[str, Any]:

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/data_layer/data_layer.py

@@ -772,6 +772,10 @@ class DataLayer:
 
     async def unsubscribe(self, store_id: bytes32, retain_data: bool) -> None:
         async with self.subscription_lock:
+            subscriptions = await self.data_store.get_subscriptions()
+            if store_id not in (subscription.store_id for subscription in subscriptions):
+                raise RuntimeError("No subscription found for the given store_id.")
+
             # Unsubscribe is processed later, after all fetching of data is done, to avoid races.
             self.unsubscribe_data_queue.append(UnsubscribeData(store_id, retain_data))
 
@@ -869,22 +873,46 @@ class DataLayer:
                 await asyncio.sleep(0.1)
 
         while not self._shut_down:
+            # Add existing subscriptions
             async with self.subscription_lock:
                 subscriptions = await self.data_store.get_subscriptions()
 
-            # Subscribe to all local store_ids that we can find on chain.
-            local_store_ids = await self.data_store.get_store_ids()
+            # pseudo-subscribe to all unsubscribed owned stores
+            # Need this to make sure we process updates and generate DAT files
+            try:
+                owned_stores = await self.get_owned_stores()
+            except ValueError:
+                # Sometimes the DL wallet isn't available, so we can't get the owned stores.
+                # We'll try again next time.
+                owned_stores = []
             subscription_store_ids = {subscription.store_id for subscription in subscriptions}
-            for local_id in local_store_ids:
-                if local_id not in subscription_store_ids:
+            for record in owned_stores:
+                store_id = record.launcher_id
+                if store_id not in subscription_store_ids:
                     try:
-                        subscription = await self.subscribe(local_id, [])
-                        subscriptions.insert(0, subscription)
+                        # don't actually subscribe, just add to the list
+                        subscriptions.insert(0, Subscription(store_id=store_id, servers_info=[]))
                     except Exception as e:
                         self.log.info(
-                            f"Can't subscribe to locally stored {local_id}: {type(e)} {e} {traceback.format_exc()}"
+                            f"Can't subscribe to owned store {store_id}: {type(e)} {e} {traceback.format_exc()}"
                         )
 
+            # Optionally
+            # Subscribe to all local non-owned store_ids that we can find on chain.
+            # This is the prior behavior where all local stores, both owned and not owned, are subscribed to.
+            if self.config.get("auto_subscribe_to_local_stores", False):
+                local_store_ids = await self.data_store.get_store_ids()
+                subscription_store_ids = {subscription.store_id for subscription in subscriptions}
+                for local_id in local_store_ids:
+                    if local_id not in subscription_store_ids:
+                        try:
+                            subscription = await self.subscribe(local_id, [])
+                            subscriptions.insert(0, subscription)
+                        except Exception as e:
+                            self.log.info(
+                                f"Can't subscribe to local store {local_id}: {type(e)} {e} {traceback.format_exc()}"
+                            )
+
             work_queue: asyncio.Queue[Job[Subscription]] = asyncio.Queue()
             async with QueuedAsyncPool.managed(
                 name="DataLayer subscription update pool",

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/util/initial-config.yaml

@@ -203,7 +203,7 @@ farmer:
     - host: *self_hostname
       port: 8444
 
-  pool_public_keys: []
+  pool_public_keys: !!set {}
 
   # Replace this with a real receive address
   # xch_target_address: txch102gkhhzs60grx7cfnpng5n6rjecr89r86l5s8xux2za8k820cxsq64ssdg

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/wallet/cat_wallet/cat_constants.py

@@ -36,6 +36,13 @@ BASE_WARPED_MILLIETH = {
     "symbol": "wmilliETH.b",
 }
 
+BASE_WARPED_EURC = {
+    "asset_id": "31ffd54c5b38bb33352dc0be0ebf9cf4f29a6329156dd4811d6f4254f85c8200",
+    "name": "Base Warped EURC",
+    "symbol": "wEURC.b",
+}
+
+
 ETH_WARPED_USDC = {
     "asset_id": "bbb51b246fbec1da1305be31dcf17151ccd0b8231a1ec306d7ce9f5b8c742b9e",
     "name": "Ethereum Warped USDC",
@@ -61,6 +68,7 @@ DEFAULT_CATS = {
     CHIA_HOLIDAY_TOKEN["asset_id"]: CHIA_HOLIDAY_TOKEN,
     BASE_WARPED_USDC["asset_id"]: BASE_WARPED_USDC,
     BASE_WARPED_MILLIETH["asset_id"]: BASE_WARPED_MILLIETH,
+    BASE_WARPED_EURC["asset_id"]: BASE_WARPED_EURC,
     ETH_WARPED_USDC["asset_id"]: ETH_WARPED_USDC,
     ETH_WARPED_MILLIETH["asset_id"]: ETH_WARPED_MILLIETH,
     ETH_WARPED_USDT["asset_id"]: ETH_WARPED_USDT,

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/chia/wallet/wallet_node.py

@@ -419,6 +419,9 @@ class WalletNode:
         private_key = await self.get_key(fingerprint, private=True, find_a_default=False)
         if private_key is None:
             public_key = await self.get_key(fingerprint, private=False, find_a_default=False)
+        else:
+            assert isinstance(private_key, PrivateKey)
+            public_key = private_key.get_g1()
 
         if public_key is None:
             private_key = await self.get_key(None, private=True, find_a_default=True)

{chia_blockchain-2.4.3rc1 → chia_blockchain-2.4.3rc3}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "chia-blockchain"
 # see [tool.poetry-dynamic-versioning]
-version = "2.4.3-rc1"
+version = "2.4.3-rc3"
 description = "Chia blockchain full node, farmer, timelord, and wallet."
 authors = ["Mariano Sorgente <mariano@chia.net>"]
 license = "Apache License"