feat: add wallet generation and improve local signer UX

- Add POST /api/wallets/generate endpoint that creates a fresh BIP-39 seed phrase and returns the derived address for "Create wallet" flow
- Add `generate_local_wallet()` function to generate 12-word seed phrases with OsRng entropy, deriving account 0 at m/44'/60'/0'/0/0
- Redesign local hot wallet setup with two modes: "Create wallet" (server generates phrase, shown once for backup) and "Import wallet" (paste existing key with warnings)
- Change default local signer from private key to seed phrase at account 0
- Add reveal/hide and copy/download buttons for generated seed phrases on the frontend
- Require explicit backup confirmation checkbox before allowing creation with generated wallet
- Update wizard and signer UI labels from "Signer" to "Wallet" for clarity
- Add seed phrase validation test and round-trip test verifying generated wallets can create bots
- Add `rand` dependency (0.8) for secure entropy generation alongside coins-bip39
- Never store or echo back generated seed phrases server-side; only derived hex keys are persisted

Author: bnolens

.textile-monorepo-source

@@ -1 +1 @@
-412b30ea7b1b91ee738f97729df48925cc38bf60
+fd7697729b1de3c524d3eafe9e1c4cf9dea1b4a1

.textile-stitch-release-version

@@ -1 +1 @@
-0.1.148
+0.1.149

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "stitch-bot"
-version = "0.1.148"
+version = "0.1.149"
 edition = "2021"
 description = "Stitch — Textile filler-network operator bot; market-makes the filler order book with signed UniswapX limit orders."
 license = "AGPL-3.0-or-later"
@@ -58,6 +58,9 @@ async-trait = "0.1"
 # BIP-39/BIP-32 seed-phrase derivation for the hot wallet (same crate ethers/alloy
 # use, so account 0 at m/44'/60'/0'/0/0 matches MetaMask/Rabby/etc.).
 coins-bip39 = "0.12"
+# Same major as coins-bip39 — used to generate a fresh BIP-39 phrase for
+# "Create wallet" in the panel (OsRng).
+rand = "0.8"
 axum = "0.8"
 base64 = "0.22"
 k256 = { version = "0.13", features = ["ecdsa"] }

Cargo.toml

@@ -256,6 +256,7 @@ fn public_routes() -> Router<AppState> {
 fn protected_routes(state: &AppState) -> Router<AppState> {
     Router::new()
         .route("/api/corridors", get(wizard::corridors))
+        .route("/api/wallets/generate", post(wizard::generate_wallet))
         .route("/api/signer/check", post(wizard::check_signer))
         .route("/api/bots", get(bots::list).post(wizard::create))
         .route("/api/bots/{name}", get(bots::show).delete(bots::remove))

src/panel/http/mod.rs

@@ -46,6 +46,20 @@ pub async fn corridors() -> Response {
     Json(serde_json::json!({ "corridors": list })).into_response()
 }
 
+/// Generate a fresh hot wallet for the "Create wallet" step.
+///
+/// Returns the seed phrase once so the SPA can show a backup screen. The phrase
+/// is not stored server-side — the client posts it back (as `seedPhrase`) on
+/// create / change-signer, and the writer persists only the derived hex key.
+pub async fn generate_wallet() -> Result<Response, ApiError> {
+    let wallet = crate::signer::generate_local_wallet()?;
+    Ok(Json(serde_json::json!({
+        "address": format!("{:?}", wallet.address).to_lowercase(),
+        "seedPhrase": wallet.seed_phrase,
+    }))
+    .into_response())
+}
+
 /// The signer half of the wizard payload.
 ///
 /// Tagged on `kind` so the shape and the backend can't disagree, and so a missing
@@ -447,6 +461,41 @@ mod tests {
             .contains("[[pools]]"));
     }
 
+    #[tokio::test]
+    async fn generate_wallet_returns_a_phrase_and_matching_address() {
+        let h = harness("gen-wallet");
+        let (status, body) = h.post_json("/api/wallets/generate", json!({})).await;
+        assert_eq!(status, StatusCode::OK, "{body}");
+        let v = Harness::parse(&body);
+        let phrase = v["seedPhrase"].as_str().expect("seedPhrase");
+        assert_eq!(phrase.split_whitespace().count(), 12);
+        let address = v["address"].as_str().expect("address");
+        assert!(address.starts_with("0x"));
+        assert_eq!(address.len(), 42);
+        // Round-trip through create so the derived key is what the fleet sees.
+        let (status, _) = h
+            .post_json(
+                "/api/bots",
+                json!({
+                    "name": "fresh",
+                    "corridorId": "cngn-usdt-bsc",
+                    "signer": { "kind": "local", "seedPhrase": phrase },
+                }),
+            )
+            .await;
+        assert_eq!(status, StatusCode::CREATED, "create with generated phrase");
+        let (_, show) = h.get("/api/bots/fresh").await;
+        let shown = Harness::parse(&show);
+        let shown_addr = shown["config"]["operatorAddress"]
+            .as_str()
+            .or_else(|| shown["operatorAddress"].as_str())
+            .expect("operator address on bot");
+        assert_eq!(shown_addr.to_lowercase(), address.to_lowercase());
+        // Secrets stay write-only — the generate response is the only place the
+        // phrase appears, and the bot detail never echoes key material.
+        assert!(!show.contains(phrase));
+    }
+
     #[tokio::test]
     async fn signer_check_warns_when_another_bot_shares_the_wallet_on_the_chain() {
         let h = harness("signer-check");

src/panel/http/wizard.rs

@@ -226,6 +226,29 @@ pub fn parse_private_key(raw: &str) -> anyhow::Result<SigningKey> {
 /// imported here resolves to the same address the operator sees in their wallet.
 pub const DEFAULT_DERIVATION_PATH: &str = "m/44'/60'/0'/0/0";
 
+/// A freshly generated hot wallet: BIP-39 seed phrase (12 words) plus the
+/// account-0 address at [`DEFAULT_DERIVATION_PATH`]. The panel shows the phrase
+/// once so the operator can back it up; only the derived hex key is persisted.
+#[derive(Debug, Clone)]
+pub struct GeneratedLocalWallet {
+    pub address: Address,
+    pub seed_phrase: String,
+}
+
+/// Generate a new local operator wallet (OsRng entropy → BIP-39 → account 0).
+pub fn generate_local_wallet() -> anyhow::Result<GeneratedLocalWallet> {
+    use coins_bip39::{English, Mnemonic};
+    use rand::rngs::OsRng;
+
+    let mnemonic = Mnemonic::<English>::new(&mut OsRng);
+    let seed_phrase = mnemonic.to_phrase();
+    let key = parse_mnemonic(&seed_phrase)?;
+    Ok(GeneratedLocalWallet {
+        address: address_from_signing_key(&key),
+        seed_phrase,
+    })
+}
+
 /// Derive the operator signing key from a BIP-39 seed phrase at
 /// [`DEFAULT_DERIVATION_PATH`]. The phrase is validated (wordlist + checksum) by
 /// the parse; a bad word or wrong length fails here rather than deriving a
@@ -450,6 +473,17 @@ mod tests {
         assert_eq!(from_phrase.to_bytes(), key().to_bytes());
     }
 
+    #[test]
+    fn generate_local_wallet_is_twelve_words_and_round_trips() {
+        let wallet = generate_local_wallet().expect("generate");
+        let words: Vec<_> = wallet.seed_phrase.split_whitespace().collect();
+        assert_eq!(words.len(), 12, "expected 12-word phrase");
+        let derived = parse_mnemonic(&wallet.seed_phrase).expect("phrase parses");
+        assert_eq!(address_from_signing_key(&derived), wallet.address);
+        let other = generate_local_wallet().expect("second generate");
+        assert_ne!(wallet.address, other.address, "two draws must not collide");
+    }
+
     #[test]
     fn mnemonic_tolerates_surrounding_whitespace() {
         let padded = format!("  {MNEMONIC}\n");

src/signer/mod.rs

@@ -141,6 +141,17 @@ export const api = {
   createBot: (body: unknown) =>
     request<{ bot: Bot; message: string }>('/api/bots', json(body)),
 
+  /**
+   * Mint a fresh hot wallet for the Create wallet step. Returns address + seed
+   * phrase once — nothing is stored until the client posts the phrase back on
+   * create / change-signer.
+   */
+  generateWallet: () =>
+    request<{ address: string; seedPhrase: string }>(
+      '/api/wallets/generate',
+      json({}),
+    ),
+
   /**
    * Dry-run: which other bots already use this signer on this chain. Used to warn
    * before create / change-signer — sharing a wallet races nonces.

web/src/api.ts

@@ -92,21 +92,22 @@ export default function ChangeSigner({
 
   if (!open) {
     return (
-      <Card title="Signer">
+      <Card title="Wallet">
         <p className="text-sm text-muted">
-          Switch this bot's signer backend (hot wallet, Turnkey, or MPCVault). This
-          writes the new credentials and recreates the container — a raw config edit
-          can't, because the backend's secret lives outside the TOML.
+          Create a new hot wallet, import an existing key, or switch to Turnkey /
+          MPCVault. This writes the credentials and recreates the container — a
+          raw config edit can't, because the backend's secret lives outside the
+          TOML.
         </p>
         <div className="mt-3">
-          <Button onClick={() => setOpen(true)}>Change signer</Button>
+          <Button onClick={() => setOpen(true)}>Change wallet</Button>
         </div>
       </Card>
     )
   }
 
   return (
-    <Card title="Change signer">
+    <Card title="Change wallet">
       <div className="space-y-4">
         <Banner tone="warning">
           This recreates {bot}'s container with the new backend. Orders it already