mycelium-cli 0.1.0__py3-none-any.whl

mycelium_cli/commands/fund.py

@@ -0,0 +1,63 @@
+"""
+`mycelium fund` — top up a testnet wallet from Friendbot.
+
+Today funding only happens implicitly as a `mycelium deploy` side-effect when the
+wallet is empty. This makes it explicit: `mycelium fund` requests Friendbot
+lumens for the project wallet (or any --address) and polls until the funding
+lands on-chain. Friendbot is testnet-only; mainnet wallets must be funded out of
+band, so this refuses to run there.
+"""
+
+import json
+import os
+import sys
+from typing import Optional
+
+from mycelium_sdk.constants import normalize_network
+
+from mycelium_cli.config import get_value
+from mycelium_cli.commands.deploy import (
+    DEFAULT_WALLET_PATH,
+    _fund_with_friendbot,
+    _native_balance,
+)
+
+
+def _wallet_public_key(wallet_path: str) -> Optional[str]:
+    """Read the wallet's plaintext public key (no passphrase needed)."""
+    if not os.path.exists(wallet_path):
+        return None
+    with open(wallet_path, "r") as f:
+        return json.load(f).get("public_key")
+
+
+def run_fund(
+    address: Optional[str] = None,
+    network: Optional[str] = None,
+    wallet_path: str = DEFAULT_WALLET_PATH,
+) -> float:
+    """Fund `address` (or the project wallet) via Friendbot. Returns the new balance."""
+    network = normalize_network(network or get_value("onchain", "network", "testnet"))
+    if network != "testnet":
+        print("❌ Friendbot funding is testnet-only. Fund mainnet wallets manually.")
+        sys.exit(1)
+
+    public_key = address or _wallet_public_key(wallet_path)
+    if not public_key:
+        print(
+            f"Error: no address given and wallet {wallet_path} not found.\n"
+            "  Run `mycelium newwallet` first, or pass --address G..."
+        )
+        sys.exit(1)
+
+    balance = _native_balance(network, public_key)
+    print(f"[fund] {public_key} currently holds {balance} XLM on {network}.")
+    try:
+        _fund_with_friendbot(network, public_key)
+    except Exception as e:
+        print(f"❌ Funding failed: {e}")
+        sys.exit(1)
+
+    new_balance = _native_balance(network, public_key)
+    print(f"✓ Funded. Balance: {new_balance} XLM (+{new_balance - balance:.4f}).")
+    return new_balance

mycelium_cli/commands/init.py

@@ -0,0 +1,188 @@
+"""
+`mycelium init` — scaffold a new agent project per sdk.md section 1.1:
+
+    <project>/
+    ├── mycelium.toml      # project / agent / onchain / registry config
+    ├── agent.py           # outer LLM-orchestration logic
+    ├── contract.py        # inner Soroban contract (Mycelium DSL)
+    └── .mycelium/         # protected dir for the encrypted wallet (gitignored)
+"""
+
+import os
+import re
+
+import tomli_w
+
+from mycelium_sdk.constants import HIVEMIND_REGISTRY_ADDRESS
+
+UNIQUE_NAME_RE = re.compile(r"^[a-zA-Z0-9_]{3,30}$")
+VALID_FRAMEWORKS = ("langgraph", "gemini", "anthropic", "openai", "ollama", "custom")
+
+
+def validate_unique_name(name: str) -> bool:
+    return bool(UNIQUE_NAME_RE.match(name))
+
+
+# ── file templates ───────────────────────────────────────────────────────────
+_CONTRACT_TEMPLATE = '''"""Inner logic: a strictly-typed Mycelium → Soroban contract."""
+
+from mycelium import contract, external, view, Env, U64
+
+
+@contract
+class Counter:
+    def __init__(self, env: Env):
+        self.env = env
+        self.storage = env.storage()
+
+    @external
+    def increment(self) -> U64:
+        count = self.storage.get("count", U64(0))
+        count = count + U64(1)
+        self.storage.set("count", count)
+        return count
+
+    @view
+    def get_count(self) -> U64:
+        return self.storage.get("count", U64(0))
+'''
+
+
+# Frameworks that the one-call `run_agent_loop` helper drives directly.
+_AGENT_LOOP_PROVIDERS = {"gemini", "anthropic"}
+
+
+def _agent_loop_template(framework: str, model: str, unique_name: str, api_key_env: str) -> str:
+    """A complete agent in one call — run_agent_loop wires the {framework} loop."""
+    return f'''"""Outer logic: {framework}-orchestrated on-chain agent ({model})."""
+
+import os
+
+from mycelium import AgentContext, HiveClient, run_agent_loop, ContractTool
+
+# Sovereign on-chain execution context (loads .mycelium/wallet.json).
+context = AgentContext(keypair_path=".mycelium/wallet.json", network_type="testnet")
+hive = HiveClient(context)
+
+# Contract this agent is bound to (set by `mycelium run` / `mycelium agent --contract`).
+CONTRACT_ID = os.environ.get("MYCELIUM_CONTRACT_ID", "")
+# API key read from the environment (.env, gitignored, written by `mycelium init`).
+API_KEY = os.environ.get("{api_key_env}")
+
+
+def main():
+    print("Agent '{unique_name}' online as", context.keypair.public_key)
+    answer = run_agent_loop(
+        "You are an on-chain agent. Increment your counter contract, "
+        "then report the new value.",
+        context=context,
+        provider="{framework}",
+        model="{model}",
+        api_key=API_KEY,
+        contract_id=CONTRACT_ID,
+        tools=[
+            ContractTool("increment"),
+            ContractTool("get_count", read_only=True),
+        ],
+        hive=hive,  # exposes a lookup_partner_agent tool for Hive Registry discovery
+    )
+    print(answer)
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def _agent_template(framework: str, model: str, unique_name: str) -> str:
+    if framework in _AGENT_LOOP_PROVIDERS:
+        return _agent_loop_template(
+            framework, model, unique_name, _API_KEY_ENV.get(framework, "API_KEY")
+        )
+    return f'''"""Outer logic: AI orchestration ({framework} / {model})."""
+
+from mycelium import AgentContext
+
+# Sovereign on-chain execution context (loads .mycelium/wallet.json).
+context = AgentContext(keypair_path=".mycelium/wallet.json", network_type="testnet")
+
+
+def main():
+    print("Agent '{unique_name}' online as", context.keypair.public_key)
+    # TODO: wire your {framework} workflow here and expose contract calls
+    # via context.call_contract(...).
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+
+def _build_config(project_name: str, framework: str, model: str, unique_name: str) -> dict:
+    return {
+        "project": {"name": project_name, "version": "0.1.0", "author": "Developer"},
+        "agent": {"framework": framework, "model": model, "unique_name": unique_name},
+        "onchain": {
+            "source_contract": "contract.py",
+            "target_wasm": "build/contract.wasm",
+            "network": "testnet",
+            "contract_id": "",
+            "wallet_public_key": "",
+        },
+        "registry": {
+            "hive_registry_address": HIVEMIND_REGISTRY_ADDRESS,
+            "service_endpoint": f"https://{unique_name}.agents.mycelium.sh/api/v1",
+            "capabilities": [],
+        },
+    }
+
+
+# Maps an API framework to the env var its agent template reads the key from.
+_API_KEY_ENV = {"gemini": "GEMINI_API_KEY", "anthropic": "ANTHROPIC_API_KEY", "openai": "OPENAI_API_KEY"}
+
+
+def run_init(
+    project_name: str,
+    framework: str = "custom",
+    model: str = "custom",
+    unique_name: str | None = None,
+    api_key: str | None = None,
+) -> str:
+    """
+    Scaffold a project directory. Prompting for framework/model/unique_name is
+    handled by the CLI layer; this function takes resolved values so it can be
+    driven non-interactively (tests/CI). When `api_key` is given it is written
+    to a gitignored `.env` so the agent can authenticate without re-prompting.
+    Returns the project path.
+    """
+    if framework not in VALID_FRAMEWORKS:
+        raise ValueError(f"framework must be one of {VALID_FRAMEWORKS}, got {framework!r}")
+    unique_name = unique_name or project_name
+    if not validate_unique_name(unique_name):
+        raise ValueError(
+            f"unique_name {unique_name!r} must match ^[a-zA-Z0-9_]{{3,30}}$"
+        )
+
+    os.makedirs(project_name, exist_ok=True)
+    os.makedirs(os.path.join(project_name, ".mycelium"), exist_ok=True)
+
+    with open(os.path.join(project_name, "mycelium.toml"), "wb") as f:
+        tomli_w.dump(_build_config(project_name, framework, model, unique_name), f)
+    with open(os.path.join(project_name, "contract.py"), "w") as f:
+        f.write(_CONTRACT_TEMPLATE)
+    with open(os.path.join(project_name, "agent.py"), "w") as f:
+        f.write(_agent_template(framework, model, unique_name))
+    with open(os.path.join(project_name, ".gitignore"), "w") as f:
+        f.write(".mycelium/\nbuild/\n.env\n__pycache__/\n")
+
+    if api_key:
+        env_var = _API_KEY_ENV.get(framework, "API_KEY")
+        env_path = os.path.join(project_name, ".env")
+        with open(env_path, "w") as f:
+            f.write(f"{env_var}={api_key}\n")
+        try:
+            os.chmod(env_path, 0o600)
+        except OSError:
+            pass
+
+    return project_name

mycelium_cli/commands/newwallet.py

@@ -0,0 +1,61 @@
+"""
+`mycelium newwallet` — generate an encrypted Ed25519 wallet (sdk.md section 2.2).
+
+Generates a Stellar keypair, encrypts the secret seed with AES-GCM-256 (key
+derived from a passphrase via PBKDF2), and writes the payload to
+`.mycelium/wallet.json`. The plaintext seed is never written to disk.
+"""
+
+import json
+import os
+
+from mycelium_sdk import crypto
+
+DEFAULT_WALLET_PATH = os.path.join(".mycelium", "wallet.json")
+
+
+def run_newwallet(
+    path: str = DEFAULT_WALLET_PATH,
+    passphrase: str | None = None,
+    force: bool = False,
+) -> str:
+    """
+    Create an encrypted wallet at `path`. `passphrase` is resolved via
+    crypto.resolve_passphrase (explicit arg → MYCELIUM_DECRYPT_KEY). Refuses to
+    overwrite an existing wallet unless `force=True`. Returns the public key.
+    """
+    from stellar_sdk import Keypair
+
+    if os.path.exists(path) and not force:
+        raise FileExistsError(
+            f"A wallet already exists at {path}. Use --force to overwrite it "
+            "(this destroys the existing key)."
+        )
+
+    pw = crypto.resolve_passphrase(passphrase)
+    keypair = Keypair.random()
+    payload = {"public_key": keypair.public_key, **crypto.encrypt_secret(keypair.secret, pw)}
+
+    parent = os.path.dirname(path)
+    if parent:
+        os.makedirs(parent, mode=0o700, exist_ok=True)
+        try:  # exist_ok won't fix the mode of a pre-existing dir
+            os.chmod(parent, 0o700)
+        except OSError:
+            pass
+
+    # Create the file with 0600 from the start so the ciphertext is never
+    # world-readable, even for the instant between write and chmod.
+    try:
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "w") as f:
+            json.dump(payload, f, indent=2)
+    except (OSError, ValueError):  # platforms without full POSIX mode support
+        with open(path, "w") as f:
+            json.dump(payload, f, indent=2)
+        try:
+            os.chmod(path, 0o600)
+        except OSError:
+            pass
+
+    return keypair.public_key

mycelium_cli/commands/pay.py

@@ -0,0 +1,83 @@
+"""
+`mycelium pay <name|address> <amount>` — machine-to-machine XLM settlement.
+
+Wraps what a2a_demo.py does by hand: resolve the recipient (a Hive Registry
+unique name, or a raw G... address) to an address, then sign and submit a native
+XLM payment from the project wallet. Reputation/endpoint come from the registry
+so you can pay an agent by *name* without knowing its address.
+"""
+
+import os
+import sys
+from typing import Optional
+
+from mycelium_cli.config import get_value
+
+DEFAULT_WALLET_PATH = ".mycelium/wallet.json"
+
+
+def _resolve_recipient(recipient: str, network: str, registry: Optional[str]) -> str:
+    """Return a destination G-address for a name or a raw address."""
+    from stellar_sdk import StrKey
+
+    if StrKey.is_valid_ed25519_public_key(recipient):
+        return recipient
+
+    from mycelium_sdk import AgentContext, HiveClient
+
+    print(f"[pay] Resolving '{recipient}' via Hive Registry...")
+    ro = AgentContext.read_only(network_type=network)
+    entry = HiveClient(ro, registry_address=registry).resolve_agent(recipient)
+    dest = entry.get("public_key")
+    if not dest:
+        print(f"❌ '{recipient}' resolved to no address.")
+        sys.exit(1)
+    print(f"[pay] '{recipient}' -> {dest}")
+    return dest
+
+
+def run_pay(
+    recipient: str,
+    amount: str,
+    network: Optional[str] = None,
+    wallet_path: str = DEFAULT_WALLET_PATH,
+    passphrase: Optional[str] = None,
+) -> str:
+    from stellar_sdk import Asset, TransactionBuilder
+
+    from mycelium_sdk import AgentContext
+    from mycelium_sdk.constants import HIVEMIND_REGISTRY_ADDRESS
+
+    network = network or get_value("onchain", "network", "testnet")
+    registry = get_value("registry", "hive_registry_address") or HIVEMIND_REGISTRY_ADDRESS
+
+    if not os.path.exists(wallet_path):
+        print(f"Error: wallet {wallet_path} not found. Run `mycelium newwallet` first.")
+        sys.exit(1)
+
+    dest = _resolve_recipient(recipient, network, registry)
+
+    context = AgentContext(keypair_path=wallet_path, network_type=network, passphrase=passphrase)
+    print(f"[pay] Sending {amount} XLM to {dest} as {context.keypair.public_key}...")
+
+    try:
+        source = context.horizon_server.load_account(context.keypair.public_key)
+        tx = (
+            TransactionBuilder(source, context.network_passphrase, base_fee=100)
+            .append_payment_op(destination=dest, asset=Asset.native(), amount=str(amount))
+            .set_timeout(60)
+            .build()
+        )
+        tx.sign(context.keypair)
+        resp = context.horizon_server.submit_transaction(tx)
+    except Exception as e:
+        print(f"❌ Payment failed: {e}")
+        sys.exit(1)
+
+    if not resp.get("successful", False):
+        print(f"❌ Payment rejected: {resp.get('result_xdr')}")
+        sys.exit(1)
+
+    tx_hash = resp["hash"]
+    print(f"✓ Paid {amount} XLM to {recipient}. Tx: {tx_hash}")
+    return tx_hash

mycelium_cli/commands/register.py

@@ -0,0 +1,59 @@
+"""
+`mycelium register` — register the agent's unique name on the Hive Registry
+(sdk.md section 2.5).
+
+Reads the agent metadata from mycelium.toml, builds an AgentContext from the
+local wallet, and invokes `register_agent` on the registry contract. The
+registry address comes from `[registry].hive_registry_address` (falling back to
+the SDK default). If that address is not a deployed registry, the on-chain call
+fails loudly — no fabricated success.
+"""
+
+import os
+import sys
+
+DEFAULT_WALLET_PATH = os.path.join(".mycelium", "wallet.json")
+
+
+def run_register(
+    network: str | None = None,
+    wallet_path: str = DEFAULT_WALLET_PATH,
+    passphrase: str | None = None,
+) -> str:
+    from mycelium_sdk import AgentContext, HiveClient
+
+    from mycelium_cli.config import get_value
+
+    unique_name = get_value("agent", "unique_name")
+    if not unique_name:
+        print("Error: [agent].unique_name missing from mycelium.toml.")
+        sys.exit(1)
+    endpoint = get_value("registry", "service_endpoint", "")
+    capabilities = get_value("registry", "capabilities", []) or []
+    registry_address = get_value("registry", "hive_registry_address")
+    network = network or get_value("onchain", "network", "testnet")
+    model = get_value("agent", "model", "custom")
+    role = get_value("agent", "role", "Autonomous Agent")
+    description = get_value("agent", "description", "Custom on-chain agent resolved from Hive Registry.")
+
+    if not os.path.exists(wallet_path):
+        print(f"Error: wallet {wallet_path} not found. Run `mycelium newwallet` first.")
+        sys.exit(1)
+
+    context = AgentContext(keypair_path=wallet_path, network_type=network, passphrase=passphrase)
+    hive = HiveClient(context, registry_address=registry_address)
+
+    print(f"[register] Registering '{unique_name}' on registry {hive.registry_address}...")
+    try:
+        result = hive.register(unique_name, capabilities, endpoint, model=model, role=role, desc=description)
+    except Exception as e:
+        m = str(e).lower()
+        if "nametaken" in m or ("name" in m and ("taken" in m or "collision" in m or "exists" in m)):
+            print(f"❌ Registration failed: the name '{unique_name}' is already taken.")
+        else:
+            print(f"❌ Registration failed: {e}")
+        sys.exit(1)
+
+    tx_hash = getattr(result, "hash", str(result))
+    print(f"✓ Registered '{unique_name}'. Tx: {tx_hash}")
+    return tx_hash

mycelium_cli/commands/resolve.py

@@ -0,0 +1,54 @@
+"""
+`mycelium resolve <name>` — look up a single agent in the Hive Registry.
+
+Read-only and wallet-free: resolves a unique agent name to its on-chain
+directory entry (address, capability hash, endpoint, reputation).
+"""
+
+import sys
+from typing import Optional
+
+# The HiveRegistry contract reverts with ContractError.NOT_REGISTERED (code 2)
+# when a name has never been registered.
+_NOT_REGISTERED_MARKERS = ("contract, #2)", "not registered", "notregistered", "keyerror")
+
+
+def _is_not_registered(error: Exception) -> bool:
+    m = str(error).lower()
+    return any(marker in m for marker in _NOT_REGISTERED_MARKERS)
+
+
+def run_resolve(
+    name: str,
+    network: Optional[str] = None,
+    registry: Optional[str] = None,
+) -> dict:
+    from mycelium_sdk import AgentContext, HiveClient
+    from mycelium_sdk.constants import HIVEMIND_REGISTRY_ADDRESS
+
+    from mycelium_cli.config import get_value
+
+    network = network or get_value("onchain", "network", "testnet")
+    registry = registry or get_value("registry", "hive_registry_address") or HIVEMIND_REGISTRY_ADDRESS
+
+    context = AgentContext.read_only(network_type=network)
+    hive = HiveClient(context, registry_address=registry)
+
+    print(f"[resolve] Looking up '{name}' on registry {registry} ({network})...")
+    try:
+        entry = hive.resolve_agent(name)
+    except Exception as e:
+        if _is_not_registered(e):
+            print(f"❌ '{name}' is not registered in the Hive Registry.")
+        else:
+            print(f"❌ Resolution failed: {e}")
+        sys.exit(1)
+
+    cap = entry.get("capability_hash")
+    cap_str = cap.hex() if isinstance(cap, (bytes, bytearray)) else (cap or "—")
+    print(f"\n✓ {name}")
+    print(f"  address     : {entry.get('public_key') or '—'}")
+    print(f"  endpoint    : {entry.get('endpoint') or '—'}")
+    print(f"  reputation  : {entry.get('reputation', 0)}")
+    print(f"  capability  : {cap_str}\n")
+    return entry

mycelium_cli/commands/run.py

@@ -0,0 +1,33 @@
+"""
+`mycelium run` — run the project's agent with config auto-wired.
+
+A convenience alias for `mycelium agent`: instead of passing
+`--contract C...` by hand, it reads `[onchain].contract_id` (and the agent
+script, defaulting to agent.py) from mycelium.toml. The network is exported as
+`MYCELIUM_NETWORK` so the runtime can pick it up.
+"""
+
+import os
+import sys
+from typing import Optional
+
+from mycelium_cli.config import get_value
+from mycelium_cli.commands.agent import run_agent
+
+
+def run_run(file: Optional[str] = None, contract: Optional[str] = None) -> None:
+    file = file or get_value("agent", "script", "agent.py")
+    contract = contract or get_value("onchain", "contract_id") or ""
+    network = get_value("onchain", "network", "testnet")
+
+    if not os.path.exists(file):
+        print(f"Error: agent script {file} not found. Pass it explicitly or run from the project dir.")
+        sys.exit(1)
+    if not contract:
+        print(
+            "Warning: no [onchain].contract_id in mycelium.toml — running unbound.\n"
+            "  Deploy first with `mycelium deploy`, or pass --contract C..."
+        )
+
+    os.environ.setdefault("MYCELIUM_NETWORK", network)
+    run_agent(file, contract)

mycelium_cli/commands/status.py

@@ -0,0 +1,127 @@
+"""
+`mycelium status` — the "am I set up correctly?" command.
+
+One screen that answers, for the current project: which wallet am I, how much
+XLM do I hold, on which network, is my contract deployed, and am I registered in
+the Hive Registry (with what reputation). Everything here is read-only and
+wallet-free — it never prompts for a passphrase or spends a fee.
+"""
+
+import json
+import os
+import sys
+from typing import Optional
+
+from mycelium_cli.config import get_value, load_config
+
+DEFAULT_WALLET_PATH = os.path.join(".mycelium", "wallet.json")
+
+_OK = "✓"
+_NO = "✗"
+
+
+def _wallet_public_key(wallet_path: str) -> Optional[str]:
+    if not os.path.exists(wallet_path):
+        return None
+    try:
+        with open(wallet_path, "r") as f:
+            return json.load(f).get("public_key")
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _safe_balance(network: str, public_key: str) -> Optional[float]:
+    try:
+        from mycelium_cli.commands.deploy import _native_balance
+
+        return _native_balance(network, public_key)
+    except Exception:
+        return None
+
+
+def _registry_entry(network: str, registry: Optional[str], name: str) -> Optional[dict]:
+    """Resolve `name` in the registry, returning the entry or None if unregistered."""
+    try:
+        from mycelium_sdk import AgentContext, HiveClient
+
+        context = AgentContext.read_only(network_type=network)
+        hive = HiveClient(context, registry_address=registry)
+        return hive.resolve_agent(name)
+    except Exception:
+        return None
+
+
+def run_status(
+    network: Optional[str] = None,
+    wallet_path: str = DEFAULT_WALLET_PATH,
+) -> dict:
+    try:
+        load_config()
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+    from mycelium_sdk.constants import HIVEMIND_REGISTRY_ADDRESS
+
+    project = get_value("project", "name", "—")
+    unique_name = get_value("agent", "unique_name")
+    framework = get_value("agent", "framework", "—")
+    network = network or get_value("onchain", "network", "testnet")
+    contract_id = get_value("onchain", "contract_id") or ""
+    registry = get_value("registry", "hive_registry_address") or HIVEMIND_REGISTRY_ADDRESS
+
+    public_key = _wallet_public_key(wallet_path)
+    balance = _safe_balance(network, public_key) if public_key else None
+    entry = _registry_entry(network, registry, unique_name) if unique_name else None
+
+    print(f"\nMycelium status — project '{project}' ({framework})\n")
+
+    # Wallet + funding.
+    if public_key:
+        bal_str = f"{balance} XLM" if balance is not None else "unknown (RPC unreachable)"
+        funded = balance is not None and balance > 0
+        print(f"  {_OK} wallet      {public_key}")
+        print(f"  {_OK if funded else _NO} balance     {bal_str}")
+    else:
+        print(f"  {_NO} wallet      not found — run `mycelium newwallet`")
+        print(f"  {_NO} balance     —")
+
+    print(f"  •  network     {network}")
+
+    # Deploy state.
+    if contract_id:
+        print(f"  {_OK} contract    {contract_id}")
+    else:
+        print(f"  {_NO} contract    not deployed — run `mycelium deploy`")
+
+    # Registry registration.
+    if not unique_name:
+        print(f"  {_NO} registry    no [agent].unique_name in mycelium.toml")
+    elif entry and entry.get("public_key"):
+        rep = entry.get("reputation", 0)
+        print(f"  {_OK} registry    '{unique_name}' registered (reputation {rep})")
+        if entry.get("endpoint"):
+            print(f"               endpoint {entry['endpoint']}")
+    else:
+        print(f"  {_NO} registry    '{unique_name}' not registered — run `mycelium register`")
+
+    # One-line "what next?" nudge.
+    if not public_key:
+        nxt = "mycelium newwallet"
+    elif not balance:
+        nxt = "mycelium fund"
+    elif not contract_id:
+        nxt = "mycelium compile && mycelium deploy"
+    elif not (entry and entry.get("public_key")):
+        nxt = "mycelium register"
+    else:
+        nxt = None
+    print(f"\n  Next: {nxt}\n" if nxt else "\n  Everything is set up. 🍄\n")
+
+    return {
+        "public_key": public_key,
+        "balance": balance,
+        "network": network,
+        "contract_id": contract_id,
+        "registered": bool(entry and entry.get("public_key")),
+    }