feat: add (Async)Arkiv constructor option to also accept a LocalAccount

Author: Matthias Zimmermann

src/arkiv/account.py

@@ -35,8 +35,8 @@ def __init__(self, name: str, account: LocalAccount):
             name: Human-readable name for the account
             account: The LocalAccount instance to wrap
         """
-        self.name = self._check_and_trim(name)
-        self._account = account
+        self.name: str = self._check_and_trim(name)
+        self._account: LocalAccount = account
 
     def __repr__(self) -> str:
         """String representation showing name and address."""

src/arkiv/client.py

@@ -5,6 +5,7 @@
 import logging
 from typing import Any, cast
 
+from eth_account.signers.local import LocalAccount
 from web3 import AsyncWeb3, Web3
 from web3.middleware import SignAndSendRawMiddlewareBuilder
 from web3.providers import WebSocketProvider
@@ -31,7 +32,7 @@ class Arkiv(ArkivBase, Web3):
     def __init__(
         self,
         provider: BaseProvider | None = None,
-        account: NamedAccount | None = None,
+        account: NamedAccount | LocalAccount | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize Arkiv client with Web3 provider.
@@ -167,7 +168,7 @@ class AsyncArkiv(ArkivBase, AsyncWeb3):
     def __init__(
         self,
         provider: AsyncBaseProvider | None = None,
-        account: NamedAccount | None = None,
+        account: NamedAccount | LocalAccount | None = None,
         **kwargs: Any,
     ) -> None:
         """Initialize AsyncArkiv client with async Web3 provider.

src/arkiv/client_base.py

@@ -5,6 +5,7 @@
 import logging
 from typing import TYPE_CHECKING, Any, Literal
 
+from eth_account.signers.local import LocalAccount
 from web3.providers.async_base import AsyncBaseProvider
 from web3.providers.base import BaseProvider
 
@@ -93,27 +94,10 @@ def _create_managed_node_and_provider(
 
         return node, provider
 
-    @staticmethod
-    def _create_default_account(account_name: str = "default") -> NamedAccount:
-        """
-        Create a default named account for local node prototyping.
-
-        Used by both Arkiv (sync) and AsyncArkiv (async) when no account is provided
-        and a local node is auto-created.
-
-        Args:
-            account_name: Name for the account (default: "default")
-
-        Returns:
-            NamedAccount with the specified name
-        """
-        logger.info(f"Creating default account '{account_name}' for local node...")
-        return NamedAccount.create(account_name)
-
     def _setup_node_and_account(
         self,
         provider: Any | None,
-        account: NamedAccount | None,
+        account: NamedAccount | LocalAccount | None,
         transport: Literal["http", "ws"],
     ) -> tuple[ArkivNode | None, Any, NamedAccount | None]:
         """
@@ -133,7 +117,17 @@ def _setup_node_and_account(
 
             # Create default account if none provided (for local node prototyping)
             if account is None:
-                account = self._create_default_account()
+                logger.debug(
+                    f"Creating default account '{self.ACCOUNT_NAME_DEFAULT}' for local node..."
+                )
+                account = NamedAccount.create(self.ACCOUNT_NAME_DEFAULT)
+
+        # If account is a LocalAccount, wrap it in NamedAccount with default name
+        if isinstance(account, LocalAccount):
+            logger.debug(
+                f"Wrapping provided LocalAccount in NamedAccount with name '{self.ACCOUNT_NAME_DEFAULT}'"
+            )
+            account = NamedAccount(self.ACCOUNT_NAME_DEFAULT, account)
 
         return node, provider, account
 

tests/test_arkiv_create.py

@@ -54,6 +54,65 @@ def test_create_arkiv_with_account(self, arkiv_node) -> None:
         _assert_arkiv_client_properties(client, account, "With Account")
         logger.info("Created Arkiv client with default account")
 
+    def test_create_arkiv_with_local_account(self, arkiv_node) -> None:
+        """Test creating Arkiv client with LocalAccount (gets wrapped in NamedAccount)."""
+        from eth_account import Account
+
+        provider = HTTPProvider(arkiv_node.http_url)
+        local_account = Account.create()
+        client = Arkiv(provider, account=local_account)
+
+        # LocalAccount should be wrapped in NamedAccount with default name
+        assert len(client.accounts) == 1, "Should have one account registered"
+        assert "default" in client.accounts, (
+            "LocalAccount should be wrapped with 'default' name"
+        )
+        assert client.current_signer == "default", "Should use 'default' as signer name"
+        assert client.eth.default_account == local_account.address, (
+            "Should set default account to LocalAccount address"
+        )
+        assert client.accounts["default"].address == local_account.address, (
+            "Wrapped account should have same address as original LocalAccount"
+        )
+
+        logger.info("Created Arkiv client with LocalAccount (wrapped in NamedAccount)")
+
+    def test_create_arkiv_with_local_account_then_add_named_default(
+        self, arkiv_node
+    ) -> None:
+        """Test that adding another 'default' named account overwrites the wrapped LocalAccount."""
+        from eth_account import Account
+
+        provider = HTTPProvider(arkiv_node.http_url)
+        local_account = Account.create()
+        client = Arkiv(provider, account=local_account)
+
+        # LocalAccount wrapped as "default"
+        original_address = client.accounts["default"].address
+        assert original_address == local_account.address
+
+        # Now manually add another account also named "default"
+        new_account = NamedAccount.create("default")
+        client.accounts["default"] = new_account
+
+        # The new account should overwrite the old one
+        assert len(client.accounts) == 1, "Should still have one account"
+        assert client.accounts["default"].address == new_account.address, (
+            "New account should replace the wrapped LocalAccount"
+        )
+        assert client.accounts["default"].address != original_address, (
+            "Address should be different from original"
+        )
+
+        # Switch to the new account
+        client.switch_to("default")
+        assert client.current_signer == "default"
+        assert client.eth.default_account == new_account.address
+
+        logger.info(
+            "Successfully replaced wrapped LocalAccount with new 'default' named account"
+        )
+
     def test_create_arkiv_with_kwargs(self, arkiv_node) -> None:
         """Test creating Arkiv client with additional kwargs."""
         provider = HTTPProvider(arkiv_node.http_url)

tests/test_async_arkiv_create.py

@@ -41,6 +41,71 @@ async def test_create_asyncarkiv_with_account(self, arkiv_node) -> None:
             await _assert_asyncarkiv_client_properties(client, account, "With Account")
             logger.info("Created AsyncArkiv client with default account")
 
+    @pytest.mark.asyncio
+    async def test_create_asyncarkiv_with_local_account(self, arkiv_node) -> None:
+        """Test creating AsyncArkiv client with LocalAccount (gets wrapped in NamedAccount)."""
+        from eth_account import Account
+
+        provider = ProviderBuilder().node(arkiv_node).async_mode().build()
+        local_account = Account.create()
+
+        async with AsyncArkiv(provider, account=local_account) as client:
+            # LocalAccount should be wrapped in NamedAccount with default name
+            assert len(client.accounts) == 1, "Should have one account registered"
+            assert "default" in client.accounts, (
+                "LocalAccount should be wrapped with 'default' name"
+            )
+            assert client.current_signer == "default", (
+                "Should use 'default' as signer name"
+            )
+            assert client.eth.default_account == local_account.address, (
+                "Should set default account to LocalAccount address"
+            )
+            assert client.accounts["default"].address == local_account.address, (
+                "Wrapped account should have same address as original LocalAccount"
+            )
+
+            logger.info(
+                "Created AsyncArkiv client with LocalAccount (wrapped in NamedAccount)"
+            )
+
+    @pytest.mark.asyncio
+    async def test_create_asyncarkiv_with_local_account_then_add_named_default(
+        self, arkiv_node
+    ) -> None:
+        """Test that adding another 'default' named account overwrites the wrapped LocalAccount."""
+        from eth_account import Account
+
+        provider = ProviderBuilder().node(arkiv_node).async_mode().build()
+        local_account = Account.create()
+
+        async with AsyncArkiv(provider, account=local_account) as client:
+            # LocalAccount wrapped as "default"
+            original_address = client.accounts["default"].address
+            assert original_address == local_account.address
+
+            # Now manually add another account also named "default"
+            new_account = NamedAccount.create("default")
+            client.accounts["default"] = new_account
+
+            # The new account should overwrite the old one
+            assert len(client.accounts) == 1, "Should still have one account"
+            assert client.accounts["default"].address == new_account.address, (
+                "New account should replace the wrapped LocalAccount"
+            )
+            assert client.accounts["default"].address != original_address, (
+                "Address should be different from original"
+            )
+
+            # Switch to the new account
+            client.switch_to("default")
+            assert client.current_signer == "default"
+            assert client.eth.default_account == new_account.address
+
+            logger.info(
+                "Successfully replaced wrapped LocalAccount with new 'default' named account"
+            )
+
     @pytest.mark.asyncio
     async def test_create_asyncarkiv_with_kwargs(self, arkiv_node) -> None:
         """Test creating AsyncArkiv client with additional kwargs."""