chia-blockchain 2.4.3__tar.gz → 2.4.3b1__tar.gz

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: chia-blockchain
-Version: 2.4.3
+Version: 2.4.3b1
 Summary: Chia blockchain full node, farmer, timelord, and wallet.
 Home-page: https://chia.net/
 License: Apache License
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: dev
 Provides-Extra: legacy-keyring
 Provides-Extra: upnp
-Requires-Dist: aiofiles (==24.1.0)
+Requires-Dist: aiofiles (==23.2.1)
 Requires-Dist: aiohttp (==3.9.5)
 Requires-Dist: aiohttp_cors (==0.7.0) ; extra == "dev"
 Requires-Dist: aiosqlite (==0.20.0)
@@ -47,7 +47,7 @@ Requires-Dist: flake8 (==7.0.0) ; extra == "dev"
 Requires-Dist: hsms (==0.3.1)
 Requires-Dist: importlib-resources (==6.4.0)
 Requires-Dist: isort (==5.13.2) ; extra == "dev"
-Requires-Dist: keyring (==25.2.1)
+Requires-Dist: keyring (==25.1.0)
 Requires-Dist: keyrings.cryptfile (==1.3.9) ; extra == "legacy-keyring"
 Requires-Dist: lxml (==5.2.2) ; extra == "dev"
 Requires-Dist: miniupnpc (==2.2.2) ; extra == "upnp"

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

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -10,7 +9,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, launch_start_daemon
+from chia.cmds.start_funcs import create_start_daemon_connection
 
 
 @pytest.mark.anyio
@@ -53,20 +52,6 @@ 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.3 → chia_blockchain-2.4.3b1}/chia/_tests/core/data_layer/test_data_rpc.py

@@ -5,7 +5,6 @@ import contextlib
 import copy
 import enum
 import json
-import logging
 import os
 import random
 import sqlite3
@@ -15,7 +14,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, Set, Tuple, cast
+from typing import Any, AsyncIterator, Dict, List, Optional, Tuple, cast
 
 import anyio
 import pytest
@@ -2240,16 +2239,6 @@ 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
@@ -2277,8 +2266,6 @@ 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")
@@ -3725,90 +3712,3 @@ 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.3 → chia_blockchain-2.4.3b1}/chia/_tests/core/data_layer/test_data_store.py

@@ -1357,7 +1357,7 @@ async def test_server_http_ban(
         filename: str,
         proxy_url: str,
         server_info: ServerInfo,
-        timeout: aiohttp.ClientTimeout,
+        timeout: int,
         log: logging.Logger,
     ) -> None:
         if error:
@@ -1373,7 +1373,7 @@ async def test_server_http_ban(
             root_hashes=[bytes32.random(seeded_random)],
             server_info=sinfo,
             client_foldername=tmp_path,
-            timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
+            timeout=15,
             log=log,
             proxy_url="",
             downloader=None,
@@ -1396,7 +1396,7 @@ async def test_server_http_ban(
             root_hashes=[bytes32.random(seeded_random)],
             server_info=sinfo,
             client_foldername=tmp_path,
-            timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
+            timeout=15,
             log=log,
             proxy_url="",
             downloader=None,
@@ -1903,7 +1903,7 @@ async def test_insert_from_delta_file_correct_file_exists(
         root_hashes=root_hashes,
         server_info=sinfo,
         client_foldername=tmp_path,
-        timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
+        timeout=15,
         log=log,
         proxy_url="",
         downloader=None,
@@ -1962,7 +1962,7 @@ async def test_insert_from_delta_file_incorrect_file_exists(
         root_hashes=[incorrect_root_hash],
         server_info=sinfo,
         client_foldername=tmp_path,
-        timeout=aiohttp.ClientTimeout(total=15, sock_connect=5),
+        timeout=15,
         log=log,
         proxy_url="",
         downloader=None,

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/chia/_tests/core/test_full_node_rpc.py

@@ -7,7 +7,6 @@ import pytest
 from chia_rs import AugSchemeMPL
 from clvm.casts import int_to_bytes
 
-from chia import __version__
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.conftest import ConsensusMode
 from chia._tests.connection_utils import connect_and_get_peer
@@ -578,23 +577,6 @@ async def test_get_network_info(one_wallet_and_one_simulator_services, self_host
         }
 
 
-@pytest.mark.anyio
-async def test_get_version(one_wallet_and_one_simulator_services, self_hostname):
-    nodes, _, bt = one_wallet_and_one_simulator_services
-    (full_node_service_1,) = nodes
-    async with FullNodeRpcClient.create_as_context(
-        self_hostname,
-        full_node_service_1.rpc_server.listen_port,
-        full_node_service_1.root_path,
-        full_node_service_1.config,
-    ) as client:
-        version = await client.fetch("get_version", {})
-        assert version == {
-            "success": True,
-            "version": __version__,
-        }
-
-
 @pytest.mark.anyio
 async def test_get_blockchain_state(one_wallet_and_one_simulator_services, self_hostname):
     num_blocks = 5

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/chia/_tests/farmer_harvester/test_farmer.py

@@ -6,14 +6,12 @@ from dataclasses import dataclass
 from time import time
 from types import TracebackType
 from typing import Any, Dict, List, Optional, Tuple, Type, Union, cast
-from unittest.mock import ANY
 
 import pytest
 from chia_rs import AugSchemeMPL, G1Element, G2Element, PrivateKey
 from pytest_mock import MockerFixture
 from yarl import URL
 
-from chia import __version__
 from chia._tests.conftest import HarvesterFarmerEnvironment
 from chia._tests.util.misc import DataCase, Marks, datacases
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -87,11 +85,9 @@ class IncrementPoolStatsCase:
 class DummyHarvesterPeer:
     return_invalid_response: bool
     peer_node_id: bytes32 = std_hash(b"1")
-    version: str
 
-    def __init__(self, return_invalid_response: bool = False, version: str = "1.0.0"):
-        self.return_invalid_response = return_invalid_response
-        self.version = version
+    def __init__(self, return_valid_response: bool):
+        self.return_invalid_response = return_valid_response
 
     async def send_message(self, arg1: Any) -> None:
         pass
@@ -1205,59 +1201,3 @@ async def test_farmer_pool_info_config_update(
     assert len(config["pool"]["pool_list"]) == 1
     assert config["pool"]["pool_list"][0]["p2_singleton_puzzle_hash"] == p2_singleton_puzzle_hash.hex()
     assert config["pool"]["pool_list"][0]["pool_url"] == case.expected_pool_url_in_config
-
-
-@dataclass
-class PartialSubmitHeaderCase(DataCase):
-    _id: str
-    harvester_peer: DummyHarvesterPeer
-    expected_headers: Dict[str, str]
-    marks: Marks = ()
-
-    @property
-    def id(self) -> str:
-        return self._id
-
-
-@datacases(
-    PartialSubmitHeaderCase(
-        "additional version headers",
-        harvester_peer=DummyHarvesterPeer(
-            version="1.2.3.asdf42",
-        ),
-        expected_headers={
-            "User-Agent": f"Chia Blockchain v.{__version__}",
-            "chia-farmer-version": __version__,
-            "chia-harvester-version": "1.2.3.asdf42",
-        },
-    ),
-)
-@pytest.mark.anyio
-async def test_farmer_additional_headers_on_partial_submit(
-    mocker: MockerFixture,
-    farmer_one_harvester: Tuple[List[HarvesterService], FarmerService, BlockTools],
-    case: PartialSubmitHeaderCase,
-) -> None:
-    _, farmer_service, _ = farmer_one_harvester
-    assert farmer_service.rpc_server is not None
-    farmer_api = farmer_service._api
-
-    sp, pos, new_pos = create_valid_pos(farmer_api.farmer)
-    assert pos.pool_contract_puzzle_hash is not None
-
-    assert (
-        verify_and_get_quality_string(
-            pos, DEFAULT_CONSTANTS, sp.challenge_hash, sp.challenge_chain_sp, height=uint32(1)
-        )
-        is not None
-    )
-
-    mock_http_post = mocker.patch(
-        "aiohttp.ClientSession.post",
-        return_value=DummyPoolResponse(True, 200, new_difficulty=123),
-    )
-
-    peer = cast(WSChiaConnection, case.harvester_peer)
-    await farmer_api.new_proof_of_space(new_pos, peer)
-
-    mock_http_post.assert_called_once_with(ANY, json=ANY, ssl=ANY, headers=case.expected_headers)

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/chia/_tests/pools/test_pool_rpc.py

@@ -438,11 +438,10 @@ class TestPoolWalletRpc:
             assert bal["confirmed_wallet_balance"] == 2 * 1_750_000_000_000
 
             # Claim 2 * 1.75, and farm a new 1.75
-            absorb_txs: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
-            await full_node_api.wait_transaction_records_entered_mempool(records=absorb_txs)
+            absorb_tx: TransactionRecord = (await client.pw_absorb_rewards(2, uint64(fee)))["transaction"]
+            await full_node_api.wait_transaction_records_entered_mempool(records=[absorb_tx])
             await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)
-            await full_node_api.check_transactions_confirmed(wallet_node.wallet_state_manager, absorb_txs)
             new_status: PoolWalletInfo = (await client.pw_status(2))[0]
             assert status.current == new_status.current
             assert status.tip_singleton_coin_id != new_status.tip_singleton_coin_id
@@ -450,9 +449,9 @@ class TestPoolWalletRpc:
             assert bal["confirmed_wallet_balance"] == 1 * 1_750_000_000_000
 
             # Claim another 1.75
-            absorb_txs1: List[TransactionRecord] = (await client.pw_absorb_rewards(2, uint64(fee)))["transactions"]
+            absorb_tx1: TransactionRecord = (await client.pw_absorb_rewards(2, uint64(fee)))["transaction"]
 
-            await full_node_api.wait_transaction_records_entered_mempool(records=absorb_txs1)
+            await full_node_api.wait_transaction_records_entered_mempool(records=[absorb_tx1])
 
             await full_node_api.farm_blocks_to_puzzlehash(count=2, farm_to=our_ph, guarantee_transaction_blocks=True)
             await full_node_api.wait_for_wallet_synced(wallet_node=wallet_node, timeout=20)

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/chia/_tests/util/rpc.py

@@ -16,7 +16,6 @@ async def validate_get_routes(client: RpcClient, api: RpcApiProtocol) -> None:
         "/close_connection",
         "/stop_node",
         "/get_routes",
-        "/get_version",
         "/healthz",
     ]
     assert len(routes_api) > 0

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

@@ -720,67 +720,3 @@ async def test_wallet_node_bad_coin_state_ignore(
 
     with pytest.raises(PeerRequestException):
         await wallet_node.get_coin_state([], wallet_node.get_full_node_peer())
-
-
-@pytest.mark.anyio
-@pytest.mark.standard_block_tools
-async def test_start_with_multiple_key_types(
-    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
-
-    pk: G1Element = await wallet_node.keychain_proxy.add_key(
-        "c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-        None,
-        private=False,
-    )
-    fingerprint_pk: int = pk.get_fingerprint()
-
-    await restart_with_fingerprint(fingerprint_pk)
-    assert wallet_node.wallet_state_manager.private_key is None
-    assert wallet_node.wallet_state_manager.root_pubkey == G1Element()
-
-    await wallet_node.keychain_proxy.delete_key_by_fingerprint(fingerprint_pk)
-
-    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.3 → chia_blockchain-2.4.3b1}/chia/cmds/start_funcs.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import os
-import shutil
 import subprocess
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -22,17 +21,8 @@ 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(
-        [cmd_to_execute, "run_daemon", "--wait-for-unlock"],
+        [sys.argv[0], "run_daemon", "--wait-for-unlock"],
         encoding="utf-8",
         stdout=subprocess.PIPE,
         creationflags=creationflags,
@@ -46,7 +36,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", flush=True)
+        print("Starting daemon")
         # launch a daemon
         process = launch_start_daemon(root_path)
         # give the daemon a chance to start up

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/chia/daemon/keychain_proxy.py

@@ -365,12 +365,7 @@ class KeychainProxy(DaemonProxy):
                             break
                     else:
                         raise KeychainKeyNotFound(fingerprint)
-                if private and selected_key.secrets is not None:
-                    key = selected_key.private_key
-                elif not private:
-                    key = selected_key.public_key
-                else:
-                    return None
+                key = selected_key.private_key if private else selected_key.public_key
         else:
             response, success = await self.get_response_for_request(
                 "get_key_for_fingerprint", {"fingerprint": fingerprint, "private": private}

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

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

{chia_blockchain-2.4.3 → chia_blockchain-2.4.3b1}/chia/data_layer/data_layer.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import dataclasses
-import functools
 import json
 import logging
 import os
@@ -125,9 +124,6 @@ class DataLayer:
     _wallet_rpc: Optional[WalletRpcClient] = None
     subscription_lock: asyncio.Lock = dataclasses.field(default_factory=asyncio.Lock)
     subscription_update_concurrency: int = 5
-    client_timeout: aiohttp.ClientTimeout = dataclasses.field(
-        default_factory=functools.partial(aiohttp.ClientTimeout, total=45, sock_connect=5)
-    )
 
     @property
     def server(self) -> ChiaServer:
@@ -189,9 +185,6 @@ class DataLayer:
             maximum_full_file_count=config.get("maximum_full_file_count", 1),
             subscription_update_concurrency=config.get("subscription_update_concurrency", 5),
             unsubscribe_data_queue=[],
-            client_timeout=aiohttp.ClientTimeout(
-                total=config.get("client_timeout", 45), sock_connect=config.get("connect_timeout", 5)
-            ),
         )
 
         self.db_path.parent.mkdir(parents=True, exist_ok=True)
@@ -593,6 +586,7 @@ class DataLayer:
                 max_generation=singleton_record.generation,
             )
             try:
+                timeout = self.config.get("client_timeout", 15)
                 proxy_url = self.config.get("proxy_url", None)
                 success = await insert_from_delta_file(
                     self.data_store,
@@ -601,7 +595,7 @@ class DataLayer:
                     [record.root for record in reversed(to_download)],
                     server_info,
                     self.server_files_location,
-                    self.client_timeout,
+                    timeout,
                     self.log,
                     proxy_url,
                     await self.get_downloader(store_id, url),
@@ -772,10 +766,6 @@ 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))
 
@@ -873,46 +863,22 @@ 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()
 
-            # 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 = []
+            # Subscribe to all local store_ids that we can find on chain.
+            local_store_ids = await self.data_store.get_store_ids()
             subscription_store_ids = {subscription.store_id for subscription in subscriptions}
-            for record in owned_stores:
-                store_id = record.launcher_id
-                if store_id not in subscription_store_ids:
+            for local_id in local_store_ids:
+                if local_id not in subscription_store_ids:
                     try:
-                        # don't actually subscribe, just add to the list
-                        subscriptions.insert(0, Subscription(store_id=store_id, servers_info=[]))
+                        subscription = await self.subscribe(local_id, [])
+                        subscriptions.insert(0, subscription)
                     except Exception as e:
                         self.log.info(
-                            f"Can't subscribe to owned store {store_id}: {type(e)} {e} {traceback.format_exc()}"
+                            f"Can't subscribe to locally stored {local_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",