api: Remove unused public entry points

core_descriptors(private=False) asked a named Bitcoin Core wallet for its
HD key and built public descriptors from it, but only type-checked the
seed it was given, so a wallet holding a different seed returned that
wallet's descriptors. Nothing calls it: ms32 wallet hands Core the root
xprv with addhdkey and Core builds the descriptors itself with
createwalletdescriptor, and Core's listdescriptors and
exportwatchonlywallet already provide public descriptors.

We are pre-1.0, so delete public API that no command or tool calls
instead of maintaining it:

- core_descriptors, the WalletPublicDeriver protocol, the descriptor
  checksum (DESCSUM) and record helpers, and the Core adapter's
  public_descriptors, gethdkeys and derivehdkey calls;
- generate_core_lightning_secret and CreationCeremony.core_lightning,
  which created fresh Core Lightning secrets that no command creates.
  Parsing, recovering, deriving and re-sharing an existing cl secret
  are unchanged.

The real-Core fixture and installed-wheel smoke test now check xprv and
tprv serialization through master_xprv. The package exports 22 names.
The installed package drops from 5,092 to 4,868 logical lines.

Fixes #128
Refs #63

Claude-Session: https://claude.ai/code/session_01T233rKgZqE5wzDm3EVTHL1

Author: claude

docs/developer/api.md

@@ -67,13 +67,13 @@ generic parse-length failure.
   `.text` attribute.
 - Sharing interpolates payload and checksum together, explicitly constructs the
   target header, and reparses the result.
-- `generation.py` is the only entropy owner and generates only `ms` and `cl`.
+- `generation.py` is the only entropy owner and generates only `ms`; it can
+  also share an existing `cl` secret.
 - Correction never edits the HRP or separator and reparses every candidate.
 - `_bip32.py` stops at HMAC-SHA512 root derivation, scalar validity, and root
   xprv/tprv Base58Check serialization. It performs no child derivation or
-  secp256k1 point arithmetic. `wallet.py` accepts only `MasterSeed`; EC-dependent
-  public derivation is supplied through an explicit wallet integration and the
-  CLI uses Bitcoin Core for that boundary.
+  secp256k1 point arithmetic. `wallet.py` accepts only `MasterSeed`; Bitcoin
+  Core performs all EC-dependent derivation.
 - `_cli_input.py` retains at most nine artifacts and delegates partial-set
   compatibility to `bip93.py`. Card confirmation clears the terminal and saved
   scrollback where supported, then displays only entered text after a mismatch.
@@ -100,7 +100,7 @@ generic parse-length failure.
   hidden state.
 
 Private Python names are convention rather than access control. The supported
-surface is the 25-name package `__all__`; direct use of private helpers is
+surface is the 22-name package `__all__`; direct use of private helpers is
 unsupported but remains in the review scope.
 
 ### Size budget
@@ -154,39 +154,37 @@ recovery, and share derivation. The `ms32` façade accepts only `ms` artifacts.
 ## Secret generation
 
 `generation.py` is the only module that draws entropy. It generates BIP93
-master seeds and Core Lightning HSM secrets, and splits either validated S type.
+master seeds and splits a validated master seed or Core Lightning HSM secret.
 Core Lightning now defaults to mnemonic recovery, but retains a codex32 HSM
 secret import path for recovery on an unused node.
 
 Fresh unshared seeds default to 16 bytes and use the first 20 bits of their
 BIP32 fingerprint as public identifier metadata. Fresh shared sets use four
-independent random u5 identifier symbols. Raw bytes, re-shared secrets, and CL
-generation also use an independent random identifier unless one is supplied.
+independent random u5 identifier symbols. Raw bytes and re-shared secrets also
+use an independent random identifier unless one is supplied.
 Random re-sharing never repeats the source set header; an explicitly repeated
 source header is rejected.
 
 The Python API and CLI accept the six PR #2258 `ms` sizes: 16, 20, 24, 28, 32,
 and 64 bytes. Other byte lengths are rejected at every public construction
 boundary; there is no legacy decoder.
 
-One-shot functions create only unshared secrets:
+The one-shot function creates only unshared secrets:
 
 ```python
 generate_master_seed(seed_bytes=None, *, byte_length=None, identifier=None)
-generate_core_lightning_secret(secret_bytes=None, *, identifier=None)
 ```
 
-Shared creation uses `CreationCeremony.master_seed(...)`,
-`CreationCeremony.core_lightning(...)`, or
+Shared creation uses `CreationCeremony.master_seed(...)` or
 `CreationCeremony.from_secret(...)`. Exactly one of `share_count` and `indices`
 is required. `next_share()` returns one pending share, `confirm(text)` must
 accept its independently re-entered string, and `finish()` returns the secret
 only after every requested share is confirmed. There is no public one-shot
 sharing or `split_secret` function. Fresh and existing Bitcoin CLI creation
 requires interactive input and output, preflights local Bitcoin Core before
 entropy or recovery input, and initializes a user-selected wallet after every
-share is confirmed. CLI creation does not accept Core Lightning profiles; CL
-generation and sharing remain API-only.
+share is confirmed. CLI creation does not accept Core Lightning profiles; sharing
+an existing CL secret remains API-only.
 Without `--existing`, omitting the Bitcoin header creates an unshared master
 seed. With `--existing` and no sharing threshold, a supplied codex32 secret is
 emitted and confirmed unchanged, and the original validated artifact initializes
@@ -580,27 +578,17 @@ Public wallet operations accept only a validated `MasterSeed`. `wallet.py` is
 stateless and never accepts shares, Core Lightning secrets, BIP39 migration
 artifacts, or raw bytes.
 
-The public adapter has two functions:
-
-- `master_xprv(secret, testnet=False)` returns the BIP32 root extended private
-  key.
-- `core_descriptors(...)` returns fixed BIP44, BIP49, BIP84, and BIP86 Bitcoin
-  Core `importdescriptors` records. Private records use stdlib-only root xprv
-  serialization; public records require an explicit wallet integration and the
-  Core wallet whose imported root key will perform hardened derivation.
+The public adapter has one function: `master_xprv(secret, testnet=False)`
+returns the BIP32 root extended private key, using stdlib-only serialization.
+It grants authority over every key derived from the seed, and the CLI warns
+before printing it.
 
 No installed Python dependency performs secp256k1 operations. The private
 Bitcoin Core adapter gives Core the root xprv over stdin and asks Core to
-create the four standard account-0 descriptor types. Public descriptor
-derivation remains available through the explicit integration API.
-
-Public descriptors contain account xpubs. Private descriptors intentionally
-follow Bitcoin Core's root-key form: they contain the root xprv followed by the
-complete derivation path. They therefore grant authority over the entire root,
-not only the selected account. The CLI warns before printing them.
+create the four standard account-0 descriptor types. Core's own wallet
+commands provide public descriptors and watch-only exports.
 
-Account, private/public mode, network serialization, and timestamp are explicit
-API inputs. The `ms32 wallet` CLI takes `--account 0` and `--timestamp`; the
+The `ms32 wallet` CLI takes `--account 0` and `--timestamp`; the
 selected Bitcoin Core chain is authoritative and there is no wallet
 `--testnet` flag. `ms32 xprv --testnet` remains explicit because it directly
 selects xprv versus tprv serialization. The timestamp defaults to `0` so
@@ -647,7 +635,7 @@ the BIP32 fingerprint.
 
 The Core calls are fixed: `getnetworkinfo`, `getblockchaininfo`, `listwallets`,
 `getwalletinfo`, `listdescriptors`, `getdescriptorinfo`, `deriveaddresses`,
-`validateaddress`, `gethdkeys`, `derivehdkey`, `addhdkey`,
+`validateaddress`, `addhdkey`,
 `createwalletdescriptor`, `importdescriptors`, and `walletlock`.
 Bitcoin Core alone creates wallets, selects encryption, handles
 passphrases, stores keys, and provides normal wallet behavior.

src/codex32/__init__.py

@@ -20,14 +20,13 @@
 from .generation import (
     ConfirmationResult,
     CreationCeremony,
-    generate_core_lightning_secret,
     generate_master_seed,
 )
 from .profiles import Profile
 from .profiles.bip39 import Bip39Secret
 from .profiles.cl32 import CoreLightningSecret
 from .profiles.ms32 import MasterSeed
-from .wallet import core_descriptors, master_xprv
+from .wallet import master_xprv
 
 __all__ = [
     "Bip39Secret",
@@ -45,11 +44,9 @@
     "Secret",
     "Share",
     "WorksheetCorrection",
-    "core_descriptors",
     "correct",
     "correct_worksheet_residue",
     "derive_share",
-    "generate_core_lightning_secret",
     "generate_master_seed",
     "master_xprv",
     "parse_codex32",

src/codex32/_bitcoin_core.py

@@ -2,7 +2,6 @@
 
 import hashlib
 import json
-import re
 import shutil
 import string
 import subprocess
@@ -15,7 +14,6 @@
 from codex32.bech32 import _u5_to_chars, convertbits
 from codex32.generation import _fingerprint_identifier
 from codex32.profiles.ms32 import MasterSeed
-from codex32.wallet import _descriptor_records
 
 
 class BitcoinCoreError(Exception):
@@ -34,9 +32,7 @@ class FingerprintMismatch(BitcoinCoreError):
     ("regtest", "regtest"),
 )
 
-_ORIGIN = re.compile(r"\[(?P<fingerprint>[0-9a-f]{8})(?P<path>(?:/[0-9]+[h']?)*)\]")
 _PRIVATE_MARKERS = ("xprv", "tprv")
-_PURPOSES = (44, 49, 84, 86)
 _OUTPUT_TYPES = ("legacy", "p2sh-segwit", "bech32", "bech32m")
 
 
@@ -218,79 +214,6 @@ def verify_identity(self, secret: MasterSeed, expected_fingerprint: bytes | None
                 "Bitcoin Core was not changed."
             )
 
-    def _root_xpub(self, wallet: str) -> str:
-        result = self._rpc("gethdkeys", wallet=wallet)
-        if not isinstance(result, list) or len(result) != 1 or not isinstance(result[0], dict):
-            raise BitcoinCoreError("Bitcoin Core did not return the expected wallet HD key.")
-        xpub = result[0].get("xpub")
-        prefix = "xpub" if self.chain == "main" else "tpub"
-        if (
-            result[0].get("has_private") is not True
-            or not isinstance(xpub, str)
-            or not xpub.startswith(prefix)
-        ):
-            raise BitcoinCoreError("Bitcoin Core did not return the expected private wallet HD key.")
-        return xpub
-
-    def _derived_key(self, wallet: str, root_xpub: str, path: str) -> tuple[bytes, str]:
-        result = self._rpc(
-            "-named",
-            "derivehdkey",
-            f"path=m{path}",
-            f"hdkey={root_xpub}",
-            wallet=wallet,
-        )
-        origin = result.get("origin") if isinstance(result, dict) else None
-        xpub = result.get("xpub") if isinstance(result, dict) else None
-        match = _ORIGIN.fullmatch(origin) if isinstance(origin, str) else None
-        prefix = "xpub" if self.chain == "main" else "tpub"
-        if match is None or not isinstance(xpub, str) or not xpub.startswith(prefix):
-            raise BitcoinCoreError("Bitcoin Core did not return the expected derived HD key.")
-        normalized_path = match.group("path").replace("'", "h")
-        if normalized_path != path:
-            raise BitcoinCoreError("Bitcoin Core returned an unexpected derivation path.")
-        return bytes.fromhex(match.group("fingerprint")), f"{origin}{xpub}/<0;1>/*"
-
-    def public_descriptors(
-        self,
-        secret: MasterSeed,
-        *,
-        wallet: str,
-        account: int = 0,
-        timestamp: int | Literal["now"] = 0,
-    ) -> tuple[dict[str, object], ...]:
-        """Ask Core to derive account xpubs, then normalize their public descriptors."""
-        if not isinstance(secret, MasterSeed):
-            raise TypeError("wallet operations accept only MasterSeed")
-        root_xpub = self._root_xpub(wallet)
-        keys: list[str] = []
-        expected_fingerprint: bytes | None = None
-        for purpose in _PURPOSES:
-            path = f"/{purpose}h/{int(self.chain != 'main')}h/{account}h"
-            fingerprint, key = self._derived_key(wallet, root_xpub, path)
-            if expected_fingerprint is None:
-                expected_fingerprint = fingerprint
-            elif fingerprint != expected_fingerprint:
-                raise BitcoinCoreError("Bitcoin Core returned inconsistent master fingerprints.")
-            keys.append(key)
-        records = _descriptor_records(tuple(keys), timestamp)  # type: ignore[arg-type]
-        for record in records:
-            detail = self._rpc("getdescriptorinfo", stdin=str(record["desc"]) + "\n")
-            expansion = detail.get("multipath_expansion") if isinstance(detail, dict) else None
-            if (
-                not isinstance(detail, dict)
-                or detail.get("hasprivatekeys") is not False
-                or not isinstance(expansion, list)
-                or len(expansion) != 2
-                or not all(
-                    isinstance(descriptor, str)
-                    and not any(marker in descriptor for marker in _PRIVATE_MARKERS)
-                    for descriptor in expansion
-                )
-            ):
-                raise BitcoinCoreError("Bitcoin Core did not validate the expected public descriptor.")
-        return records
-
     def _target(self, name: str) -> tuple[bool, bool] | None:
         listing, info = self._rpc("listdescriptors", wallet=name), self._rpc("getwalletinfo", wallet=name)
         if not isinstance(info, dict) or not isinstance(listing, dict):

src/codex32/checksums.py

@@ -1,4 +1,4 @@
-"""Immutable checksum specifications used by codex32 and descriptors."""
+"""Immutable checksum specifications used by codex32."""
 
 from dataclasses import dataclass
 
@@ -16,7 +16,6 @@
     0x0C577EAECCF1990D13C,
     0x1887F74F8DC71B10651,
 )
-_DESCSUM_GEN = (0xF5DEE51989, 0xA9FDCA3312, 0x1BAB10E32D, 0x3706B1677A, 0x644D626FFD)
 
 
 @dataclass(frozen=True, slots=True)
@@ -52,9 +51,6 @@ def create(self, values: list[int] | tuple[int, ...]) -> list[int]:
 _CODEX32 = _Checksum("codex32", _CODEX32_GEN, 13, 0x10CE0795C2FD1E62A, 93)
 _CODEX32_LONG = _Checksum("Long codex32", _CODEX32_LONG_GEN, 15, 0x43381E570BF4798AB26, 1023)
 
-# Descriptor checksum remains an independently specified, non-codex32 helper.
-DESCSUM = _Checksum("Descriptor", _DESCSUM_GEN, 8, 1)
-
 _CRC = (
     None,
     # ``_Checksum`` consumes input bits most-significant bit first.  With its

src/codex32/generation.py

@@ -29,11 +29,7 @@
     InvalidThreshold,
 )
 from codex32.profiles import Profile
-from codex32.profiles.cl32 import PAYLOAD_LENGTH as CL_PAYLOAD_LENGTH
-from codex32.profiles.cl32 import (
-    CoreLightningSecret,
-    _secret_from_bytes,
-)
+from codex32.profiles.cl32 import CoreLightningSecret
 from codex32.profiles.cl32 import (
     _has_generation_padding as _cl_padding,
 )
@@ -175,14 +171,6 @@ def generate_master_seed(
         return MasterSeed.from_seed(fresh, identifier=_fingerprint_identifier(fingerprint(fresh)))
 
 
-def generate_core_lightning_secret(
-    secret_bytes: bytes | None = None, *, identifier: str | None = None
-) -> CoreLightningSecret:
-    """Generate or encode one unshared Core Lightning HSM secret."""
-    identifier = _random_identifier() if identifier is None else _identifier(identifier)
-    return _secret_from_bytes(secrets.token_bytes(32) if secret_bytes is None else secret_bytes, identifier)
-
-
 class CreationCeremony:
     """Generate and confirm one shared-backup card at a time."""
 
@@ -256,28 +244,6 @@ def master_seed(
             None,
         )
 
-    @classmethod
-    def core_lightning(
-        cls,
-        *,
-        threshold: int,
-        share_count: int | None = None,
-        indices: Sequence[str] | str | None = None,
-        identifier: str | None = None,
-    ) -> CreationCeremony:
-        """Start a ceremony for a fresh shared Core Lightning secret."""
-        threshold = _threshold(threshold, allow_zero=False)
-        identifier = _random_identifier() if identifier is None else _identifier(identifier)
-        return cls._start(
-            Profile.CL,
-            CL_PAYLOAD_LENGTH,
-            threshold,
-            share_count,
-            indices,
-            identifier,
-            None,
-        )
-
     @classmethod
     def from_secret(
         cls,

src/codex32/profiles/cl32.py

@@ -3,11 +3,11 @@
 from __future__ import annotations
 
 from codex32.bech32 import convertbits
-from codex32.bip93 import Header, Secret, _from_parts
+from codex32.bip93 import Secret
 from codex32.errors import InvalidLength
 from codex32.profiles import Profile
 
-SECRET_BYTES, PAYLOAD_LENGTH, TEXT_LENGTH = 32, 52, 74
+PAYLOAD_LENGTH, TEXT_LENGTH = 52, 74
 
 
 def _has_generation_padding(secret: CoreLightningSecret) -> bool:
@@ -25,21 +25,6 @@ def secret_bytes(self) -> bytes:
         return bytes(convertbits(self.payload_symbols, 5, 8, pad=False, accept_any_padding=True))
 
 
-def _secret_from_bytes(
-    secret_bytes: bytes,
-    identifier: str,
-    threshold: int = 0,
-) -> CoreLightningSecret:
-    if not isinstance(secret_bytes, bytes):
-        raise TypeError("secret_bytes must be bytes")
-    if len(secret_bytes) != SECRET_BYTES:
-        raise InvalidLength("Core Lightning secrets must contain exactly 32 bytes")
-    payload = tuple(convertbits(secret_bytes, 8, 5, pad=True, pad_value=0))
-    artifact = _from_parts(Profile.CL, Header(threshold, identifier, "s"), payload)
-    assert isinstance(artifact, CoreLightningSecret)
-    return artifact
-
-
 class _Cl32Rules:
     profile, label = Profile.CL, "Core Lightning HSM secret"
     secret_type = CoreLightningSecret