docs: link CHANGELOG.md and require updating it on new version tags

CLAUDE.md: add a working rule to update CHANGELOG.md whenever <Version> is
bumped for a new release tag. README.md: add a Changelog section pointing
to it, and fix a stale claim that release signing "is not set up yet" for
Android — it now is, via docker/build.sh android and the persistent
keystore (docker/keystore/).

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,80 @@
+name: Bug Report
+description: Report a problem with Palladium Wallet
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to report a bug.
+        Please fill in every section — incomplete reports are hard to reproduce and may be closed.
+
+  - type: input
+    id: version
+    attributes:
+      label: Wallet version
+      description: Shown in Help → Info (e.g. `1.0.0`).
+      placeholder: "1.0.0"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Platform
+      options:
+        - Windows
+        - Linux
+        - Android
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: What happened?
+      description: Describe the bug clearly and concisely. What did you see? What did you expect?
+      placeholder: "When I click … the wallet shows … instead of …"
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: Numbered steps that reliably trigger the bug.
+      placeholder: |
+        1. Open the wallet
+        2. Go to …
+        3. Click …
+        4. Observe …
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: What should have happened instead?
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / error messages
+      description: |
+        Paste any error dialogs, crash messages, or stack traces.
+        Leave blank if none.
+      render: text
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Before submitting
+      options:
+        - label: I searched existing issues and this is not a duplicate
+          required: true
+        - label: I reproduced this on the latest available version
+          required: false

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Security vulnerability
+    url: https://github.com/davide3011/PalladiumWallet/security/policy
+    about: Please report security vulnerabilities privately, not as a public issue. See SECURITY.md.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,55 @@
+name: Feature Request
+description: Suggest an idea or improvement for Palladium Wallet
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to suggest an improvement.
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: Problem
+      description: What problem are you trying to solve? Is it related to something you find missing or frustrating?
+      placeholder: "I'm always frustrated when …"
+    validations:
+      required: true
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: Proposed solution
+      description: Describe what you'd like to happen.
+    validations:
+      required: true
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives considered
+      description: Any alternative solutions or workarounds you've considered.
+    validations:
+      required: false
+
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Affected platform(s)
+      multiple: true
+      options:
+        - Windows
+        - Linux
+        - Android
+        - CLI
+        - All
+    validations:
+      required: false
+
+  - type: checkboxes
+    id: checklist
+    attributes:
+      label: Before submitting
+      options:
+        - label: I searched existing issues and this is not a duplicate
+          required: true

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,26 @@
+## Summary
+
+<!-- What does this PR change and why? -->
+
+## Related issue
+
+<!-- Closes #... (if applicable) -->
+
+## Type of change
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Refactor / cleanup
+- [ ] Documentation
+- [ ] Build / CI
+
+## Testing
+
+<!-- How was this verified? e.g. `dotnet test`, manual run on Windows/Linux/Android, golden-vector comparison -->
+
+## Checklist
+
+- [ ] `dotnet test` passes
+- [ ] No seed/private key material logged or persisted in plaintext (if touching Crypto/Wallet/Storage)
+- [ ] Server responses still validated with Merkle + checkpoints (if touching Spv/Net)
+- [ ] Code/comments/commit messages are in English

.gitignore

@@ -74,6 +74,8 @@ temp/
 *.key
 *.pfx
 *.p12
+*.keystore
+*.jks
 secrets/
 
 # Wallet data and local runtime state

AGENTS.md

@@ -0,0 +1,84 @@
+# AGENTS.md
+
+This file provides guidance to coding agents when working with code in this repository.
+
+## Role
+
+Operate as an **expert in cryptocurrencies and cryptography**: reason with the domain's rigor about UTXO consensus, HD key derivation (BIP32/39/SLIP-132), signature schemes and scripts (P2PKH/P2SH/P2WPKH, PSBT), address encoding (base58/bech32), Merkle/SPV proofs, and at-rest encryption. When a choice touches cryptographic correctness or fund safety, judge it through that lens and flag known risks and pitfalls (nonce reuse, missing validation, exposed keys/seed, wrong fee/coin-selection, unverified server responses). Explain trade-offs with technical precision; never take for granted what hasn't been verified.
+
+## Language policy
+
+- **Conversation with the user**: Italian.
+- **All code, comments, commit messages, and documentation files**: English only.
+
+## How to assist
+
+On **every requested change**, before implementing, judge whether it makes sense and say so plainly: if a request is useful and consistent with the project, proceed; if it is useless, redundant, already covered elsewhere, or risks degrading the code, **say so** with a short rationale and propose the better alternative (or doing nothing). No automatic agreement -- an honest opinion is worth more than blind execution.
+
+## What it is
+
+SPV wallet (Sparrow-style) for the **Palladium (PLM)** cryptocurrency, a Bitcoin-derived UTXO chain. Targets desktop (Windows/Linux) and Android, from the same source. Lightning is excluded from the first release.
+
+## Stack and structure
+
+.NET 10 + Avalonia UI 12 + NBitcoin.
+
+```
+src/Core/         Chain/ Crypto/ Wallet/ Spv/ Net/ Storage/  (no UI dependency)
+src/App/          shared Avalonia UI library (App, Views, ViewModels, Loc, Assets)
+src/App.Desktop/  desktop head (WinExe): Program.cs, app.manifest, .ico -> runnable
+src/App.Android/  Android head (net10.0-android): MainApplication/MainActivity -> apk
+src/Cli/          CLI on the same Core            tests/   xUnit
+```
+
+The Avalonia UI lives **once** in `src/App` (a library); the two heads only carry the
+per-platform entry point and packages. `MainView` (UserControl) is the shared root, hosted
+by `MainWindow` on desktop and as the single-view root on Android.
+
+**Non-negotiable dependency rule:** `App`/`Cli` depend only on `Core`; the UI goes through the wallet domain, never directly through network or cryptography. `Core` knows nothing about the UI.
+
+## Commands
+
+.NET 10 SDK lives in `~/.dotnet10`: in non-interactive shells, before any `dotnet` command run
+`export PATH="$HOME/.dotnet10:$PATH" DOTNET_ROOT="$HOME/.dotnet10"`.
+
+- Build: `dotnet build`
+- Tests (headless, the primary verification layer): `dotnet test` -- single: `dotnet test --filter "FullyQualifiedName~TestName"`; property-based tests (CsCheck, `PropertyTests.cs`) run in the same command and take ~30 s
+- GUI hot reload: `dotnet watch --project src/App.Desktop` (on WSL2/WSLg the window shows on the Windows desktop, no graphics dependencies to install)
+- CLI: `dotnet run --project src/Cli -- <command>` (no args -> usage)
+- Windows publish: `dotnet publish src/App.Desktop -r win-x64 -p:PublishSingleFile=true --self-contained`
+- Linux publish: `dotnet publish src/App.Desktop -r linux-x64 --self-contained` (then AppImage via PupNet Deploy)
+
+**Android (apk).** Needs the `android` workload (`dotnet workload install android`), a JDK
+(`JAVA_HOME`), and the Android SDK. To provision the SDK once:
+`dotnet build src/App.Android -t:InstallAndroidDependencies -p:AndroidSdkDirectory=$HOME/android-sdk -p:AcceptAndroidSDKLicenses=true`.
+Then build a debug apk (output in `src/App.Android/bin/Debug/net10.0-android/*-Signed.apk`):
+`JAVA_HOME=<jdk> dotnet build src/App.Android -c Debug -t:SignAndroidPackage -p:AndroidSdkDirectory=$HOME/android-sdk`
+(set `ANDROID_HOME` to skip the `-p:AndroidSdkDirectory` flag). The head is an application,
+not a library, because it sets `<OutputType>Exe</OutputType>`; min SDK 23 (AndroidX requirement).
+Note: a plain `dotnet build` at the solution level needs the Android SDK path for the Android head.
+
+**CLI** (`src/Cli`): `create`/`restore`/`restore-xpub`/`info`; `sync`/`send`/`servers`/`reset-certs` (`--server host:port [--ssl]`); `newseed`/`addresses`. Default wallet file `~/.palladium-wallet/<network>/wallets/default.wallet.json` (`--file` to change it).
+
+## Architecture (points that require reading multiple files)
+
+- **Layers:** GUI -> wallet domain -> SPV/Sync -> Network -> Cryptography -> Persistence; each layer depends only downward.
+- **Network profile:** all chain constants (address prefixes, BIP32 headers, bech32 HRP, genesis, ports, coin_type 746) **centralized in `Core/Chain`** (`ChainProfiles`/`PalladiumNetworks`), selectable per network (mainnet/testnet/regtest). No scattered magic numbers.
+- **LWMA / skip PoW:** LWMA difficulty, 2-minute blocks; an SPV client cannot recompute it -> `SkipPowValidation = true`, trust anchored to **hardcoded checkpoints**. Custom layer: NBitcoin assumes Bitcoin's retargeting.
+- **NBitcoin vs custom:** NBitcoin covers the custom network, BIP32/39, addresses, transactions, PSBT, signing, encoding, hashing -- **do not reimplement these**. Hand-written custom code: JSON-RPC client for the indexing server (ElectrumX-like); SPV sync with Merkle verification; header/checkpoint validation; coin selection and fee policy; versioned encrypted JSON wallet file.
+- **PSBT-centric:** every signing flow goes through PSBT (offline/air-gapped/multisig/hardware).
+- **Ports:** 50001/50002 = indexing server (what the SPV wallet talks to), **not** the node's P2P port (2333).
+
+## GUI conventions (`src/App`)
+
+- **Shared `MainView` + heads:** the whole UI is a single `MainView` (UserControl), so it works both as a desktop window's content and as Android's single-view root. Top-level APIs (file/folder picker, clipboard) are reached via `TopLevel.GetTopLevel(this)` since a UserControl doesn't expose them. `MainWindowViewModel.IsDesktop` (from `OperatingSystem.IsAndroid()`) hides filesystem-only features (open-from-file; the data-location wizard step auto-skips on Android because the head sets `AppPaths.OverrideDataRoot`).
+- **Single ViewModel** `MainWindowViewModel` (CommunityToolkit.Mvvm: `[ObservableProperty]`, `[RelayCommand]`); `Core` is driven directly from here.
+- **In-app overlays, not OS windows:** details (address, transaction), settings, and help are full-screen `Border`s gated by an `IsXxxOpen` flag, not separate `Window`s -- instant open/close, mobile-friendly, and popups/top-levels are slow on WSLg. Pattern: bool property + Open/Close commands + backdrop handler and Esc key in `MainView`'s code-behind; overlay close buttons bind via `$parent[UserControl]` (not `$parent[Window]`, absent on mobile). Heavy network work runs off the UI thread (`Task.Run`) so the overlay never freezes.
+- **Localization:** `Localization/Loc.cs`, key->6 languages dictionary (it/en/es/fr/pt/de); in XAML `{Binding Loc[key]}`, in C# `Loc.Tr("key")`. On language change the `Loc` instance is replaced.
+- **App version:** single source = `<Version>` in `src/App/PalladiumWallet.App.csproj`; read at runtime (`MainWindowViewModel.AppVersion`) and shown in the title.
+- **Storage paths:** `Core/Storage/AppPaths` resolves data locations; `AppPaths.OverrideDataRoot` (top priority) is the per-platform seam -- the Android head sets it to the app sandbox (`Context.FilesDir`), desktop leaves it null.
+
+## Working rules
+
+- **Cross-implementation tests:** compare addresses, txids, and PSBTs against a reference wallet (golden vectors). A different address or txid is a blocking bug.
+- **Security:** seed and private keys never in plaintext on disk/logs/network; every server response validated with Merkle + checkpoints; watch-only truly read-only.

CHANGELOG.md

@@ -0,0 +1,156 @@
+# Changelog
+
+Technical changelog for PalladiumWallet. Format loosely follows
+[Keep a Changelog](https://keepachangelog.com/en/1.0.0/); entries are grouped
+by subsystem rather than strictly by date, since `0.9.0` is the first
+release and covers the full history from the initial commit.
+
+## [0.9.0] — 2026-07-02
+
+First release. SPV wallet (Sparrow-style) for the Palladium (PLM) network —
+Bitcoin-derived UTXO chain — targeting desktop (Windows/Linux) and Android
+from a single Avalonia UI codebase on .NET 10 + NBitcoin.
+
+### Core — Chain
+
+- Network profiles and consensus constants centralized in `Core/Chain`
+  (`ChainProfiles`/`PalladiumNetworks`): address prefixes, BIP32 headers,
+  bech32 HRP, genesis, ports, `coin_type` 746 — selectable per network
+  (mainnet/testnet/regtest), no scattered magic numbers.
+- LWMA difficulty / 2-minute blocks: SPV cannot recompute LWMA retargeting,
+  so PoW validation is skipped and trust is anchored to hardcoded
+  checkpoints instead.
+
+### Core — Crypto
+
+- HD key derivation: BIP32/39/84, HD accounts, SLIP-132 extended key
+  serialization.
+- Address types: P2PKH, P2SH-P2WPKH, and P2TR (Taproot/BIP86).
+- `IWalletAccount` abstraction with WIF/xpub/xprv keystore import (including
+  watch-only accounts from public material only).
+
+### Core — Net
+
+- Custom `ElectrumClient`: JSON-RPC 2.0 client for the ElectrumX-like
+  indexing server, with TLS support and TOFU certificate pinning.
+- `ServerRegistry`: bootstrap server list, peer discovery, persisted last-used
+  server, fallback resolution for `--server`.
+- Batched writes, zero-allocation reads, bounded in-flight requests for
+  network throughput.
+- Fix: allow changing the indexing server at any time, including during an
+  active sync.
+
+### Core — Spv
+
+- Header sync with Merkle proof verification and scripthash subscriptions
+  against hardcoded checkpoints (no full PoW recomputation, per the chain
+  profile above).
+- Per-address balance and transaction-count aggregation in sync results.
+- Electrum-style continuous updates: incremental, parallelized sync across
+  address chains, with a persistent header cache.
+- Fix: resilient sync — history discovery via `GetHistory`, transaction
+  caching, automatic reconnect fallback.
+
+### Core — Storage
+
+- Versioned, encrypted JSON wallet file (`WalletDocument`) with dedicated
+  persistence and loader layer.
+- `WalletLock`: prevents concurrent access to the same wallet file; acquired
+  before load and before close (fixed a race where it wasn't).
+- XDG-compliant data paths (`AppPaths`) with per-platform override seam used
+  by the Android head; English as default UI language.
+- Contacts list (name + address) persisted in `WalletDocument`.
+- Documented caveat: `WalletStore.Save` writes plaintext JSON when the
+  wallet is unencrypted — seed/keys are only ever encrypted-at-rest when the
+  user opts into a password.
+
+### Core — Wallet
+
+- Coin selection, PSBT-centric transaction factory, and wallet loader.
+- Confirmation-threshold enforcement before spending UTXOs; immature
+  (coinbase) balance surfaced separately from confirmed balance; pending
+  mempool balance shown, with unconfirmed UTXOs excluded from spending by
+  default.
+- Fix: reject amounts with sub-satoshi precision.
+
+### App — Avalonia UI (shared, `src/App`)
+
+- Single shared `MainView` (UserControl) hosted by `MainWindow` on desktop
+  and as the single-view root on Android; single `MainWindowViewModel`
+  (CommunityToolkit.Mvvm), later split into partial files by area
+  (Wizard/Settings/Sync/Send/Contacts/Receive/...).
+- Step-by-step setup wizard (replacing a single-form panel), including a
+  first-run data-location step, multi-wallet chooser, confirm-password and
+  encrypt toggle, and dedicated flows for creating a wallet vs. importing
+  from xpub/xprv/WIF.
+- In-app overlay pattern for details/settings/help (`IsXxxOpen` flags, no OS
+  windows) replacing earlier nested submenus and a separate
+  `AddressInfoWindow`: server settings, app settings (language/unit),
+  wallet info (xpub, password-gated seed reveal), address detail
+  (password-gated private key reveal), transaction detail with full
+  on-chain data (inputs/outputs, no truncation), and a Help overlay
+  (Info/Donate tabs).
+- Connection-status indicator in the bottom bar; connect-before-wallet-open
+  flow; persisted last-used server; server discovery split into its own
+  always-usable button; mainnet hardcoded (network selector removed for the
+  first release).
+- Localization: `Loc` key → 6-language dictionary (it/en/es/fr/pt/de) with
+  live language switching.
+- Receive: QR code generation and copy-to-clipboard for the receive address.
+- Android: QR code scanner for the Send address field.
+- Centralized design system (color tokens, gradient hero, SVG tab icons);
+  responsive layout for portrait mobile, unified tab bar (desktop +
+  mobile), two-column desktop layout for Send/Receive; various mobile-only
+  fixes (tab bar sizing/indicator overlap, text overflow, full-screen server
+  overlay on mobile).
+- App version shown in window title and Help overlay, read from the single
+  `<Version>` source in the App csproj.
+- In-app update check: compares the running version against the latest
+  GitHub release tag on startup and shows an overlay with the new tag when
+  one is available (best-effort — silent on network/parse failure).
+- In-app bug-report button (Help overlay) opening a pre-filled GitHub issue
+  template; issue/PR templates completed.
+
+### Android head (`src/App.Android`)
+
+- Architecture split: shared UI library (`src/App`) + `src/App.Desktop` +
+  `src/App.Android` heads from the same source (`refactor(arch)`), each
+  carrying only the per-platform entry point and packages.
+- App logo as launcher icon.
+- Persistent release-signing keystore workflow
+  (`docker/keystore/generate-keystore.sh`, git-ignored output): every
+  release APK is signed with the same key so installing a newer build
+  updates a previous install in place instead of requiring an uninstall.
+  `versionCode` derived from `<Version>` instead of a fixed constant.
+
+### CLI (`src/Cli`)
+
+- Commands: `create`/`restore`/`restore-xpub`/`info`,
+  `sync`/`send`/`servers`/`reset-certs`, `newseed`/`addresses`.
+- `servers` command, `info --addresses`, and registry-based fallback
+  resolution for `--server`.
+
+### Build & Distribution
+
+- Docker-based reproducible build system (`docker/build.sh` +
+  `docker/Dockerfile.*`): pinned toolchain (.NET 10 SDK, JDK, Android SDK),
+  builds Windows/Linux single-file executables and a signed Android APK
+  without any SDK installed on the host.
+- Android release signing wired into `build_android` (see Android head
+  above): requires the persistent keystore, prompts for its passwords at
+  build time, mounts it read-only into the build container.
+
+### Testing
+
+- Unit test coverage across all Core modules, later expanded to 209 tests.
+- Property-based tests via CsCheck (`PropertyTests.cs`), bringing total
+  coverage to 218 tests; dedicated `WalletLock` concurrency tests.
+
+### Documentation
+
+- `README.md` (project overview, quickstart, reproducible builds), `CLAUDE.md`
+  (codebase guidance for AI tooling, kept in sync with the multi-head
+  architecture and .NET 10 migration), `SECURITY.md` (threat model and SPV
+  trust assumptions), coding-agent guide.
+- Code comments translated to English project-wide, per the language policy
+  (Italian conversation, English code/docs).

CLAUDE.md

@@ -6,65 +6,82 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 Operate as an **expert in cryptocurrencies and cryptography**: reason with the domain's rigor about UTXO consensus, HD key derivation (BIP32/39/SLIP-132), signature schemes and scripts (P2PKH/P2SH/P2WPKH, PSBT), address encoding (base58/bech32), Merkle/SPV proofs, and at-rest encryption. When a choice touches cryptographic correctness or fund safety, judge it through that lens and flag known risks and pitfalls (nonce reuse, missing validation, exposed keys/seed, wrong fee/coin-selection, unverified server responses). Explain trade-offs with technical precision; never take for granted what hasn't been verified.
 
+## Language policy
+
+- **Conversation with the user**: Italian.
+- **All code, comments, commit messages, and documentation files**: English only.
+
 ## How to assist
 
 On **every requested change**, before implementing, judge whether it makes sense and say so plainly: if a request is useful and consistent with the project, proceed; if it is useless, redundant, already covered elsewhere, or risks degrading the code, **say so** with a short rationale and propose the better alternative (or doing nothing). No automatic agreement — an honest opinion is worth more than blind execution.
 
 ## What it is
 
-SPV desktop wallet (Sparrow-style) for the **Palladium (PLM)** cryptocurrency, a Bitcoin-derived UTXO chain. Windows/Linux only, no mobile. Lightning is excluded from the first release.
-
-[blueprint.md](blueprint.md) is a **reference for understanding** (consensus parameters verified against the node, algorithms, network protocol): consult it when it helps to understand an area, but **it is no longer binding** — it need not be followed to the letter or read before every change. The source of truth is the current code; the `§` references below point to the blueprint only as further reading.
+SPV wallet (Sparrow-style) for the **Palladium (PLM)** cryptocurrency, a Bitcoin-derived UTXO chain. Targets desktop (Windows/Linux) and Android, from the same source. Lightning is excluded from the first release.
 
 ## Stack and structure
 
-.NET 8 + Avalonia UI + NBitcoin.
+.NET 10 + Avalonia UI 12 + NBitcoin.
 
 ```
-src/Core/   Chain/ Crypto/ Wallet/ Spv/ Net/ Storage/  (no UI dependency)
-src/App/    Avalonia GUI       src/Cli/   CLI           tests/   xUnit
+src/Core/         Chain/ Crypto/ Wallet/ Spv/ Net/ Storage/  (no UI dependency)
+src/App/          shared Avalonia UI library (App, Views, ViewModels, Loc, Assets)
+src/App.Desktop/  desktop head (WinExe): Program.cs, app.manifest, .ico → runnable
+src/App.Android/  Android head (net10.0-android): MainApplication/MainActivity → apk
+src/Cli/          CLI on the same Core            tests/   xUnit
+docker/           reproducible release builds (build.sh + pinned Dockerfiles) → dist/
 ```
 
+The Avalonia UI lives **once** in `src/App` (a library); the two heads only carry the
+per-platform entry point and packages. `MainView` (UserControl) is the shared root, hosted
+by `MainWindow` on desktop and as the single-view root on Android.
+
 **Non-negotiable dependency rule:** `App`/`Cli` depend only on `Core`; the UI goes through the wallet domain, never directly through network or cryptography. `Core` knows nothing about the UI.
 
 ## Commands
 
-.NET 8 SDK lives in `~/.dotnet`: in non-interactive shells, before any `dotnet` command run
-`export PATH="$HOME/.dotnet:$PATH" DOTNET_ROOT="$HOME/.dotnet"`.
+.NET 10 SDK lives in `~/.dotnet10`: in non-interactive shells, before any `dotnet` command run
+`export PATH="$HOME/.dotnet10:$PATH" DOTNET_ROOT="$HOME/.dotnet10"`.
 
 - Build: `dotnet build`
-- Tests (headless, the primary verification layer): `dotnet test` — single: `dotnet test --filter "FullyQualifiedName~TestName"`
-- GUI hot reload: `dotnet watch --project src/App` (on WSL2/WSLg the window shows on the Windows desktop, no graphics dependencies to install)
+- Tests (headless, the primary verification layer): `dotnet test` — single: `dotnet test --filter "FullyQualifiedName~TestName"`; property-based tests (CsCheck, `PropertyTests.cs`) run in the same command and take ~30 s
+- GUI hot reload: `dotnet watch --project src/App.Desktop` (on WSL2/WSLg the window shows on the Windows desktop, no graphics dependencies to install)
 - CLI: `dotnet run --project src/Cli -- <command>` (no args → usage)
-- Windows publish: `dotnet publish src/App -r win-x64 -p:PublishSingleFile=true --self-contained`
-- Linux publish: `dotnet publish src/App -r linux-x64 --self-contained` (then AppImage via PupNet Deploy)
+- **Release binaries (all 3 targets): `./docker/build.sh [windows|linux|android|all]`** — reproducible builds in Docker (toolchain pinned in `docker/Dockerfile.*`, no SDK needed on host), artifacts in `dist/`, version taken from the App csproj. See `docker/README.md`. Gotchas already encoded there: single-file desktop publishes need `-p:IncludeNativeLibrariesForSelfExtract=true` (without it Avalonia's native libs — Skia/HarfBuzz/ANGLE — stay outside the exe, which then silently fails to start); the android workload dictates the SDK API level (error XA5207 → bump `ANDROID_SDK_PLATFORM` in `Dockerfile.android`). Android release builds need a persistent signing keystore, generated once with `docker/keystore/generate-keystore.sh` (never committed — see `docker/keystore/README.md`): without it every build gets a different random signature and users must uninstall the old app to receive an update instead of updating in place.
+- Manual Windows publish: `dotnet publish src/App.Desktop -r win-x64 -p:PublishSingleFile=true -p:IncludeNativeLibrariesForSelfExtract=true --self-contained`
+- Manual Linux publish: same with `-r linux-x64` (single-file binary; AppImage via PupNet Deploy is a future step, no pupnet.conf yet)
+
+**Android (apk).** Needs the `android` workload (`dotnet workload install android`), a JDK
+(`JAVA_HOME`), and the Android SDK. To provision the SDK once:
+`dotnet build src/App.Android -t:InstallAndroidDependencies -p:AndroidSdkDirectory=$HOME/android-sdk -p:AcceptAndroidSDKLicenses=true`.
+Then build a debug apk (output in `src/App.Android/bin/Debug/net10.0-android/*-Signed.apk`):
+`JAVA_HOME=<jdk> dotnet build src/App.Android -c Debug -t:SignAndroidPackage -p:AndroidSdkDirectory=$HOME/android-sdk`
+(set `ANDROID_HOME` to skip the `-p:AndroidSdkDirectory` flag). The head is an application,
+not a library, because it sets `<OutputType>Exe</OutputType>`; min SDK 23 (AndroidX requirement).
+Note: a plain `dotnet build` at the solution level needs the Android SDK path for the Android head.
 
 **CLI** (`src/Cli`): `create`/`restore`/`restore-xpub`/`info`; `sync`/`send`/`servers`/`reset-certs` (`--server host:port [--ssl]`); `newseed`/`addresses`. Default wallet file `~/.palladium-wallet/<network>/wallets/default.wallet.json` (`--file` to change it).
 
 ## Architecture (points that require reading multiple files)
 
-- **Layers (§2):** GUI → wallet domain → SPV/Sync → Network → Cryptography → Persistence; each layer depends only downward.
-- **Network profile (§3):** all chain constants (address prefixes, BIP32 headers, bech32 HRP, genesis, ports, coin_type 746) **centralized in `Core/Chain`** (`ChainProfiles`/`PalladiumNetworks`), selectable per network (mainnet/testnet/regtest). No scattered magic numbers.
-- **LWMA / skip PoW (§3, §7):** LWMA difficulty, 2-minute blocks; an SPV client cannot recompute it → `SkipPowValidation = true`, trust anchored to **hardcoded checkpoints** (§7.3). Custom layer: NBitcoin assumes Bitcoin's retargeting.
-- **NBitcoin vs custom (§19.2):** NBitcoin covers the custom network, BIP32/39, addresses, transactions, PSBT, signing, encoding, hashing — **do not reimplement these**. Hand-written custom code: JSON-RPC client for the indexing server (ElectrumX-like, §10); SPV sync with Merkle verification (§7.4); header/checkpoint validation; coin selection and fee policy; versioned encrypted JSON wallet file.
-- **PSBT-centric (§6.5):** every signing flow goes through PSBT (offline/air-gapped/multisig/hardware).
+- **Layers:** GUI → wallet domain → SPV/Sync → Network → Cryptography → Persistence; each layer depends only downward.
+- **Network profile:** all chain constants (address prefixes, BIP32 headers, bech32 HRP, genesis, ports, coin_type 746) **centralized in `Core/Chain`** (`ChainProfiles`/`PalladiumNetworks`), selectable per network (mainnet/testnet/regtest). No scattered magic numbers.
+- **LWMA / skip PoW:** LWMA difficulty, 2-minute blocks; an SPV client cannot recompute it → `SkipPowValidation = true`, trust anchored to **hardcoded checkpoints**. Custom layer: NBitcoin assumes Bitcoin's retargeting.
+- **NBitcoin vs custom:** NBitcoin covers the custom network, BIP32/39, addresses, transactions, PSBT, signing, encoding, hashing — **do not reimplement these**. Hand-written custom code: JSON-RPC client for the indexing server (ElectrumX-like); SPV sync with Merkle verification; header/checkpoint validation; coin selection and fee policy; versioned encrypted JSON wallet file.
+- **PSBT-centric:** every signing flow goes through PSBT (offline/air-gapped/multisig/hardware).
 - **Ports:** 50001/50002 = indexing server (what the SPV wallet talks to), **not** the node's P2P port (2333).
 
 ## GUI conventions (`src/App`)
 
+- **Shared `MainView` + heads:** the whole UI is a single `MainView` (UserControl), so it works both as a desktop window's content and as Android's single-view root. Top-level APIs (file/folder picker, clipboard) are reached via `TopLevel.GetTopLevel(this)` since a UserControl doesn't expose them. `MainWindowViewModel.IsDesktop` (from `OperatingSystem.IsAndroid()`) hides filesystem-only features (open-from-file; the data-location wizard step auto-skips on Android because the head sets `AppPaths.OverrideDataRoot`).
 - **Single ViewModel** `MainWindowViewModel` (CommunityToolkit.Mvvm: `[ObservableProperty]`, `[RelayCommand]`); `Core` is driven directly from here.
-- **In-app overlays, not OS windows:** details (address, transaction), settings, and help are full-screen `Border`s gated by an `IsXxxOpen` flag, not separate `Window`s — popups/top-levels are slow on WSLg. Pattern: bool property + Open/Close commands + backdrop handler and Esc key in `MainWindow`'s code-behind. Heavy network work runs off the UI thread (`Task.Run`) so the overlay never freezes.
+- **In-app overlays, not OS windows:** details (address, transaction), settings, and help are full-screen `Border`s gated by an `IsXxxOpen` flag, not separate `Window`s — instant open/close, mobile-friendly, and popups/top-levels are slow on WSLg. Pattern: bool property + Open/Close commands + backdrop handler and Esc key in `MainView`'s code-behind; overlay close buttons bind via `$parent[UserControl]` (not `$parent[Window]`, absent on mobile). Heavy network work runs off the UI thread (`Task.Run`) so the overlay never freezes.
 - **Localization:** `Localization/Loc.cs`, key→6 languages dictionary (it/en/es/fr/pt/de); in XAML `{Binding Loc[key]}`, in C# `Loc.Tr("key")`. On language change the `Loc` instance is replaced.
 - **App version:** single source = `<Version>` in `src/App/PalladiumWallet.App.csproj`; read at runtime (`MainWindowViewModel.AppVersion`) and shown in the title.
-
-## Implementation state (§16 steps 1–7 + GUI)
-
-`Core/Chain` network profiles; `Core/Crypto` BIP39/32/SLIP-132/`HdAccount`; `Core/Storage` JSON wallet v1 + AES-GCM (PBKDF2-SHA512) + data paths; `Core/Net` `ElectrumClient` (newline JSON-RPC over TCP/TLS, TOFU in `server-certs.json`, concurrent requests) + `ElectrumApi`; `Core/Spv` scripthash, mandatory Merkle verification on every confirmed tx, sync with gap limit; `Core/Wallet` `TransactionFactory` (RBF on, send-all, watch-only PSBT), `TransactionInspector` (tx detail from the server), `WalletLoader`. GUI: setup wizard, dashboard (history/send/receive with QR+copy/addresses/contacts), transaction detail, settings/server/help, multi-wallet.
-
-**TODO (§16 steps 8–9):** multisig, hardware wallet, coin control UI, fee ETA/mempool, RBF/CPFP UI, on-disk header chain, multi-server pool, proxy/Tor.
+- **Storage paths:** `Core/Storage/AppPaths` resolves data locations; `AppPaths.OverrideDataRoot` (top priority) is the per-platform seam — the Android head sets it to the app sandbox (`Context.FilesDir`), desktop leaves it null.
 
 ## Working rules
 
-- **Cross-implementation tests (§16):** compare addresses, txids, and PSBTs against a reference wallet (golden vectors). A different address or txid is a blocking bug.
-- **Security (§17):** seed and private keys never in plaintext on disk/logs/network; every server response validated with Merkle + checkpoints; watch-only truly read-only.
-- *(Optional)* blueprint features may be deferred but must still be considered in the design.
+- **Cross-implementation tests:** compare addresses, txids, and PSBTs against a reference wallet (golden vectors). A different address or txid is a blocking bug.
+- **Security:** seed and private keys never in plaintext on disk/logs/network; every server response validated with Merkle + checkpoints; watch-only truly read-only.
+- **Releases:** whenever a new version tag is created (bumping `<Version>` in `src/App/PalladiumWallet.App.csproj`), update `CHANGELOG.md` with an entry for that version before/with the tag — it's the technical record of what shipped, not optional bookkeeping.

PalladiumWallet.sln

@@ -15,6 +15,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{FDF1822C
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PalladiumWallet.Tests", "tests\PalladiumWallet.Tests\PalladiumWallet.Tests.csproj", "{C7E79E8E-B1DE-4053-9FB4-853814766CE0}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PalladiumWallet.App.Desktop", "src\App.Desktop\PalladiumWallet.App.Desktop.csproj", "{A5D1DD48-7485-43F0-BFE3-2F645EC4D1E7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PalladiumWallet.App.Android", "src\App.Android\PalladiumWallet.App.Android.csproj", "{BCC5BE4A-B909-4043-B0FB-B5A839349578}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -40,11 +44,21 @@ Global
 		{C7E79E8E-B1DE-4053-9FB4-853814766CE0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C7E79E8E-B1DE-4053-9FB4-853814766CE0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C7E79E8E-B1DE-4053-9FB4-853814766CE0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A5D1DD48-7485-43F0-BFE3-2F645EC4D1E7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A5D1DD48-7485-43F0-BFE3-2F645EC4D1E7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A5D1DD48-7485-43F0-BFE3-2F645EC4D1E7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A5D1DD48-7485-43F0-BFE3-2F645EC4D1E7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BCC5BE4A-B909-4043-B0FB-B5A839349578}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BCC5BE4A-B909-4043-B0FB-B5A839349578}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BCC5BE4A-B909-4043-B0FB-B5A839349578}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BCC5BE4A-B909-4043-B0FB-B5A839349578}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{A7D0EF95-B206-4646-99DD-1D2BBB7AF978} = {84E60614-5042-48EC-B349-290FB0CA7BA8}
 		{13EE9780-5810-4229-BFCF-6003172534DD} = {84E60614-5042-48EC-B349-290FB0CA7BA8}
 		{D1AE035A-6DAC-46F4-90FB-F1AE2A79D416} = {84E60614-5042-48EC-B349-290FB0CA7BA8}
 		{C7E79E8E-B1DE-4053-9FB4-853814766CE0} = {FDF1822C-58D6-4B35-93EA-6A85E1292933}
+		{A5D1DD48-7485-43F0-BFE3-2F645EC4D1E7} = {84E60614-5042-48EC-B349-290FB0CA7BA8}
+		{BCC5BE4A-B909-4043-B0FB-B5A839349578} = {84E60614-5042-48EC-B349-290FB0CA7BA8}
 	EndGlobalSection
 EndGlobal

README.md

@@ -1,6 +1,6 @@
 # Palladium Wallet
 
-**An SPV desktop wallet built specifically for the Palladium (PLM) cryptocurrency** and optimized for its chain.
+**An SPV wallet built specifically for the Palladium (PLM) cryptocurrency** and optimized for its chain. Runs on desktop (Windows/Linux) and Android from a single shared codebase.
 
 Unlike generic wallets adapted to many coins, Palladium Wallet is designed around Palladium's consensus parameters — a Bitcoin-derived UTXO chain with 2-minute blocks and LWMA difficulty — and centralizes them in a single network profile. This keeps it lightweight, predictable and faithful to the chain: no client-side difficulty recalculation (trust is anchored to hardcoded checkpoints), mandatory Merkle verification on every confirmed transaction, and a network client written specifically for Palladium's indexing server.
 
@@ -11,34 +11,39 @@ Unlike generic wallets adapted to many coins, Palladium Wallet is designed aroun
 - **HD wallet** (BIP39/BIP32), SegWit/wrapped/legacy addresses, watch-only from xpub.
 - **PSBT-centric**: signing flows go through PSBT (offline / air-gapped / multisig).
 - **Multi-network**: mainnet, testnet, regtest.
-- **GUI** (Avalonia) and **CLI** on the same core.
+- **Cross-platform**: desktop (Windows/Linux) and Android share one Avalonia UI; a **CLI** runs on the same core.
 - **Multilingual**: Italian, English, Spanish, French, Portuguese, German.
 
 ## Architecture
 
 ```
 PalladiumWallet.sln
-├─ src/Core/   Chain/ Crypto/ Wallet/ Spv/ Net/ Storage/  (no UI dependency)
-├─ src/App/    Avalonia GUI
-├─ src/Cli/    CLI on the same Core
-└─ tests/      xUnit
+├─ src/Core/          Chain/ Crypto/ Wallet/ Spv/ Net/ Storage/  (no UI dependency)
+├─ src/App/           shared Avalonia UI library (Views, ViewModels, Loc, Assets)
+├─ src/App.Desktop/   desktop head (Windows/Linux) → runnable
+├─ src/App.Android/   Android head → apk
+├─ src/Cli/           CLI on the same Core
+└─ tests/             xUnit
 ```
 
-Stack: **.NET 8 + Avalonia UI + NBitcoin**.
+The UI is written **once** in `src/App`; the desktop and Android heads only add the per-platform
+entry point and packages.
+
+Stack: **.NET 10 + Avalonia UI 12 + NBitcoin**.
 
 ---
 
 ## Development environment
 
-You only need the **.NET 8 SDK**. The core and crypto are fully testable without the GUI or a real network.
+For desktop and the CLI you only need the **.NET 10 SDK**. The core and crypto are fully testable without the GUI or a real network.
 
 ### Windows
 
-1. Install the .NET 8 SDK:
+1. Install the .NET 10 SDK:
    ```powershell
-   winget install Microsoft.DotNet.SDK.8
+   winget install Microsoft.DotNet.SDK.10
    ```
-   (alternatively, the installer from <https://dotnet.microsoft.com/download/dotnet/8.0>)
+   (alternatively, the installer from <https://dotnet.microsoft.com/download/dotnet/10.0>)
 2. Clone the repository and restore dependencies:
    ```powershell
    git clone <repo-URL>
@@ -48,10 +53,10 @@ You only need the **.NET 8 SDK**. The core and crypto are fully testable without
 
 ### Linux
 
-1. Install the .NET 8 SDK through your distro's package manager, or without root via the official script:
+1. Install the .NET 10 SDK through your distro's package manager, or without root via the official script:
    ```bash
-   curl -sSL https://dot.net/v1/dotnet-install.sh | bash -s -- --channel 8.0
-   export PATH="$HOME/.dotnet:$PATH" DOTNET_ROOT="$HOME/.dotnet"
+   curl -sSL https://dot.net/v1/dotnet-install.sh | bash -s -- --channel 10.0 --install-dir "$HOME/.dotnet10"
+   export PATH="$HOME/.dotnet10:$PATH" DOTNET_ROOT="$HOME/.dotnet10"
    ```
    (add the two `export` lines to your `~/.bashrc` to make them permanent)
 2. Clone and restore:
@@ -61,27 +66,58 @@ You only need the **.NET 8 SDK**. The core and crypto are fully testable without
    dotnet restore
    ```
 
-> The GUI uses Avalonia, which runs natively on both platforms with no extra graphics dependencies.
+> The GUI uses Avalonia, which runs natively on Windows and Linux with no extra graphics dependencies.
+
+### Android (additional setup)
+
+Building the apk also requires the Android workload, a JDK, and the Android SDK:
+
+```bash
+dotnet workload install android          # .NET Android build packs
+# JDK 17+ must be available (set JAVA_HOME)
+# Provision the Android SDK once into ~/android-sdk:
+dotnet build src/App.Android -t:InstallAndroidDependencies \
+  -p:AndroidSdkDirectory=$HOME/android-sdk -p:AcceptAndroidSDKLicenses=true
+```
+
+To run the apk on an emulator (instead of a physical device), see
+[*Android emulator (developer setup)*](#android-emulator-developer-setup) below.
 
 ---
 
 ## Running it
 
-**GUI** (with hot reload for development):
+### Desktop GUI in debug (Linux & Windows)
+
+The desktop head runs the same way on both OSes (`Debug` is the default configuration). Run it from
+the repo root:
+
 ```bash
-dotnet watch --project src/App
-```
-or a single run:
-```bash
-dotnet run --project src/App
+dotnet run --project src/App.Desktop                 # single run (Debug)
+dotnet watch --project src/App.Desktop               # with hot reload (edit XAML/C# and see changes live)
+dotnet run --project src/App.Desktop -c Release      # to try the Release config
 ```
 
-**CLI** (same core, useful for scripts and headless environments):
+- **Linux** — runs natively on X11/Wayland, no extra graphics packages. On **WSL2** the window
+  appears on the Windows desktop through WSLg (already working here, nothing to install).
+- **Windows** — runs natively; use the same commands from PowerShell or a terminal.
+
+The app writes its data under the per-user data folder (see *User guide → First launch*); delete it
+to start from a clean first-run wizard.
+
+### CLI
+
+Same core, useful for scripts and headless environments:
 ```bash
 dotnet run --project src/Cli -- <command>
 ```
 Run without arguments for the full list of commands.
 
+### Android
+
+There is no `dotnet run` for a phone: build the apk and install it (see *Building → Android apk*),
+or run it on an emulator (see *Android emulator (developer setup)*).
+
 ---
 
 ## Running tests
@@ -105,38 +141,172 @@ dotnet test tests/PalladiumWallet.Tests
 
 > Cross-implementation tests compare addresses, txids and PSBTs against reference golden vectors: a different address or txid is a blocking bug.
 
+The suite includes **property-based tests** ([CsCheck](https://github.com/AnthonyLloyd/CsCheck)) in `tests/PalladiumWallet.Tests/PropertyTests.cs`. These generate hundreds of random inputs per test and verify invariants that must hold universally — no crash on arbitrary strings, encrypt/decrypt roundtrip for any plaintext and password, every leaf in a randomly-built Merkle tree verifies against its root. They run automatically with `dotnet test` and take ~30 s.
+
 ---
 
 ## Building
 
-**Development build:**
+### Reproducible builds (Docker) — recommended for release binaries
+
+All three distribution targets (Windows exe, Linux binary, Android apk) can be
+built with one command inside Docker, with **no SDK installed on the host**:
+
 ```bash
-dotnet build
+./docker/build.sh          # interactive menu, or: ./docker/build.sh all
 ```
 
-**Windows publish** (single self-contained executable):
+Why build this way: the whole toolchain is pinned in the Dockerfiles, so every
+build uses exactly the same SDK versions regardless of the host machine — no
+toolchain drift between releases — and the build environment itself is
+reviewable in the repo. For a wallet this is a trust property, not a
+convenience: anyone can rebuild the published binaries from source and check
+they were produced by the process the repository declares.
+
+See [docker/README.md](docker/README.md) for prerequisites, usage, how to run
+each produced artifact, and troubleshooting. The sections below cover manual
+builds with a locally installed SDK (the normal path during development).
+
+### Development build
+
 ```bash
-dotnet publish src/App -r win-x64 -p:PublishSingleFile=true --self-contained
+dotnet build                              # whole solution (debug)
+dotnet build src/App.Desktop              # desktop head only
 ```
 
-**Linux publish** (self-contained; the AppImage is then produced with [PupNet Deploy](https://github.com/kuiperzone/PupNet-Deploy)):
+> A solution-wide `dotnet build` also builds the Android head, which needs the Android SDK
+> (see *Android emulator (developer setup)* below). If you don't have it, build the specific
+> non-Android projects (`src/App.Desktop`, `src/Cli`, `tests/...`).
+
+### Desktop release (self-contained)
+
 ```bash
-dotnet publish src/App -r linux-x64 --self-contained
+# Windows — single self-contained .exe (output: src/App.Desktop/bin/Release/net10.0/win-x64/publish/PalladiumWallet.exe)
+# IncludeNativeLibrariesForSelfExtract embeds Avalonia's native libs (Skia, HarfBuzz, ANGLE):
+# without it they stay as separate DLLs and the .exe alone silently fails to start.
+dotnet publish src/App.Desktop -c Release -r win-x64 -p:PublishSingleFile=true \
+  -p:IncludeNativeLibrariesForSelfExtract=true --self-contained
+
+# Linux — self-contained; AppImage then produced with PupNet Deploy
+# (output: src/App.Desktop/bin/Release/net10.0/linux-x64/publish/PalladiumWallet)
+dotnet publish src/App.Desktop -c Release -r linux-x64 --self-contained
 ```
 
-The application **version** is set in a single place: the `<Version>` tag in [`src/App/PalladiumWallet.App.csproj`](src/App/PalladiumWallet.App.csproj). It appears in the window title and is stamped into the published binaries.
+[PupNet Deploy](https://github.com/kuiperzone/PupNet-Deploy) turns the Linux publish into an AppImage.
+The executable is named `PalladiumWallet` (set via `<AssemblyName>` in the desktop head).
+
+### Android apk
+
+Prerequisites: the Android workload + SDK (see *Development environment → Android*). The Android
+head already sets `<EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>`, so the apk is
+**self-contained** and installs/runs standalone (a Fast-Deployment debug apk crashes at launch
+with "No assemblies found" when installed without `adb`).
+
+```bash
+# Default debug apk — all ABIs (arm64-v8a + x86_64): runs on phones AND the x86_64 emulator.
+# ~79 MB. Output: src/App.Android/bin/Debug/net10.0-android/*-Signed.apk
+JAVA_HOME=<jdk-path> dotnet build src/App.Android -c Debug -t:SignAndroidPackage \
+  -p:AndroidSdkDirectory=$HOME/android-sdk
+
+# Smaller apk for a real phone — arm64 only (~41 MB):
+JAVA_HOME=<jdk-path> dotnet build src/App.Android -c Debug -t:SignAndroidPackage \
+  -p:AndroidSdkDirectory=$HOME/android-sdk -p:AbiArm64Only=true
+```
+
+The ABI restriction uses the `AbiArm64Only` flag, which is scoped to the Android head's
+`<RuntimeIdentifiers>` in its csproj — do **not** pass `-p:RuntimeIdentifiers=android-arm64` on the
+command line, it leaks to the `net10.0` projects (`Core`/`App`) and breaks the build. (The legacy
+`AndroidSupportedAbis` property is deprecated and ignored.)
+
+(Set `ANDROID_HOME` to skip the `-p:AndroidSdkDirectory` flag.) This debug apk is fine for personal
+sideloading, but debug builds are signed with a key regenerated per build machine/container, so a
+newer debug apk won't install over an older one without an uninstall first. For a stable signature
+across releases (needed to update an existing install in place), build via
+`./docker/build.sh android` instead — see [docker/keystore/README.md](docker/keystore/README.md).
+
+> **Verification status.** The default multi-ABI apk is verified running on the x86_64 emulator
+> (UI renders, connects to a server over TLS). The arm64-only apk builds correctly (41 MB,
+> `arm64-v8a` only) but is meant for a physical arm64 phone — on the x86_64 emulator it only runs
+> through slow ARM translation and stalls on the splash, so **verify it on a real device**.
+
+### Version
+
+The application **version** is set in a single place: the `<Version>` tag in
+[`src/App/PalladiumWallet.App.csproj`](src/App/PalladiumWallet.App.csproj). It appears in the desktop
+window title, in the Help dialog, and is stamped into the published binaries (and the apk's versionName).
+
+---
+
+## Android emulator (developer setup)
+
+How to run the apk without a physical device. Paths assume the Android SDK in `~/android-sdk`
+and a JDK at `JAVA_HOME` (JDK 17+). Tested on Linux / WSL2.
+
+**1. Install the emulator, a system image and the matching platform** (once):
+```bash
+SDK=$HOME/android-sdk
+$SDK/cmdline-tools/latest/bin/sdkmanager --sdk_root=$SDK \
+  "emulator" "system-images;android-34;google_apis;x86_64" "platforms;android-34"
+```
+Use an `x86_64` image so the emulator runs with hardware acceleration (KVM); the app's min SDK is 23.
+
+**2. Hardware acceleration (Linux/WSL2)** — the emulator needs access to `/dev/kvm`. Add yourself
+to the `kvm` group once, then start a new shell (or prefix the launch with `sg kvm -c '…'`):
+```bash
+sudo usermod -aG kvm $USER
+```
+On WSL2, KVM must be enabled on the Windows host (nested virtualization); the emulator window is
+shown on the Windows desktop through WSLg.
+
+**3. Create an AVD** (virtual device):
+```bash
+echo no | $SDK/cmdline-tools/latest/bin/avdmanager create avd \
+  -n plm -k "system-images;android-34;google_apis;x86_64" -d pixel
+```
+
+**4. Launch the emulator** (software GL is the most robust under WSLg):
+```bash
+$SDK/emulator/emulator -avd plm -gpu swiftshader_indirect -no-snapshot -no-audio &
+$SDK/platform-tools/adb wait-for-device
+# wait for full boot:
+until [ "$($SDK/platform-tools/adb shell getprop sys.boot_completed | tr -d '\r')" = 1 ]; do sleep 2; done
+```
+If the window won't render, add `-no-window` and rely on `adb` + screenshots
+(`adb exec-out screencap -p > shot.png`).
+
+**5. Install and run the apk; capture logs to debug crashes:**
+```bash
+ADB=$SDK/platform-tools/adb
+$ADB install -r src/App.Android/bin/Debug/net10.0-android/*-Signed.apk
+$ADB shell monkey -p io.github.davide3011.palladiumwallet -c android.intent.category.LAUNCHER 1
+$ADB logcat -d | grep -iE "monodroid|exception|fatal|avalonia"
+```
+
+**VS Code "Android iOS Emulator" extension** (optional, click-to-launch): it only starts an
+existing AVD, so create one first (step 3). Point it at the emulator binary:
+```jsonc
+// VS Code settings.json
+"emulator.emulatorPathLinux": "/home/<user>/android-sdk/emulator"
+// on WSL, use: "emulator.emulatorPathWSL": "/home/<user>/android-sdk/emulator"
+```
 
 ---
 
 ## User guide (quick)
 
 ### First launch
-1. On first launch, choose **where to store data** (wallet, configuration, certificates) — the default path or a folder of your choice.
-2. Create a new wallet, restore from seed, or open an existing wallet.
+1. On first launch (desktop), choose **where to store data** (wallet, configuration, certificates) — the default path or a folder of your choice. On Android this step is skipped: data lives in the app's private sandbox.
+2. Create a new wallet, restore from seed, or open one of the wallets already in your data folder.
 3. If you create a wallet, **write the seed phrase down on paper**: it will not be shown again. You can protect the file with a password.
 
+> **Desktop vs Android.** The UI and features are the same on both. Differences: on Android the
+> data-location step is skipped (fixed app sandbox) and *File → Open wallet from file* (importing a
+> wallet from an arbitrary file) is hidden — open wallets from the in-app chooser instead. The
+> version is shown in the desktop window title and, on every platform, in the Help dialog. The CLI
+> is desktop/headless only.
+
 ### Main tabs
-- **History** — list of transactions. *Double-click* a row to open the full detail (amount, fee, addresses, sizes, confirmations).
+- **History** — list of transactions. *Double-click* (double-tap on touch) a row to open the full detail (amount, fee, addresses, sizes, confirmations).
 - **Send** — recipient + amount (or "send all"), adjustable fee; for watch-only wallets a PSBT is produced to be signed offline.
 - **Receive** — next unused address, with a **QR code** and a **Copy** button.
 - **Addresses** — all derived addresses with balances; click for details (keys, derivation path).
@@ -165,6 +335,10 @@ The default wallet file is `~/.palladium-wallet/<network>/wallets/default.wallet
 
 ---
 
+## Changelog
+
+Technical, per-version changes are tracked in [CHANGELOG.md](CHANGELOG.md).
+
 ## License
 
 Released under the MIT License. See the [LICENSE](LICENSE) file.

SECURITY.md

@@ -0,0 +1,83 @@
+# Security
+
+## Threat model
+
+Palladium Wallet is a self-custody SPV wallet. It is designed to protect funds against:
+
+- Theft of the wallet file at rest (AES-256-GCM encryption with PBKDF2-HMAC-SHA512)
+- Memory snooping of private keys after unlock (keys are held only in process memory, never written to disk in plaintext unless the user explicitly disables encryption)
+- Fraudulent transaction injection by a malicious server (every confirmed transaction is verified with a Merkle proof against SPV-validated block headers anchored to hardcoded checkpoints)
+
+It does **not** protect against:
+
+- A fully compromised operating system or process (malware with memory access can extract keys from RAM)
+- An attacker who obtains the wallet file **and** the password
+- Denial of service or eclipse attacks against the indexing server
+- Network-level traffic analysis (no Tor/proxy support in the first release)
+
+---
+
+## SPV trust model
+
+This wallet is an SPV client, not a full node. It validates:
+
+- Block headers (proof of work checked up to the last checkpoint; `SkipPowValidation` is enabled because LWMA difficulty cannot be recomputed client-side — trust is anchored to hardcoded checkpoints in `Core/Chain/ChainProfiles.cs`)
+- Transaction inclusion in a confirmed block (Merkle branch proof, mandatory for every confirmed transaction — see `Core/Spv/MerkleVerifier.cs`)
+
+It does **not** validate:
+
+- Script execution (P2WPKH scripts are assumed valid if the server returns a confirmed transaction with a valid Merkle proof)
+- Double-spend detection beyond what the server reports (an eclipse attack on the indexing server could hide a conflicting transaction)
+- Full block validity (coinbase, consensus rules beyond the header)
+
+The indexing server (ElectrumX-compatible, port 50001/50002) is a **semi-trusted** component. It can:
+
+- Lie about unconfirmed (mempool) transactions — the wallet shows mempool transactions as unconfirmed and non-spendable
+- Refuse to relay a broadcast transaction
+- Delay reporting of new blocks
+
+It cannot (given correct Merkle verification):
+
+- Fabricate a confirmed transaction with a valid Merkle proof
+- Forge a payment to a wrong address
+
+---
+
+## Key and seed management
+
+- The BIP39 mnemonic and derived private keys exist only in process memory after unlock
+- Private keys are never written to disk, logged, or sent over the network
+- The wallet file stores the encrypted seed (with password) or the encrypted/plaintext `WalletDocument` — the document contains the account xpub and sync cache, not the raw seed when watch-only
+- Watch-only wallets (`restore-xpub`) hold no private keys and cannot sign transactions
+
+---
+
+## Encryption at rest
+
+- Algorithm: AES-256-GCM
+- Key derivation: PBKDF2-HMAC-SHA512, 100 000 iterations, 32-byte random salt
+- Authentication: GCM tag (16 bytes) — any tampering is detected before decryption
+- The user can explicitly opt out of encryption (UI shows a warning); the `WalletStore.Save` API accepts `null` password only when the caller has confirmed user intent
+
+---
+
+## TLS certificate pinning
+
+Connections to the indexing server use TOFU (Trust On First Use): the server's TLS certificate is pinned on first connection and stored in `server-certs.json`. A certificate change triggers a hard error (`CertificatePinMismatchException`) requiring explicit reset by the user. This prevents silent MITM substitution after first connection.
+
+---
+
+## Backup
+
+The wallet file is the only thing that needs to be backed up. For encrypted wallets, the password is also required. If both the file and the password are lost, funds are unrecoverable (no server-side backup). For watch-only wallets restored from xpub, the private keys must be kept in a separate cold storage device.
+
+---
+
+## Known limitations and out-of-scope for v1
+
+- No Tor/proxy support (network traffic reveals which addresses are being queried)
+- No multi-server pooling (single point of failure for the indexing server)
+- No hardware wallet integration
+- No coin control (automatic UTXO selection only)
+- No RBF/CPFP UI (RBF flag is set on all transactions, but fee bumping is not exposed)
+- No Lightning Network support

docker/Dockerfile.android

@@ -0,0 +1,39 @@
+FROM mcr.microsoft.com/dotnet/sdk:10.0
+
+# ── Java (required by the Android SDK tools) ─────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        openjdk-17-jdk-headless \
+        wget \
+        unzip \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+ENV JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
+ENV ANDROID_HOME=/opt/android-sdk
+# .NET 10 android workload compiles against API level 36 (see error XA5207
+# if this drifts: the workload's Xamarin.Android.Tooling.targets dictates it).
+ENV ANDROID_SDK_PLATFORM=36
+ENV ANDROID_SDK_BUILD_TOOLS=36.0.0
+
+# ── Android command-line tools ────────────────────────────────────────────────
+# Pin the build number to a known-good release; update when Google breaks the URL.
+# Latest as of 2025: commandlinetools-linux-11076708_latest.zip (cmdline-tools 12.0)
+RUN mkdir -p "${ANDROID_HOME}/cmdline-tools" && \
+    wget -q "https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip" \
+         -O /tmp/cmdtools.zip && \
+    unzip -q /tmp/cmdtools.zip -d "${ANDROID_HOME}/cmdline-tools" && \
+    mv "${ANDROID_HOME}/cmdline-tools/cmdline-tools" "${ANDROID_HOME}/cmdline-tools/latest" && \
+    rm /tmp/cmdtools.zip
+
+ENV PATH="${JAVA_HOME}/bin:${ANDROID_HOME}/cmdline-tools/latest/bin:${ANDROID_HOME}/platform-tools:${PATH}"
+
+# ── Android SDK packages ──────────────────────────────────────────────────────
+RUN yes | sdkmanager --licenses > /dev/null && \
+    sdkmanager \
+        "platform-tools" \
+        "platforms;android-${ANDROID_SDK_PLATFORM}" \
+        "build-tools;${ANDROID_SDK_BUILD_TOOLS}"
+
+# ── dotnet android workload (~1 GB, baked into this layer) ───────────────────
+RUN dotnet workload install android
+
+WORKDIR /tmp/build

docker/Dockerfile.desktop

@@ -0,0 +1,11 @@
+FROM mcr.microsoft.com/dotnet/sdk:10.0
+
+# clang and zlib are required by the .NET SDK for native compilation steps
+# that occur even during managed cross-publish (win-x64 / linux-x64).
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        clang \
+        zlib1g-dev \
+        libkrb5-dev \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /tmp/build

docker/README.md

@@ -0,0 +1,199 @@
+# PalladiumWallet — Reproducible Builds via Docker
+
+This folder builds all three distribution targets — **Windows**, **Linux**,
+**Android** — inside Docker containers. The entire toolchain (.NET 10 SDK,
+JDK, Android SDK, android workload) lives in the container images, pinned in
+the Dockerfiles, so:
+
+- **anyone can produce the official binaries** with a single command, on any
+  Linux machine, without installing any SDK on the host;
+- **the toolchain never drifts**: every build uses exactly the same SDK
+  versions, regardless of what is installed (or updated) on the host;
+- **the build environment is auditable**: the Dockerfiles in this folder are
+  the complete, reviewable definition of how release binaries are made — which
+  matters for a wallet, where users must be able to trust that the shipped
+  binary comes from the published source.
+
+> **Scope note:** this pins the *build environment*. Bit-for-bit identical
+> output across machines is a stronger property that .NET does not guarantee
+> by default (embedded timestamps, signing); if two builds of the same commit
+> differ, they differ only in those metadata, not in code.
+
+---
+
+## Prerequisites
+
+A Linux host (native, WSL2, or a VM) with **Docker Engine** installed and
+running. Nothing else — no .NET SDK, no JDK, no Android SDK.
+
+```bash
+# Check that Docker works:
+docker info
+```
+
+If Docker is missing, install it from <https://docs.docker.com/engine/install/>
+(or `sudo apt install docker.io` on Debian/Ubuntu). If `docker info` fails
+with a permission error, add yourself to the `docker` group and start a new
+shell:
+
+```bash
+sudo usermod -aG docker $USER
+```
+
+**Disk space:** ~2 GB for the desktop image, ~7 GB for the Android image
+(SDK + emulator-less toolchain). **First-run time:** the images are built
+automatically on first use — a few minutes for desktop, 10–20 minutes for
+Android (large downloads). Subsequent builds reuse the cached images and take
+well under a minute (desktop) / a few minutes (Android).
+
+**Android release signing:** before the first `android` build, generate the
+persistent signing keystore once — see [`keystore/README.md`](keystore/README.md):
+
+```bash
+./docker/keystore/generate-keystore.sh
+```
+
+Without it, `build_android` refuses to run — every APK must be signed with
+the same key so future releases can update a previous install in place.
+
+---
+
+## Quick start
+
+```bash
+# From the repository root (or from the docker/ folder — both work):
+./docker/build.sh
+```
+
+Running without arguments shows an interactive menu — pick a single target or
+`all`. Non-interactive usage:
+
+```
+./docker/build.sh [TARGET] [--rebuild]
+
+Targets:
+  windows   Win x64 single-file executable (native libs embedded)
+  linux     Linux x64 single-file binary (runs as-is, nothing to install)
+  android   Android APK (release-signed, prompts for keystore passwords)
+  all       All three targets
+
+Options:
+  --rebuild   Force rebuild of the Docker images (needed after editing a Dockerfile)
+```
+
+Examples:
+
+```bash
+./docker/build.sh all               # build everything
+./docker/build.sh windows           # Windows only
+./docker/build.sh android --rebuild # Android, rebuilding the image first
+```
+
+---
+
+## Output — and how to use each artifact
+
+All artifacts land in `dist/` at the repository root. The version number is
+read automatically from `<Version>` in `src/App/PalladiumWallet.App.csproj`.
+
+| Target  | Path                                             |
+|---------|--------------------------------------------------|
+| Windows | `dist/windows/PalladiumWallet-{ver}-win-x64.exe` |
+| Linux   | `dist/linux/PalladiumWallet-{ver}-linux-x64`     |
+| Android | `dist/android/PalladiumWallet-{ver}.apk`         |
+
+**Windows** — a single self-contained `.exe` (runtime and native libraries
+embedded). Copy it to any 64-bit Windows 10/11 machine and double-click.
+The first launch takes a few extra seconds (it unpacks native libraries to a
+per-user cache); later launches are normal. SmartScreen may warn because the
+binary is not code-signed — choose "Run anyway".
+
+**Linux** — a single self-contained binary, already executable. Copy and run:
+
+```bash
+./PalladiumWallet-{ver}-linux-x64
+```
+
+Works on any desktop distro with glibc, X11/Wayland and fontconfig (i.e.
+effectively all of them); no .NET or other packages to install. If you
+transfer it through a channel that strips permissions (e.g. a web download),
+restore the execute bit with `chmod +x`.
+
+**Android** — a release-signed APK for sideloading: transfer it to the phone
+and open it (enable "install from unknown sources" if prompted), or install
+via `adb install dist/android/PalladiumWallet-*.apk`. Supports Android 6.0+
+(API 23), arm64 phones and x86_64 emulators.
+
+> **Signature:** every APK is signed with the persistent keystore in
+> `docker/keystore/` (see [Prerequisites](#prerequisites)), so installing a
+> newer build over an existing one updates it in place — no uninstall, no
+> data loss. This only holds as long as every release keeps using that same
+> keystore file; see `docker/keystore/README.md` for the backup story.
+
+---
+
+## How it works
+
+### Docker images
+
+| Image               | Dockerfile           | Used for        | Size    |
+|---------------------|----------------------|-----------------|---------|
+| `plm-build-desktop` | `Dockerfile.desktop` | windows + linux | ~1.5 GB |
+| `plm-build-android` | `Dockerfile.android` | android         | ~5 GB   |
+
+Images are built automatically the first time a target needs them and reused
+afterwards. Use `--rebuild` only after modifying a Dockerfile.
+
+### Source isolation
+
+The repository is mounted **read-only** inside the container; the build works
+on a copy at `/tmp/build`. Your working tree is never touched — no stray
+`bin/`/`obj/` directories, and a dirty working tree doesn't leak into the
+build beyond the files it contains. Artifacts are written back through a
+bind mount to `dist/` and chown'd to your user.
+
+### NuGet cache
+
+A Docker named volume `plm-nuget-cache` holds downloaded NuGet packages
+across builds. To reclaim the space or force a clean re-download:
+
+```bash
+docker volume rm plm-nuget-cache
+```
+
+---
+
+## Troubleshooting
+
+- **`Docker daemon is not running`** — start it (`sudo systemctl start
+  docker`; on WSL2, start Docker Desktop or the docker service).
+- **Android image build fails downloading `commandlinetools`** — Google
+  rotates the build number in the URL. Update the URL in
+  `Dockerfile.android` to the current one from
+  <https://developer.android.com/studio#command-tools> and rerun with
+  `--rebuild`.
+- **`error XA5207: Could not find android.jar for API level N`** — the .NET
+  android workload moved to a newer API level. Bump
+  `ANDROID_SDK_PLATFORM` (and `ANDROID_SDK_BUILD_TOOLS`) in
+  `Dockerfile.android` to the level the error names, then `--rebuild`.
+- **APK won't install over an existing app
+  (`INSTALL_FAILED_UPDATE_INCOMPATIBLE`)** — the new build wasn't signed with
+  the same keystore as the installed one. Make sure `docker/keystore/release.keystore`
+  hasn't changed since the installed build; if it's genuinely a different key,
+  the user must uninstall the old app first (this deletes app data — back up
+  the wallet seed before doing this).
+- **`build_android` refuses to run, asks to generate a keystore** — run
+  `./docker/keystore/generate-keystore.sh` once (see `docker/keystore/README.md`).
+- **Everything is broken / start from scratch** —
+  `docker system prune -a && docker volume rm plm-nuget-cache`, then rerun
+  the script (images and packages are re-downloaded).
+
+---
+
+## Linux AppImage (future)
+
+The Linux target currently produces a single-file self-contained binary.
+Once a `pupnet.conf` is added to the repository, the `build_linux` function
+in `build.sh` can be extended to call PupNet Deploy inside the same
+`plm-build-desktop` image to also produce an AppImage with desktop
+integration (icon, menu entry).

docker/build.sh

@@ -0,0 +1,235 @@
+#!/usr/bin/env bash
+# Reproducible build script for PalladiumWallet using Docker.
+# Run from anywhere; paths are resolved relative to this script.
+set -euo pipefail
+
+# ── Paths ─────────────────────────────────────────────────────────────────────
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+DIST_DIR="${PROJECT_ROOT}/dist"
+
+# ── Docker image names ────────────────────────────────────────────────────────
+IMAGE_DESKTOP="plm-build-desktop"
+IMAGE_ANDROID="plm-build-android"
+
+# Named volume for NuGet package cache (shared across all builds, survives reboots).
+NUGET_VOLUME="plm-nuget-cache"
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+bold()  { printf '\033[1m%s\033[0m\n' "$*"; }
+info()  { printf '\033[1;34m>>>\033[0m %s\n' "$*"; }
+ok()    { printf '\033[1;32m✓\033[0m  %s\n' "$*"; }
+err()   { printf '\033[1;31m✗\033[0m  %s\n' "$*" >&2; }
+die()   { err "$*"; exit 1; }
+
+usage() {
+    cat <<EOF
+$(bold "Usage:") $(basename "$0") [TARGET] [OPTIONS]
+
+$(bold "Targets:")
+  windows   Win x64 single-file executable  →  dist/windows/
+  linux     Linux x64 single-file binary    →  dist/linux/
+  android   Android APK (release-signed)    →  dist/android/
+  all       All three targets
+
+$(bold "Options:")
+  --rebuild   Force rebuild of Docker images (e.g. after Dockerfile change)
+  -h, --help  Show this help
+
+$(bold "Examples:")
+  $(basename "$0")               # interactive menu
+  $(basename "$0") all           # build everything
+  $(basename "$0") windows       # Windows only
+  $(basename "$0") android --rebuild
+EOF
+}
+
+# ── Argument parsing ──────────────────────────────────────────────────────────
+REBUILD=false
+TARGET=""
+
+for arg in "$@"; do
+    case "$arg" in
+        windows|linux|android|all) TARGET="$arg" ;;
+        --rebuild)                 REBUILD=true ;;
+        -h|--help)                 usage; exit 0 ;;
+        *) err "Unknown argument: $arg"; usage; exit 1 ;;
+    esac
+done
+
+# ── Interactive menu if no target given ───────────────────────────────────────
+if [[ -z "$TARGET" ]]; then
+    bold "PalladiumWallet — reproducible build"
+    echo ""
+    PS3="Select target: "
+    options=("windows" "linux" "android" "all" "quit")
+    select opt in "${options[@]}"; do
+        case "$opt" in
+            windows|linux|android|all) TARGET="$opt"; break ;;
+            quit) echo "Aborted."; exit 0 ;;
+            *) echo "Invalid choice, try again." ;;
+        esac
+    done
+    echo ""
+fi
+
+# ── Preflight checks ──────────────────────────────────────────────────────────
+command -v docker &>/dev/null || die "Docker is not installed or not in PATH."
+docker info &>/dev/null       || die "Docker daemon is not running."
+
+# ── Read project version from csproj ─────────────────────────────────────────
+CSPROJ="${PROJECT_ROOT}/src/App/PalladiumWallet.App.csproj"
+[[ -f "$CSPROJ" ]] || die "Cannot find $CSPROJ — run this script from the repo."
+VERSION=$(grep -oP '(?<=<Version>)[^<]+' "$CSPROJ") || die "Cannot extract <Version> from $CSPROJ."
+info "Version: ${VERSION}"
+
+# ── Ensure NuGet volume exists ────────────────────────────────────────────────
+docker volume inspect "$NUGET_VOLUME" &>/dev/null || \
+    docker volume create "$NUGET_VOLUME" > /dev/null
+
+# ── Image builders ────────────────────────────────────────────────────────────
+ensure_desktop_image() {
+    if [[ "$REBUILD" == true ]] || ! docker image inspect "$IMAGE_DESKTOP" &>/dev/null; then
+        info "Building Docker image: ${IMAGE_DESKTOP}"
+        docker build \
+            --tag "$IMAGE_DESKTOP" \
+            --file "${SCRIPT_DIR}/Dockerfile.desktop" \
+            "${SCRIPT_DIR}"
+    fi
+}
+
+ensure_android_image() {
+    if [[ "$REBUILD" == true ]] || ! docker image inspect "$IMAGE_ANDROID" &>/dev/null; then
+        info "Building Docker image: ${IMAGE_ANDROID}"
+        docker build \
+            --tag "$IMAGE_ANDROID" \
+            --file "${SCRIPT_DIR}/Dockerfile.android" \
+            "${SCRIPT_DIR}"
+    fi
+}
+
+# ── Common docker run wrapper ─────────────────────────────────────────────────
+# $1 = image name, $2 = inline bash commands to execute inside the container.
+# Source is copied to /tmp/build inside the container so bin/obj never pollute
+# the repo. Output is written to /output (→ host DIST_DIR sub-folder).
+# Optional extra `docker run` args (e.g. keystore mount, signing passwords via
+# -e) can be set by the caller in the EXTRA_DOCKER_ARGS array beforehand.
+EXTRA_DOCKER_ARGS=()
+
+run_build() {
+    local image="$1"
+    local commands="$2"
+    local out_dir="$3"
+
+    mkdir -p "$out_dir"
+
+    docker run --rm \
+        --volume "${PROJECT_ROOT}:/src:ro" \
+        --volume "${out_dir}:/output" \
+        --volume "${NUGET_VOLUME}:/root/.nuget/packages" \
+        "${EXTRA_DOCKER_ARGS[@]}" \
+        "$image" \
+        bash -euo pipefail -c "
+            cp -r /src/. /tmp/build
+            cd /tmp/build
+            ${commands}
+            chown -R $(id -u):$(id -g) /output
+        "
+}
+
+# ── Per-target build functions ────────────────────────────────────────────────
+build_windows() {
+    ensure_desktop_image
+    info "Building Windows x64 …"
+    run_build "$IMAGE_DESKTOP" \
+        "dotnet publish src/App.Desktop \
+            -r win-x64 \
+            -c Release \
+            -p:PublishSingleFile=true \
+            -p:IncludeNativeLibrariesForSelfExtract=true \
+            --self-contained \
+            -o /tmp/win-out
+         cp /tmp/win-out/PalladiumWallet.exe \
+            \"/output/PalladiumWallet-${VERSION}-win-x64.exe\"" \
+        "${DIST_DIR}/windows"
+    ok "Windows → dist/windows/PalladiumWallet-${VERSION}-win-x64.exe"
+}
+
+build_linux() {
+    ensure_desktop_image
+    info "Building Linux x64 …"
+    run_build "$IMAGE_DESKTOP" \
+        "dotnet publish src/App.Desktop \
+            -r linux-x64 \
+            -c Release \
+            -p:PublishSingleFile=true \
+            -p:IncludeNativeLibrariesForSelfExtract=true \
+            --self-contained \
+            -o /tmp/linux-out
+         install -m 755 /tmp/linux-out/PalladiumWallet \
+             \"/output/PalladiumWallet-${VERSION}-linux-x64\"" \
+        "${DIST_DIR}/linux"
+    ok "Linux → dist/linux/PalladiumWallet-${VERSION}-linux-x64"
+}
+
+build_android() {
+    ensure_android_image
+
+    local keystore="${SCRIPT_DIR}/keystore/release.keystore"
+    [[ -f "$keystore" ]] || die "No release keystore found at docker/keystore/release.keystore. Run ./docker/keystore/generate-keystore.sh once first (see docker/keystore/README.md)."
+
+    info "Building Android APK …"
+    read -r -s -p "Keystore password: " ANDROID_KS_PASS
+    echo
+    read -r -s -p "Key password (press Enter to reuse the keystore password): " ANDROID_KEY_PASS
+    echo
+    ANDROID_KEY_PASS="${ANDROID_KEY_PASS:-$ANDROID_KS_PASS}"
+
+    # versionCode derived from <Version> (MAJOR.MINOR.PATCH, pre-release suffix
+    # stripped) so it always increases with releases — required for some
+    # installers to accept an in-place update even when the signature matches.
+    local semver="${VERSION%%-*}"
+    IFS='.' read -r VMAJOR VMINOR VPATCH <<< "$semver"
+    local VERSION_CODE=$(( ${VMAJOR:-0} * 10000 + ${VMINOR:-0} * 100 + ${VPATCH:-0} ))
+    info "versionCode: ${VERSION_CODE}"
+
+    EXTRA_DOCKER_ARGS=(
+        --volume "${keystore}:/keystore/release.keystore:ro"
+        --env "ANDROID_KS_PASS=${ANDROID_KS_PASS}"
+        --env "ANDROID_KEY_PASS=${ANDROID_KEY_PASS}"
+    )
+    run_build "$IMAGE_ANDROID" \
+        "JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64 \
+         dotnet build src/App.Android \
+            -c Release \
+            -t:SignAndroidPackage \
+            -p:AndroidSdkDirectory=\${ANDROID_HOME} \
+            -p:ApplicationVersion=${VERSION_CODE} \
+            -p:AndroidSigningKeyStore=/keystore/release.keystore \
+            -p:AndroidSigningKeyAlias=palladiumwallet \
+            -p:AndroidSigningStorePass=\${ANDROID_KS_PASS} \
+            -p:AndroidSigningKeyPass=\${ANDROID_KEY_PASS}
+         cp src/App.Android/bin/Release/net10.0-android/*-Signed.apk \
+            \"/output/PalladiumWallet-${VERSION}.apk\"" \
+        "${DIST_DIR}/android"
+    EXTRA_DOCKER_ARGS=()
+    ok "Android → dist/android/PalladiumWallet-${VERSION}.apk"
+}
+
+# ── Dispatch ──────────────────────────────────────────────────────────────────
+START=$(date +%s)
+
+case "$TARGET" in
+    windows) build_windows ;;
+    linux)   build_linux   ;;
+    android) build_android ;;
+    all)
+        build_windows
+        build_linux
+        build_android
+        ;;
+esac
+
+ELAPSED=$(( $(date +%s) - START ))
+bold ""
+bold "Done in ${ELAPSED}s.  Artifacts in: ${DIST_DIR}/"

docker/keystore/README.md

@@ -0,0 +1,37 @@
+# Android release-signing keystore
+
+This folder holds the persistent keystore used to sign release APKs built by
+`docker/build.sh android`. Every release must be signed with the **same**
+key, or Android refuses to install a new build over a previously installed
+one (`INSTALL_FAILED_UPDATE_INCOMPATIBLE`) and forces the user to uninstall
+first — which deletes the app's data.
+
+## First-time setup
+
+```bash
+./docker/keystore/generate-keystore.sh
+```
+
+Run this **once**, on whichever machine will keep producing release builds.
+It creates `release.keystore` in this folder and asks for a keystore
+password (and, optionally, a separate key password). Nothing is written to
+git — `release.keystore` is ignored by `.gitignore`, and the script never
+saves the passwords anywhere.
+
+`docker/build.sh android` will refuse to run without this file, and will
+prompt you for the same passwords at every build.
+
+## Back it up
+
+The keystore file and its passwords cannot be regenerated: if lost, no
+future release can ever update existing installs in place again — every
+user would need to uninstall and reinstall from scratch. Copy
+`release.keystore` and the passwords to a password manager or encrypted
+backup outside this repository as soon as you generate them.
+
+## What NOT to do
+
+- Do not commit `release.keystore` (or any `*.jks`/`*.keystore` file) to git.
+- Do not re-run `generate-keystore.sh` once a keystore already exists — it
+  refuses on purpose; delete the file yourself only if you fully accept the
+  consequences above.

docker/keystore/generate-keystore.sh

@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# Generates the persistent Android release-signing keystore used by
+# docker/build.sh. Every APK built with this keystore carries the same
+# signature, which is what lets Android treat a new release as an update to
+# a previously installed one instead of a conflicting, different app.
+#
+# Run this ONCE. Re-running it after the keystore already exists is refused
+# below on purpose: regenerating it changes the signature, and every device
+# with a prior release installed would then need a full uninstall (and lose
+# any app data that isn't in the wallet file itself) to receive the next
+# update.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+KEYSTORE_PATH="${SCRIPT_DIR}/release.keystore"
+ALIAS="palladiumwallet"
+
+if [[ -f "$KEYSTORE_PATH" ]]; then
+    echo "A keystore already exists at $KEYSTORE_PATH — refusing to overwrite it." >&2
+    echo "Delete it manually first only if you understand the consequences above." >&2
+    exit 1
+fi
+
+command -v keytool &>/dev/null || {
+    echo "keytool not found on PATH — install a JDK (e.g. openjdk-17-jdk) and retry." >&2
+    exit 1
+}
+
+echo "Creating the Palladium Wallet Android release-signing keystore."
+echo "This file and the passwords you enter now must be kept safe OUTSIDE this"
+echo "repository (password manager, encrypted backup, ...). They are never"
+echo "committed to git. Losing them means no future release can ever update"
+echo "existing installs in place — only a fresh keystore + full user reinstall."
+echo
+
+read -r -s -p "Keystore password (min 6 characters): " KS_PASS
+echo
+read -r -s -p "Confirm keystore password: " KS_PASS_CONFIRM
+echo
+if [[ "$KS_PASS" != "$KS_PASS_CONFIRM" ]]; then
+    echo "Passwords do not match." >&2
+    exit 1
+fi
+if [[ "${#KS_PASS}" -lt 6 ]]; then
+    echo "Password too short (keytool requires at least 6 characters)." >&2
+    exit 1
+fi
+
+read -r -s -p "Key password (press Enter to reuse the keystore password): " KEY_PASS
+echo
+KEY_PASS="${KEY_PASS:-$KS_PASS}"
+
+export KS_PASS KEY_PASS
+keytool -genkeypair -v \
+    -keystore "$KEYSTORE_PATH" \
+    -alias "$ALIAS" \
+    -keyalg RSA -keysize 2048 -validity 10000 \
+    -storepass:env KS_PASS -keypass:env KEY_PASS \
+    -dname "CN=PalladiumWallet, OU=PalladiumWallet, O=PalladiumWallet, C=IT"
+unset KS_PASS KEY_PASS
+
+echo
+echo "Keystore created at $KEYSTORE_PATH (git-ignored, alias: $ALIAS)."
+echo "Back it up now, together with the passwords — it cannot be regenerated."
+echo "./docker/build.sh android will prompt for these same passwords at build time."

src/App.Android/MainActivity.cs

@@ -0,0 +1,37 @@
+using System.Threading.Tasks;
+using Android.App;
+using Android.Content;
+using Android.Content.PM;
+using Android.OS;
+using Avalonia.Android;
+
+namespace PalladiumWallet.Mobile;
+
+[Activity(
+    Label = "Palladium Wallet",
+    Theme = "@style/MyTheme.NoActionBar",
+    MainLauncher = true,
+    ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize | ConfigChanges.UiMode)]
+public class MainActivity : AvaloniaMainActivity
+{
+    internal const int ScanRequestCode = 9001;
+    internal static TaskCompletionSource<string?>? ScanTcs;
+    internal static MainActivity? Current;
+
+    protected override void OnCreate(Bundle? savedInstanceState)
+    {
+        base.OnCreate(savedInstanceState);
+        Current = this;
+    }
+
+    protected override void OnActivityResult(int requestCode, Result resultCode, Intent? data)
+    {
+        base.OnActivityResult(requestCode, resultCode, data);
+        if (requestCode == ScanRequestCode)
+        {
+            var text = resultCode == Result.Ok ? data?.GetStringExtra(ScannerActivity.ResultKey) : null;
+            ScanTcs?.TrySetResult(text);
+            ScanTcs = null;
+        }
+    }
+}

src/App.Android/MainApplication.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Threading.Tasks;
+using Android.App;
+using Android.Content;
+using Android.Runtime;
+using Avalonia;
+using Avalonia.Android;
+using PalladiumWallet.App.Services;
+using PalladiumWallet.Core.Storage;
+
+namespace PalladiumWallet.Mobile;
+
+// In Avalonia 12 the Android AppBuilder is configured in the Application subclass
+// (AvaloniaAndroidApplication<TApp>), no longer in the Activity. allowBackup=false:
+// the encrypted wallet file/seed must not end up in automatic cloud backups.
+[Application(Label = "Palladium Wallet", AllowBackup = false,
+             Icon = "@mipmap/ic_launcher", RoundIcon = "@mipmap/ic_launcher_round")]
+public class MainApplication : AvaloniaAndroidApplication<global::PalladiumWallet.App.App>
+{
+    public MainApplication(IntPtr javaReference, JniHandleOwnership transfer)
+        : base(javaReference, transfer)
+    {
+    }
+
+    public override void OnCreate()
+    {
+        AppPaths.OverrideDataRoot = FilesDir?.AbsolutePath;
+
+        // Registers the QR scanner: opens ScannerActivity and waits for its result.
+        PlatformServices.ScanQrAsync = async () =>
+        {
+            var activity = MainActivity.Current;
+            if (activity == null) return null;
+            var tcs = new TaskCompletionSource<string?>();
+            MainActivity.ScanTcs = tcs;
+            activity.StartActivityForResult(
+                new Intent(activity, typeof(ScannerActivity)),
+                MainActivity.ScanRequestCode);
+            return await tcs.Task;
+        };
+
+        base.OnCreate();
+    }
+
+    protected override AppBuilder CustomizeAppBuilder(AppBuilder builder) =>
+        base.CustomizeAppBuilder(builder).WithInterFont();
+}

src/App.Android/PalladiumWallet.App.Android.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Head Android: entry-point e pacchetti specifici. La UI vera vive nella
+       libreria condivisa PalladiumWallet.App (stessa di desktop). -->
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net10.0-android</TargetFramework>
+    <SupportedOSPlatformVersion>23</SupportedOSPlatformVersion>
+    <Nullable>enable</Nullable>
+    <ApplicationId>io.github.davide3011.palladiumwallet</ApplicationId>
+    <!-- ApplicationVersion = versionCode (intero), ApplicationDisplayVersion = versionName -->
+    <ApplicationVersion>1</ApplicationVersion>
+    <ApplicationDisplayVersion>0.9.0</ApplicationDisplayVersion>
+    <AndroidPackageFormat>apk</AndroidPackageFormat>
+    <!-- Includi le assembly .NET DENTRO l'apk: senza, in Debug si usa il Fast
+         Deployment (assembly spinte via adb da `dotnet run`) e un apk installato
+         a mano — sideload sul telefono o `adb install` — crasha all'avvio con
+         "monodroid: No assemblies found ... Exiting". Così l'apk è autosufficiente. -->
+    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk>
+    <!-- Default: ABI multiple (l'apk gira sia su emulatore x86_64 sia su telefoni arm64).
+         Per un apk più piccolo solo-telefono: aggiungi -p:AbiArm64Only=true alla build. -->
+    <RuntimeIdentifiers Condition="'$(AbiArm64Only)' == 'true'">android-arm64</RuntimeIdentifiers>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia.Android" Version="12.0.4" />
+    <PackageReference Include="ZXing.Net" Version="0.16.9" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\App\PalladiumWallet.App.csproj" />
+  </ItemGroup>
+</Project>

src/App.Android/Properties/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+	<!-- Necessario per parlare col server di indicizzazione (TCP/TLS).
+	     L'elemento <application> (label, allowBackup) è generato dall'attributo
+	     [Application] su MainApplication. usesCleartextTraffic resta al default
+	     (bloccato su Android 9+): il wallet preferisce comunque TLS. -->
+	<uses-permission android:name="android.permission.INTERNET" />
+	<uses-permission android:name="android.permission.CAMERA" />
+	<uses-feature android:name="android.hardware.camera" android:required="false" />
+</manifest>

src/App.Android/Resources/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

src/App.Android/Resources/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+</adaptive-icon>

src/App.Android/Resources/values/ic_launcher_background.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="ic_launcher_background">#FFFFFF</color>
+</resources>

src/App.Android/Resources/values/styles.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- DEVE derivare da Theme.AppCompat: AvaloniaActivity estende AppCompatActivity,
+         che con un tema non-AppCompat lancia IllegalStateException all'avvio.
+         Avalonia disegna comunque l'intera UI (NoActionBar). -->
+    <style name="MyTheme.NoActionBar" parent="Theme.AppCompat.Light.NoActionBar" />
+</resources>

src/App.Android/ScannerActivity.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Android.App;
+using Android.Content;
+using Android.Graphics;
+using Android.Hardware.Camera2;
+using Android.Media;
+using Android.OS;
+using Android.Views;
+using Android.Widget;
+using ZXing;
+using ZXing.Common;
+using AndroidResult = Android.App.Result;
+
+namespace PalladiumWallet.Mobile;
+
+/// <summary>
+/// Full-screen activity for QR scanning via Camera2 + ZXing.Net.
+/// Returns to MainActivity via SetResult with the extra "qr" = code text.
+/// </summary>
+[Activity(Theme = "@style/MyTheme.NoActionBar",
+          ScreenOrientation = Android.Content.PM.ScreenOrientation.Portrait)]
+internal sealed class ScannerActivity : Activity, TextureView.ISurfaceTextureListener
+{
+    internal const string ResultKey = "qr";
+    private const int PermReq = 1;
+
+    private HandlerThread? _bgThread;
+    private Handler? _bgHandler;
+    private CameraDevice? _camera;
+    private CameraCaptureSession? _session;
+    private ImageReader? _imageReader;
+    private SurfaceTexture? _surfaceTex;
+    private bool _permOk;
+    private volatile bool _done;
+    private long _lastDecode;
+
+    protected override void OnCreate(Bundle? savedInstanceState)
+    {
+        base.OnCreate(savedInstanceState);
+        Window!.SetFlags(WindowManagerFlags.Fullscreen, WindowManagerFlags.Fullscreen);
+
+        var root = new FrameLayout(this);
+
+        var preview = new TextureView(this) { SurfaceTextureListener = this };
+        root.AddView(preview, new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MatchParent, FrameLayout.LayoutParams.MatchParent));
+
+        var hint = new TextView(this) { Text = "Inquadra un codice QR" };
+        hint.SetTextColor(Color.White);
+        hint.SetBackgroundColor(Color.ParseColor("#AA000000"));
+        hint.SetPadding(24, 12, 24, 12);
+        root.AddView(hint, new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.WrapContent, FrameLayout.LayoutParams.WrapContent,
+            GravityFlags.Top | GravityFlags.CenterHorizontal) { TopMargin = 60 });
+
+        var cancel = new Button(this) { Text = "Annulla" };
+        cancel.Click += (_, _) => Finish();
+        root.AddView(cancel, new FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.WrapContent, FrameLayout.LayoutParams.WrapContent,
+            GravityFlags.Bottom | GravityFlags.CenterHorizontal) { BottomMargin = 80 });
+
+        SetContentView(root);
+
+        _bgThread = new HandlerThread("CamBg");
+        _bgThread.Start();
+        _bgHandler = new Handler(_bgThread.Looper!);
+
+        if (CheckSelfPermission(Android.Manifest.Permission.Camera) == Android.Content.PM.Permission.Granted)
+            _permOk = true;
+        else
+            RequestPermissions([Android.Manifest.Permission.Camera], PermReq);
+    }
+
+    public override void OnRequestPermissionsResult(int req, string[] perms, Android.Content.PM.Permission[] grants)
+    {
+        _permOk = grants.Length > 0 && grants[0] == Android.Content.PM.Permission.Granted;
+        if (_permOk) TryOpen(); else Finish();
+    }
+
+    public void OnSurfaceTextureAvailable(SurfaceTexture st, int w, int h) { _surfaceTex = st; TryOpen(); }
+    public bool OnSurfaceTextureDestroyed(SurfaceTexture st) { CloseCamera(); return true; }
+    public void OnSurfaceTextureSizeChanged(SurfaceTexture st, int w, int h) { }
+    public void OnSurfaceTextureUpdated(SurfaceTexture st) { }
+
+    private void TryOpen() { if (_permOk && _surfaceTex != null) OpenCamera(_surfaceTex); }
+
+    private void OpenCamera(SurfaceTexture st)
+    {
+        var mgr = (CameraManager)GetSystemService(CameraService)!;
+
+        var ids = mgr.GetCameraIdList()!;
+        string cameraId = ids[0];
+        foreach (var id in ids)
+        {
+            var chars = mgr.GetCameraCharacteristics(id)!;
+            if (chars.Get(CameraCharacteristics.LensFacing) is Java.Lang.Integer f
+                && f.IntValue() == (int)LensFacing.Back)
+            { cameraId = id; break; }
+        }
+
+        var map = mgr.GetCameraCharacteristics(cameraId)!
+                     .Get(CameraCharacteristics.ScalerStreamConfigurationMap)
+                  as Android.Hardware.Camera2.Params.StreamConfigurationMap;
+        var allSizes = map!.GetOutputSizes((int)ImageFormatType.Jpeg)!;
+        var size = allSizes.OrderBy(s => Math.Abs(s.Width - 640)).First();
+
+        st.SetDefaultBufferSize(size.Width, size.Height);
+        _imageReader = ImageReader.NewInstance(size.Width, size.Height, ImageFormatType.Jpeg, 2);
+        _imageReader.SetOnImageAvailableListener(new ImageListener(this), _bgHandler);
+
+        mgr.OpenCamera(cameraId, new OpenCb(this, st), _bgHandler);
+    }
+
+    private void CloseCamera()
+    {
+        _session?.Close();  _session = null;
+        _camera?.Close();   _camera  = null;
+        _imageReader?.Close(); _imageReader = null;
+        _bgThread?.QuitSafely();
+    }
+
+    internal void OnCameraOpened(CameraDevice dev, SurfaceTexture st)
+    {
+        _camera = dev;
+        var prevSurf = new Surface(st);
+        var capSurf  = _imageReader!.Surface!;
+#pragma warning disable CA1422 // CreateCaptureSession(IList,...) obsoleted on API 30; replacement needs API 28, our min is 23
+        dev.CreateCaptureSession([prevSurf, capSurf], new SessionCb(this, prevSurf, capSurf), _bgHandler);
+#pragma warning restore CA1422
+    }
+
+    internal void OnSessionReady(CameraCaptureSession session, Surface prev, Surface cap)
+    {
+        _session = session;
+        var req = _camera!.CreateCaptureRequest(CameraTemplate.Preview);
+        req.AddTarget(prev);
+        req.AddTarget(cap);
+        session.SetRepeatingRequest(req.Build()!, null, _bgHandler);
+    }
+
+    internal void TryDecode(ImageReader reader)
+    {
+        if (_done) return;
+        var image = reader.AcquireLatestImage();
+        if (image == null) return;
+        try
+        {
+            var now = SystemClock.ElapsedRealtime();
+            if (now - _lastDecode < 400) return; // max ~2.5 fps
+            _lastDecode = now;
+
+            var buf = image.GetPlanes()![0].Buffer!;
+            var bytes = new byte[buf.Remaining()];
+            buf.Get(bytes);
+
+            var bmp = BitmapFactory.DecodeByteArray(bytes, 0, bytes.Length);
+            if (bmp == null) return;
+            int w = bmp.Width, h = bmp.Height;
+            var pixels = new int[w * h];
+            bmp.GetPixels(pixels, 0, w, 0, 0, w, h);
+            bmp.Recycle();
+
+            // ARGB int[] → RGB byte[] for ZXing.RGBLuminanceSource
+            var rgb = new byte[pixels.Length * 3];
+            for (int i = 0; i < pixels.Length; i++)
+            {
+                rgb[i * 3]     = (byte)(pixels[i] >> 16);
+                rgb[i * 3 + 1] = (byte)(pixels[i] >> 8);
+                rgb[i * 3 + 2] = (byte) pixels[i];
+            }
+
+            var source = new RGBLuminanceSource(rgb, w, h, RGBLuminanceSource.BitmapFormat.RGB24);
+            var zreader = new BarcodeReaderGeneric { AutoRotate = true };
+            zreader.Options.PossibleFormats = [BarcodeFormat.QR_CODE];
+            zreader.Options.TryHarder = true;
+            var result = zreader.Decode(source);
+            if (result == null) return;
+
+            _done = true;
+            RunOnUiThread(() =>
+            {
+                var intent = new Intent().PutExtra(ResultKey, result.Text);
+                SetResult(AndroidResult.Ok, intent);
+                Finish();
+            });
+        }
+        finally { image.Close(); }
+    }
+
+    protected override void OnDestroy()
+    {
+        CloseCamera();
+        base.OnDestroy();
+    }
+
+    // ── Callback helpers ─────────────────────────────────────────────────
+
+    private sealed class OpenCb(ScannerActivity a, SurfaceTexture st) : CameraDevice.StateCallback
+    {
+        public override void OnOpened(CameraDevice cam) => a.OnCameraOpened(cam, st);
+        public override void OnDisconnected(CameraDevice cam) { cam.Close(); a.Finish(); }
+        public override void OnError(CameraDevice cam, CameraError err) { cam.Close(); a.Finish(); }
+    }
+
+    private sealed class SessionCb(ScannerActivity a, Surface prev, Surface cap) : CameraCaptureSession.StateCallback
+    {
+        public override void OnConfigured(CameraCaptureSession s) => a.OnSessionReady(s, prev, cap);
+        public override void OnConfigureFailed(CameraCaptureSession s) => a.Finish();
+    }
+
+    private sealed class ImageListener(ScannerActivity a) : Java.Lang.Object, ImageReader.IOnImageAvailableListener
+    {
+        // Interface declares ImageReader? but reader is never null in practice
+        public void OnImageAvailable(ImageReader? reader) => a.TryDecode(reader!);
+    }
+}

src/App.Desktop/PalladiumWallet.App.Desktop.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Head Desktop (Windows/Linux): entry-point e pacchetti specifici del
+       desktop. La UI vera vive nella libreria condivisa PalladiumWallet.App. -->
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <ApplicationIcon>..\App\Assets\logo.ico</ApplicationIcon>
+    <AssemblyName>PalladiumWallet</AssemblyName>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia" Version="12.0.4" />
+    <PackageReference Include="Avalonia.Desktop" Version="12.0.4" />
+    <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.2.1">
+      <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
+      <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\App\PalladiumWallet.App.csproj" />
+  </ItemGroup>
+</Project>

src/App/App.axaml

@@ -8,8 +8,20 @@
     <Application.DataTemplates>
         <local:ViewLocator/>
     </Application.DataTemplates>
-  
+
+    <!-- Semantic design tokens (colors, radii, brand accent): defined for
+         both light/dark variants. See Styles/Theme.axaml. -->
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceInclude Source="/Styles/Theme.axaml"/>
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+    </Application.Resources>
+
     <Application.Styles>
         <FluentTheme />
+        <!-- Control refinements and reusable classes (on top of Fluent) -->
+        <StyleInclude Source="/Styles/Controls.axaml"/>
     </Application.Styles>
 </Application>

src/App/App.axaml.cs

@@ -1,31 +1,34 @@
-using Avalonia;
-using Avalonia.Controls.ApplicationLifetimes;
-using Avalonia.Data.Core;
-using Avalonia.Data.Core.Plugins;
-using System.Linq;
-using Avalonia.Markup.Xaml;
-using PalladiumWallet.App.ViewModels;
-using PalladiumWallet.App.Views;
-
-namespace PalladiumWallet.App;
-
-public partial class App : Application
-{
-    public override void Initialize()
-    {
-        AvaloniaXamlLoader.Load(this);
-    }
-
-    public override void OnFrameworkInitializationCompleted()
-    {
-        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
-        {
-            desktop.MainWindow = new MainWindow
-            {
-                DataContext = new MainWindowViewModel(),
-            };
-        }
-
-        base.OnFrameworkInitializationCompleted();
-    }
-}
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using PalladiumWallet.App.ViewModels;
+using PalladiumWallet.App.Views;
+
+namespace PalladiumWallet.App;
+
+public partial class App : Application
+{
+    public override void Initialize()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+
+    public override void OnFrameworkInitializationCompleted()
+    {
+        var vm = new MainWindowViewModel();
+
+        // Desktop (Windows/Linux): classic window. Mobile (Android): single
+        // view. Same shared UI (MainView) and same ViewModel.
+        switch (ApplicationLifetime)
+        {
+            case IClassicDesktopStyleApplicationLifetime desktop:
+                desktop.MainWindow = new MainWindow { DataContext = vm };
+                break;
+            case ISingleViewApplicationLifetime singleView:
+                singleView.MainView = new MainView { DataContext = vm };
+                break;
+        }
+
+        base.OnFrameworkInitializationCompleted();
+    }
+}

src/App/Localization/Loc.cs

@@ -3,9 +3,9 @@ using System.Collections.Generic;
 namespace PalladiumWallet.App.Localization;
 
 /// <summary>
-/// Localizzazione UI: dizionario chiave → traduzioni per lingua, con
-/// indicizzatore bindabile da XAML ({Binding Loc[chiave]}). Al cambio lingua
-/// il ViewModel sostituisce l'istanza così Avalonia rivaluta tutte le binding.
+/// UI localisation: key → per-language translations dictionary, with an
+/// indexer bindable from XAML ({Binding Loc[key]}). On language change the
+/// ViewModel replaces the instance so Avalonia re-evaluates all bindings.
 /// </summary>
 public sealed class Loc
 {
@@ -20,10 +20,10 @@ public sealed class Loc
     private Loc(string language) { Language = language; }
 
     /// <summary>
-    /// Crea una nuova istanza con la lingua specificata e aggiorna il singleton
-    /// usato da <see cref="Tr"/>. Il ViewModel assegna questa istanza alla
-    /// propria property Loc così Avalonia vede un riferimento diverso e
-    /// rivaluta tutte le binding {Binding Loc[chiave]}.
+    /// Creates a new instance for the specified language and updates the singleton
+    /// used by <see cref="Tr"/>. The ViewModel assigns this instance to its Loc
+    /// property so Avalonia sees a different reference and re-evaluates all
+    /// {Binding Loc[key]} bindings.
     /// </summary>
     internal static Loc SwitchTo(string language)
     {
@@ -45,21 +45,39 @@ public sealed class Loc
         // Menu                                                it                                          en                              es                                      fr                                          pt                                          de
         ["menu.file"]             = ["_File",                                                             "_File",                        "_Archivo",                             "_Fichier",                                 "_Arquivo",                                 "_Datei"],
         ["menu.file.new"]         = ["Nuovo / ripristina wallet…",                                        "New / restore wallet…",        "Nuevo / restaurar wallet…",            "Nouveau / restaurer le wallet…",           "Novo / restaurar carteira…",               "Neu / Wallet wiederherstellen…"],
-        ["menu.file.open"]        = ["Apri wallet da file…",                                              "Open wallet from file…",       "Abrir wallet desde archivo…",          "Ouvrir le wallet depuis un fichier…",      "Abrir carteira de arquivo…",               "Wallet aus Datei öffnen…"],
-        ["menu.file.close"]       = ["Chiudi wallet",                                                     "Close wallet",                 "Cerrar wallet",                        "Fermer le wallet",                         "Fechar carteira",                          "Wallet schließen"],
+["menu.file.close"]       = ["Chiudi wallet",                                                     "Close wallet",                 "Cerrar wallet",                        "Fermer le wallet",                         "Fechar carteira",                          "Wallet schließen"],
+        ["menu.file.quit"]        = ["Esci",                                                               "Quit",                         "Salir",                                "Quitter",                                  "Sair",                                     "Beenden"],
         ["menu.net"]              = ["_Rete",                                                             "_Network",                     "_Red",                                 "_Réseau",                                  "_Rede",                                    "_Netzwerk"],
         ["menu.net.discover"]     = ["Cerca altri server (peer)",                                         "Discover servers (peers)",     "Buscar otros servidores (peers)",      "Rechercher d'autres serveurs (pairs)",     "Procurar outros servidores (peers)",        "Weitere Server suchen (Peers)"],
         ["menu.net.resetcerts"]   = ["Reset certificati SSL",                                             "Reset SSL certificates",       "Restablecer certificados SSL",         "Réinitialiser les certificats SSL",        "Redefinir certificados SSL",               "SSL-Zertifikate zurücksetzen"],
         ["menu.settings"]         = ["_Impostazioni",                                                     "_Settings",                    "_Configuración",                       "_Paramètres",                              "_Configurações",                           "_Einstellungen"],
         ["menu.help"]             = ["_Help",                                                             "_Help",                        "_Ayuda",                               "_Aide",                                    "_Ajuda",                                   "_Hilfe"],
-        ["help.title"]            = ["Informazioni sul software",                                         "About this software",          "Información del software",             "À propos du logiciel",                     "Sobre o software",                         "Über die Software"],
+        ["help.title"]            = ["Informazioni",                                                     "About",                        "Información",                          "À propos",                                 "Sobre",                                    "Über"],
         ["help.info"]             = [
-            "Wallet SPV per la criptovaluta Palladium (PLM).",
-            "SPV wallet for the Palladium (PLM) cryptocurrency.",
-            "Monedero SPV para la criptomoneda Palladium (PLM).",
-            "Portefeuille SPV pour la cryptomonnaie Palladium (PLM).",
-            "Carteira SPV para a criptomoeda Palladium (PLM).",
-            "SPV-Wallet für die Kryptowährung Palladium (PLM)."],
+            "Wallet SPV leggero e non-custodiale per la rete Palladium (PLM). Sicurezza locale: seed e chiavi sempre cifrati, mai esposti in rete.",
+            "Lightweight, non-custodial SPV wallet for the Palladium (PLM) network. Local security: seed and keys always encrypted, never exposed on the wire.",
+            "Monedero SPV ligero y sin custodia para la red Palladium (PLM). Seguridad local: semilla y claves siempre cifradas, nunca expuestas en la red.",
+            "Portefeuille SPV léger et non-custodial pour le réseau Palladium (PLM). Sécurité locale : graine et clés toujours chiffrées, jamais exposées sur le réseau.",
+            "Carteira SPV leve e não custodial para a rede Palladium (PLM). Segurança local: semente e chaves sempre cifradas, nunca expostas na rede.",
+            "Leichtes, nicht-verwahrendes SPV-Wallet für das Palladium (PLM)-Netzwerk. Lokale Sicherheit: Seed und Schlüssel stets verschlüsselt, nie im Netzwerk exponiert."],
+        ["help.tab.info"]         = ["Info",                                                               "Info",                         "Info",                                 "Info",                                     "Info",                                     "Info"],
+        ["help.tab.donate"]       = ["Dona",                                                               "Donate",                       "Donar",                                "Faire un don",                             "Doar",                                     "Spenden"],
+        ["help.bug.report"]       = ["Segnala un bug",                                                     "Report a bug",                 "Informar un error",                    "Signaler un bug",                          "Reportar um bug",                          "Fehler melden"],
+        ["update.title"]          = ["Aggiornamento disponibile",                                          "Update available",             "Actualización disponible",             "Mise à jour disponible",                   "Atualização disponível",                   "Update verfügbar"],
+        ["update.message"]        = ["È disponibile una nuova versione:",                                  "A new version is available:",  "Hay una nueva versión disponible:",    "Une nouvelle version est disponible :",    "Uma nova versão está disponível:",         "Eine neue Version ist verfügbar:"],
+        ["update.download"]       = ["Scarica",                                                            "Download",                     "Descargar",                            "Télécharger",                              "Baixar",                                   "Herunterladen"],
+        ["update.dismiss"]        = ["Ignora",                                                              "Dismiss",                      "Ignorar",                               "Ignorer",                                  "Ignorar",                                  "Verwerfen"],
+        ["donate.desc"]           = [
+            "Se questo wallet ti è utile, considera una piccola donazione allo sviluppatore.",
+            "If you find this wallet useful, consider a small donation to the developer.",
+            "Si esta wallet te resulta útil, considera una pequeña donación al desarrollador.",
+            "Si ce portefeuille vous est utile, envisagez un petit don au développeur.",
+            "Se esta carteira é útil para você, considere uma pequena doação ao desenvolvedor.",
+            "Wenn Ihnen dieses Wallet nützlich ist, erwägen Sie eine kleine Spende an den Entwickler."],
+        ["donate.dev.address"]    = ["Indirizzo sviluppatore",                                             "Developer address",            "Dirección del desarrollador",          "Adresse du développeur",                   "Endereço do desenvolvedor",                "Entwickleradresse"],
+        ["donate.amount"]         = ["Importo donazione",                                                  "Donation amount",              "Monto de donación",                    "Montant du don",                           "Valor da doação",                          "Spendenbetrag"],
+        ["donate.prepare"]        = ["Prepara donazione",                                                  "Prepare donation",             "Preparar donación",                    "Préparer le don",                          "Preparar doação",                          "Spende vorbereiten"],
+        ["donate.confirm"]        = ["Conferma e invia",                                                   "Confirm and send",             "Confirmar y enviar",                   "Confirmer et envoyer",                     "Confirmar e enviar",                       "Bestätigen und senden"],
         ["settings.unit.short"]   = ["Unità",                                                             "Unit",                         "Unidad",                               "Unité",                                    "Unidade",                                  "Einheit"],
 
         // Wizard
@@ -75,10 +93,11 @@ public sealed class Loc
         ["wiz.data.usedefault"]   = ["Usa il percorso predefinito",                                       "Use the default path",         "Usar la ruta predeterminada",          "Utiliser le chemin par défaut",            "Usar o caminho padrão",                    "Standardpfad verwenden"],
         ["wiz.data.choose"]       = ["Scegli una cartella…",                                              "Choose a folder…",             "Elegir una carpeta…",                  "Choisir un dossier…",                      "Escolher uma pasta…",                      "Ordner wählen…"],
         ["wiz.choose.title"]      = ["Scegli il wallet da aprire",                                        "Choose the wallet to open",    "Elige el wallet a abrir",              "Choisissez le wallet à ouvrir",            "Escolha a carteira a abrir",               "Wallet zum Öffnen wählen"],
-        ["wiz.net"]               = ["Rete:",                                                             "Network:",                     "Red:",                                 "Réseau :",                                 "Rede:",                                    "Netzwerk:"],
-        ["wiz.open.btn"]          = ["Apri il wallet esistente",                                          "Open existing wallet",         "Abrir wallet existente",               "Ouvrir le wallet existant",                "Abrir carteira existente",                 "Vorhandenes Wallet öffnen"],
+["wiz.open.btn"]          = ["Apri il wallet esistente",                                          "Open existing wallet",         "Abrir wallet existente",               "Ouvrir le wallet existant",                "Abrir carteira existente",                 "Vorhandenes Wallet öffnen"],
         ["wiz.new.btn"]           = ["Crea un nuovo wallet",                                              "Create a new wallet",          "Crear nuevo wallet",                   "Créer un nouveau wallet",                  "Criar nova carteira",                      "Neues Wallet erstellen"],
         ["wiz.restore.btn"]       = ["Ripristina da seed",                                                "Restore from seed",            "Restaurar desde semilla",              "Restaurer depuis la graine",               "Restaurar da semente",                     "Aus Seed wiederherstellen"],
+        ["wiz.importxkey.btn"]    = ["Importa xpub / xprv",                                               "Import xpub / xprv",           "Importar xpub / xprv",                 "Importer xpub / xprv",                     "Importar xpub / xprv",                     "xpub / xprv importieren"],
+        ["wiz.importwif.btn"]     = ["Importa chiave WIF",                                                 "Import WIF key",               "Importar clave WIF",                   "Importer clé WIF",                         "Importar chave WIF",                       "WIF-Schlüssel importieren"],
         ["wiz.open.title"]        = ["Apri il wallet",                                                    "Open the wallet",              "Abrir el wallet",                      "Ouvrir le wallet",                         "Abrir a carteira",                         "Wallet öffnen"],
         ["wiz.open.placeholder"]  = ["Password del file (vuoto se non impostata)",                        "File password (empty if not set)", "Contraseña del archivo (vacío si no establecida)", "Mot de passe du fichier (vide si non défini)", "Senha do arquivo (vazio se não definida)", "Dateipasswort (leer lassen, wenn nicht gesetzt)"],
         ["wiz.open.ok"]           = ["Apri",                                                              "Open",                         "Abrir",                                "Ouvrir",                                   "Abrir",                                    "Öffnen"],
@@ -97,6 +116,9 @@ public sealed class Loc
         ["wiz.words.placeholder"] = ["Mnemonica BIP39 (12 o 24 parole separate da spazi)",               "BIP39 mnemonic (12 or 24 words separated by spaces)", "Mnemónico BIP39 (12 o 24 palabras separadas por espacios)", "Mnémonique BIP39 (12 ou 24 mots séparés par des espaces)", "Mnemônico BIP39 (12 ou 24 palavras separadas por espaços)", "BIP39-Mnemonic (12 oder 24 durch Leerzeichen getrennte Wörter)"],
         ["wiz.passphrase.title"]  = ["Passphrase opzionale",                                              "Optional passphrase",          "Frase de contraseña opcional",         "Phrase de passe optionnelle",              "Frase-senha opcional",                     "Optionale Passphrase"],
         ["wiz.passphrase.placeholder"] = ["Lascia vuoto per non usarla",                                  "Leave empty to skip",          "Deja vacío para omitir",               "Laisser vide pour ignorer",                "Deixe vazio para ignorar",                 "Leer lassen zum Überspringen"],
+        ["wiz.name.label"]        = ["Nome wallet (opzionale)",                                           "Wallet name (optional)",       "Nombre del wallet (opcional)",         "Nom du wallet (optionnel)",                "Nome da carteira (opcional)",              "Wallet-Name (optional)"],
+        ["wiz.name.placeholder"]  = ["es. risparmio, trading… (lascia vuoto per nome automatico)",        "e.g. savings, trading… (leave blank for auto name)", "p.ej. ahorro, trading… (deja en blanco para nombre automático)", "ex. épargne, trading… (laisser vide pour nom automatique)", "ex. poupança, trading… (deixe em branco para nome automático)", "z.B. Sparen, Trading… (leer lassen für automatischen Namen)"],
+        ["msg.wallet.exists"]     = ["Esiste già un wallet con questo nome. Scegli un nome diverso.",      "A wallet with this name already exists. Choose a different name.", "Ya existe un wallet con este nombre. Elige un nombre diferente.", "Un wallet avec ce nom existe déjà. Choisissez un nom différent.", "Já existe uma carteira com este nome. Escolha um nome diferente.", "Ein Wallet mit diesem Namen existiert bereits. Wähle einen anderen Namen."],
         ["wiz.password.title"]    = ["Password del file wallet",                                          "Wallet file password",         "Contraseña del archivo wallet",        "Mot de passe du fichier wallet",           "Senha do arquivo da carteira",             "Wallet-Dateipasswort"],
         ["wiz.password.placeholder"] = ["Consigliata (vuoto = file in chiaro su disco)",                 "Recommended (empty = plaintext file on disk)", "Recomendada (vacío = archivo en texto claro en disco)", "Recommandé (vide = fichier en texte clair sur disque)", "Recomendada (vazio = arquivo em texto simples no disco)", "Empfohlen (leer = Klartextdatei auf Disk)"],
         ["wiz.password.create"]   = ["Crea il wallet",                                                    "Create wallet",                "Crear wallet",                         "Créer le wallet",                          "Criar carteira",                           "Wallet erstellen"],
@@ -111,13 +133,49 @@ public sealed class Loc
             "Achtung: ohne Verschlüsselung bleibt der Seed im Klartext auf der Festplatte."],
         ["wiz.back"]              = ["Indietro",                                                          "Back",                         "Atrás",                                "Retour",                                   "Voltar",                                   "Zurück"],
         ["wiz.next"]              = ["Avanti",                                                            "Next",                         "Siguiente",                            "Suivant",                                  "Próximo",                                  "Weiter"],
+        ["wiz.scripttype.title"]  = ["Tipo di script e indirizzi",                                       "Script type and addresses",    "Tipo de script y direcciones",         "Type de script et adresses",               "Tipo de script e endereços",               "Skripttyp und Adressen"],
+        ["wiz.scripttype.hint"]   = [
+            "Determina il formato degli indirizzi. Se non sai cosa scegliere, usa Native SegWit.",
+            "Determines the address format. If unsure, use Native SegWit.",
+            "Determina el formato de los direcciones. Si no sabes, usa Native SegWit.",
+            "Détermine le format des adresses. En cas de doute, utilisez Native SegWit.",
+            "Determina o formato dos endereços. Em caso de dúvida, use Native SegWit.",
+            "Bestimmt das Adressformat. Wenn Sie unsicher sind, verwenden Sie Native SegWit."],
+        ["wiz.scripttype.legacy.desc"]  = ["BIP44 · m/44'/… · indirizzi P",  "BIP44 · m/44'/… · P addresses",  "BIP44 · m/44'/… · direcciones P",  "BIP44 · m/44'/… · adresses P",  "BIP44 · m/44'/… · endereços P",  "BIP44 · m/44'/… · P-Adressen"],
+        ["wiz.scripttype.wrapped.desc"] = ["BIP49 · m/49'/… · indirizzi 3",  "BIP49 · m/49'/… · 3 addresses",  "BIP49 · m/49'/… · direcciones 3",  "BIP49 · m/49'/… · adresses 3",  "BIP49 · m/49'/… · endereços 3",  "BIP49 · m/49'/… · 3-Adressen"],
+        ["wiz.scripttype.native.desc"]  = ["BIP84 · m/84'/… · indirizzi plm1q — consigliato", "BIP84 · m/84'/… · plm1q addresses — recommended", "BIP84 · m/84'/… · direcciones plm1q — recomendado", "BIP84 · m/84'/… · adresses plm1q — recommandé", "BIP84 · m/84'/… · endereços plm1q — recomendado", "BIP84 · m/84'/… · plm1q-Adressen — empfohlen"],
+        ["wiz.scripttype.taproot.desc"] = ["BIP86 · m/86'/… · indirizzi plm1p", "BIP86 · m/86'/… · plm1p addresses", "BIP86 · m/86'/… · direcciones plm1p", "BIP86 · m/86'/… · adresses plm1p", "BIP86 · m/86'/… · endereços plm1p", "BIP86 · m/86'/… · plm1p-Adressen"],
+        ["wiz.importxkey.title"]  = ["Importa chiave estesa",                                              "Import extended key",          "Importar clave extendida",             "Importer la clé étendue",                  "Importar chave estendida",                 "Erweiterten Schlüssel importieren"],
+        ["wiz.importxkey.hint"]   = [
+            "Incolla una xpub/zpub/ypub (watch-only) o xprv/zprv/yprv (spendibile). Il tipo di script viene rilevato automaticamente.",
+            "Paste an xpub/zpub/ypub (watch-only) or xprv/zprv/yprv (spendable). The script type is detected automatically.",
+            "Pega un xpub/zpub/ypub (solo lectura) o xprv/zprv/yprv (gastable). El tipo de script se detecta automáticamente.",
+            "Collez un xpub/zpub/ypub (lecture seule) ou xprv/zprv/yprv (dépensable). Le type de script est détecté automatiquement.",
+            "Cole um xpub/zpub/ypub (somente leitura) ou xprv/zprv/yprv (gastável). O tipo de script é detectado automaticamente.",
+            "Fügen Sie einen xpub/zpub/ypub (nur lesend) oder xprv/zprv/yprv (ausgabefähig) ein. Der Skripttyp wird automatisch erkannt."],
+        ["wiz.importxkey.placeholder"] = ["xpub… / zpub… / ypub… / xprv… / zprv…",                       "xpub… / zpub… / ypub… / xprv… / zprv…", "xpub… / zpub… / ypub… / xprv… / zprv…", "xpub… / zpub… / ypub… / xprv… / zprv…", "xpub… / zpub… / ypub… / xprv… / zprv…", "xpub… / zpub… / ypub… / xprv… / zprv…"],
+        ["wiz.importwif.title"]   = ["Importa chiave privata WIF",                                         "Import WIF private key",       "Importar clave privada WIF",           "Importer la clé privée WIF",               "Importar chave privada WIF",               "WIF-Privatschlüssel importieren"],
+        ["wiz.importwif.hint"]    = [
+            "Incolla una o più chiavi WIF (una per riga). Puoi importare più chiavi per controllare più indirizzi con lo stesso wallet.",
+            "Paste one or more WIF keys (one per line). You can import multiple keys to control multiple addresses with the same wallet.",
+            "Pega una o más claves WIF (una por línea). Puedes importar múltiples claves para controlar múltiples direcciones con el mismo wallet.",
+            "Collez une ou plusieurs clés WIF (une par ligne). Vous pouvez importer plusieurs clés pour contrôler plusieurs adresses avec le même wallet.",
+            "Cole uma ou mais chaves WIF (uma por linha). Você pode importar várias chaves para controlar vários endereços com a mesma carteira.",
+            "Fügen Sie einen oder mehrere WIF-Schlüssel ein (einer pro Zeile). Sie können mehrere Schlüssel importieren, um mehrere Adressen mit demselben Wallet zu verwalten."],
+        ["wiz.importwif.placeholder"] = ["K… / L… / 5… (una chiave per riga)",                            "K… / L… / 5… (one key per line)", "K… / L… / 5… (una clave por línea)", "K… / L… / 5… (une clé par ligne)", "K… / L… / 5… (uma chave por linha)", "K… / L… / 5… (ein Schlüssel pro Zeile)"],
 
-        // Pannello wallet
+        // Import error messages
+        ["msg.xkey.required"]     = ["Incolla una chiave estesa (xpub/xprv o variante).",                  "Paste an extended key (xpub/xprv or variant).", "Pega una clave extendida (xpub/xprv o variante).", "Collez une clé étendue (xpub/xprv ou variante).", "Cole uma chave estendida (xpub/xprv ou variante).", "Fügen Sie einen erweiterten Schlüssel ein (xpub/xprv oder Variante)."],
+        ["msg.xkey.invalid"]      = ["Chiave estesa non riconosciuta per questa rete.",                     "Extended key not recognised for this network.", "Clave extendida no reconocida para esta red.", "Clé étendue non reconnue pour ce réseau.", "Chave estendida não reconhecida para esta rede.", "Erweiterter Schlüssel für dieses Netzwerk nicht erkannt."],
+        ["msg.wif.required"]      = ["Incolla almeno una chiave WIF.",                                      "Paste at least one WIF key.",  "Pega al menos una clave WIF.",         "Collez au moins une clé WIF.",             "Cole pelo menos uma chave WIF.",           "Fügen Sie mindestens einen WIF-Schlüssel ein."],
+        ["msg.wif.invalid"]       = ["Chiave WIF non valida per questa rete.",                              "WIF key not valid for this network.", "Clave WIF no válida para esta red.", "Clé WIF invalide pour ce réseau.",        "Chave WIF inválida para esta rede.",       "WIF-Schlüssel für dieses Netzwerk ungültig."],
+
+        // Wallet panel
         ["wallet.close"]          = ["Chiudi wallet",                                                     "Close wallet",                 "Cerrar wallet",                        "Fermer le wallet",                         "Fechar carteira",                          "Wallet schließen"],
         ["wallet.server"]         = ["Server:",                                                           "Server:",                      "Servidor:",                            "Serveur :",                                "Servidor:",                                "Server:"],
-        ["wallet.connect"]        = ["Connetti e sincronizza",                                            "Connect and sync",             "Conectar y sincronizar",               "Connecter et synchroniser",                "Conectar e sincronizar",                   "Verbinden und synchronisieren"],
+        ["wallet.connect"]        = ["Connetti",                                                          "Connect",                       "Conectar",                             "Connecter",                                "Conectar",                                  "Verbinden"],
         ["wallet.manual"]         = ["oppure host:porta manuale",                                         "or manual host:port",          "o host:puerto manual",                 "ou hôte:port manuel",                      "ou host:porta manual",                     "oder manuell host:port"],
-        ["wallet.discover"]       = ["Cerca altri server",                                                "Discover servers",             "Buscar otros servidores",              "Rechercher des serveurs",                  "Procurar servidores",                      "Server suchen"],
+        ["wallet.discover"]       = ["Sincronizza",                                                       "Sync servers",                  "Sincronizar",                          "Synchroniser",                             "Sincronizar",                              "Synchronisieren"],
         ["wallet.resetcert"]      = ["Reset cert.",                                                       "Reset certs",                  "Restablecer cert.",                    "Réinit. cert.",                            "Redefinir cert.",                          "Zert. zurücksetzen"],
         ["tab.receive"]           = ["Ricevi",                                                            "Receive",                      "Recibir",                              "Recevoir",                                 "Receber",                                  "Empfangen"],
         ["tab.history"]           = ["Storico",                                                           "History",                      "Historial",                            "Historique",                               "Histórico",                                "Verlauf"],
@@ -142,13 +200,15 @@ public sealed class Loc
         ["addr.pubkey"]           = ["Chiave pubblica:",                                                  "Public key:",                  "Clave pública:",                       "Clé publique :",                           "Chave pública:",                           "Öffentlicher Schlüssel:"],
         ["addr.privkey"]          = ["Chiave privata (WIF):",                                             "Private key (WIF):",           "Clave privada (WIF):",                 "Clé privée (WIF) :",                       "Chave privada (WIF):",                     "Privater Schlüssel (WIF):"],
         ["addr.show.privkey"]     = ["Mostra",                                                            "Show",                         "Mostrar",                              "Afficher",                                 "Mostrar",                                  "Anzeigen"],
+        ["addr.privkey.prompt.title"] = ["Conferma identità",                                           "Confirm identity",             "Confirmar identidad",                  "Confirmer l'identité",                     "Confirmar identidade",                     "Identität bestätigen"],
+        ["addr.privkey.prompt.desc"]  = ["Inserisci la password del wallet per visualizzare la chiave privata.", "Enter the wallet password to reveal the private key.", "Ingresa la contraseña del wallet para ver la clave privada.", "Entrez le mot de passe du wallet pour afficher la clé privée.", "Digite a senha da carteira para ver a chave privada.", "Geben Sie das Wallet-Passwort ein, um den privaten Schlüssel anzuzeigen."],
         ["addr.hide.privkey"]     = ["Nascondi",                                                          "Hide",                         "Ocultar",                              "Masquer",                                  "Ocultar",                                  "Ausblenden"],
         ["addr.receive"]          = ["ricezione",                                                         "receive",                      "recepción",                            "réception",                                "recebimento",                              "Empfang"],
         ["addr.change"]           = ["change",                                                            "change",                       "cambio",                               "monnaie",                                  "troco",                                    "Wechselgeld"],
         ["addr.info.title"]       = ["Informazioni indirizzo",                                          "Address information",          "Información de dirección",             "Informations sur l'adresse",               "Informações do endereço",                  "Adressinformationen"],
         ["addr.close"]            = ["Chiudi",                                                          "Close",                        "Cerrar",                               "Fermer",                                   "Fechar",                                   "Schließen"],
 
-        // Storico → dettaglio transazione
+        // History → transaction detail
         ["history.hint"]          = ["Doppio click su una transazione per i dettagli.",                  "Double-click a transaction for details.", "Doble clic en una transacción para ver los detalles.", "Double-cliquez sur une transaction pour les détails.", "Clique duplo numa transação para ver os detalhes.", "Doppelklick auf eine Transaktion für Details."],
         ["tx.title"]              = ["Dettagli transazione",                                            "Transaction details",          "Detalles de la transacción",           "Détails de la transaction",                "Detalhes da transação",                    "Transaktionsdetails"],
         ["tx.close"]              = ["Chiudi",                                                          "Close",                        "Cerrar",                               "Fermer",                                   "Fechar",                                   "Schließen"],
@@ -170,12 +230,16 @@ public sealed class Loc
         ["tx.size.total"]         = ["Dimensione totale",                                              "Total size",                   "Tamaño total",                         "Taille totale",                            "Tamanho total",                            "Gesamtgröße"],
         ["tx.size.virtual"]       = ["Dimensione virtuale",                                            "Virtual size",                 "Tamaño virtual",                       "Taille virtuelle",                         "Tamanho virtual",                          "Virtuelle Größe"],
         ["tx.rbf"]                = ["Sostituibile (RBF)",                                              "Replaceable (RBF)",            "Reemplazable (RBF)",                   "Remplaçable (RBF)",                        "Substituível (RBF)",                       "Ersetzbar (RBF)"],
-        ["tx.verified"]           = ["Verifica SPV",                                                    "SPV verification",             "Verificación SPV",                     "Vérification SPV",                         "Verificação SPV",                          "SPV-Prüfung"],
-        ["tx.inputs"]             = ["Input",                                                           "Inputs",                       "Entradas",                             "Entrées",                                  "Entradas",                                 "Eingänge"],
+["tx.inputs"]             = ["Input",                                                           "Inputs",                       "Entradas",                             "Entrées",                                  "Entradas",                                 "Eingänge"],
         ["tx.outputs"]            = ["Output",                                                          "Outputs",                      "Salidas",                              "Sorties",                                  "Saídas",                                   "Ausgänge"],
         ["tx.yes"]                = ["Sì",                                                              "Yes",                          "Sí",                                   "Oui",                                      "Sim",                                      "Ja"],
         ["tx.no"]                 = ["No",                                                              "No",                           "No",                                   "Non",                                      "Não",                                      "Nein"],
         ["tx.needconnection"]     = ["Connettiti al server per vedere i dettagli della transazione.",   "Connect to the server to view transaction details.", "Conéctate al servidor para ver los detalles de la transacción.", "Connectez-vous au serveur pour voir les détails de la transaction.", "Conecte-se ao servidor para ver os detalhes da transação.", "Mit dem Server verbinden, um die Transaktionsdetails zu sehen."],
+        ["tx.sect.overview"]      = ["Panoramica",                                                       "Overview",                     "Resumen",                              "Aperçu",                                   "Visão geral",                              "Übersicht"],
+        ["tx.sect.amounts"]       = ["Importi e commissioni",                                            "Amounts & fees",               "Importes y comisiones",                "Montants et frais",                        "Valores e taxas",                          "Beträge & Gebühren"],
+        ["tx.sect.tech"]          = ["Dettagli tecnici",                                                 "Technical details",            "Detalles técnicos",                    "Détails techniques",                       "Detalhes técnicos",                        "Technische Details"],
+        ["tx.coinbase"]           = ["Coinbase",                                                        "Coinbase",                     "Coinbase",                             "Coinbase",                                 "Coinbase",                                 "Coinbase"],
+        ["tx.coinbase.newcoins"]  = ["Nuova emissione (mining)",                                         "Newly generated (mining)",     "Nueva emisión (minería)",              "Nouvelle émission (minage)",               "Nova emissão (mineração)",                 "Neu erzeugt (Mining)"],
         ["send.from.contact"]     = ["Da contatti:",                                                      "From contacts:",               "De contactos:",                        "Depuis les contacts :",                    "De contatos:",                             "Aus Kontakten:"],
         ["send.contact.hint"]     = ["seleziona per riempire l'indirizzo",                                "select to fill address",       "selecciona para rellenar la dirección", "sélectionner pour remplir l'adresse",      "selecione para preencher o endereço",      "auswählen um Adresse einzufügen"],
         ["send.to"]               = ["Indirizzo destinatario",                                            "Recipient address",            "Dirección destinataria",               "Adresse du destinataire",                  "Endereço do destinatário",                 "Empfängeradresse"],
@@ -183,18 +247,52 @@ public sealed class Loc
         ["send.all"]              = ["Invia tutto",                                                       "Send all",                     "Enviar todo",                          "Tout envoyer",                             "Enviar tudo",                              "Alles senden"],
         ["send.feerate"]          = ["fee sat/vB:",                                                       "fee sat/vB:",                  "tarifa sat/vB:",                       "frais sat/vB :",                           "taxa sat/vB:",                             "Gebühr sat/vB:"],
         ["send.prepare"]          = ["Prepara transazione",                                               "Prepare transaction",          "Preparar transacción",                 "Préparer la transaction",                  "Preparar transação",                       "Transaktion vorbereiten"],
+        ["send.scan"]             = ["Scansiona QR",                                                      "Scan QR",                      "Escanear QR",                          "Scanner QR",                               "Escanear QR",                              "QR scannen"],
         ["send.confirm"]          = ["CONFERMA E TRASMETTI",                                              "CONFIRM AND BROADCAST",        "CONFIRMAR Y TRANSMITIR",               "CONFIRMER ET DIFFUSER",                    "CONFIRMAR E TRANSMITIR",                   "BESTÄTIGEN UND SENDEN"],
+        ["send.sect.recipient"]   = ["Destinatario",                                                       "Recipient",                    "Destinatario",                         "Destinataire",                             "Destinatário",                             "Empfänger"],
+        ["send.sect.amount"]      = ["Importo e commissione",                                              "Amount & fee",                 "Importe y comisión",                   "Montant et frais",                         "Valor e taxa",                             "Betrag & Gebühr"],
+        ["send.summary"]          = ["Riepilogo",                                                          "Summary",                      "Resumen",                              "Résumé",                                   "Resumo",                                   "Zusammenfassung"],
+        ["receive.your.address"]  = ["Il tuo indirizzo",                                                   "Your address",                 "Tu dirección",                         "Votre adresse",                            "Seu endereço",                             "Deine Adresse"],
 
-        // Stato connessione
+        // Wallet info overlay
+        ["menu.wallet"]              = ["_Wallet",                                                          "_Wallet",                      "_Wallet",                              "_Wallet",                                  "_Wallet",                                  "_Wallet"],
+        ["walletinfo.title"]         = ["Informazioni Wallet",                                              "Wallet Information",           "Información del Wallet",               "Informations Wallet",                      "Informações da Carteira",                  "Wallet-Informationen"],
+        ["walletinfo.file"]          = ["File",                                                             "File",                         "Archivo",                              "Fichier",                                  "Arquivo",                                  "Datei"],
+        ["walletinfo.network"]       = ["Rete",                                                             "Network",                      "Red",                                  "Réseau",                                   "Rede",                                     "Netzwerk"],
+        ["walletinfo.type"]          = ["Tipo wallet",                                                      "Wallet type",                  "Tipo de wallet",                       "Type de wallet",                           "Tipo de carteira",                         "Wallet-Typ"],
+        ["walletinfo.type.seed"]     = ["HD (seed BIP39)",                                                  "HD (BIP39 seed)",              "HD (seed BIP39)",                      "HD (graine BIP39)",                        "HD (semente BIP39)",                       "HD (BIP39-Seed)"],
+        ["walletinfo.type.xprv"]     = ["HD (xprv importato)",                                              "HD (imported xprv)",           "HD (xprv importado)",                  "HD (xprv importé)",                        "HD (xprv importado)",                      "HD (importierter xprv)"],
+        ["walletinfo.type.wif"]      = ["Chiave WIF importata",                                             "Imported WIF key",             "Clave WIF importada",                  "Clé WIF importée",                         "Chave WIF importada",                      "Importierter WIF-Schlüssel"],
+        ["walletinfo.type.watchonly"] = ["Watch-only (xpub)",                                               "Watch-only (xpub)",            "Watch-only (xpub)",                    "Watch-only (xpub)",                        "Watch-only (xpub)",                        "Watch-only (xpub)"],
+        ["walletinfo.script"]        = ["Script",                                                           "Script",                       "Script",                               "Script",                                   "Script",                                   "Script"],
+        ["walletinfo.derivpath"]     = ["Percorso derivazione",                                             "Derivation path",              "Ruta de derivación",                   "Chemin de dérivation",                     "Caminho de derivação",                     "Ableitungspfad"],
+        ["walletinfo.xpub"]          = ["Chiave pubblica estesa",                                           "Extended public key",          "Clave pública extendida",              "Clé publique étendue",                     "Chave pública estendida",                  "Erweiterter öffentlicher Schlüssel"],
+        ["walletinfo.fingerprint"]   = ["Master fingerprint",                                               "Master fingerprint",           "Huella maestra",                       "Empreinte maître",                         "Impressão digital mestre",                 "Master-Fingerprint"],
+        ["walletinfo.seed.section"]  = ["Seed (mnemonica BIP39)",                                           "Seed (BIP39 mnemonic)",        "Semilla (mnemónico BIP39)",            "Graine (mnémonique BIP39)",                "Semente (mnemônico BIP39)",                "Seed (BIP39-Mnemonic)"],
+        ["walletinfo.seed.noseed"]   = ["Questo wallet non ha una seed (watch-only o importato).",          "This wallet has no seed (watch-only or imported).", "Este wallet no tiene seed (watch-only o importado).", "Ce wallet n'a pas de graine (watch-only ou importé).", "Esta carteira não tem semente (watch-only ou importada).", "Dieses Wallet hat keinen Seed (watch-only oder importiert)."],
+        ["walletinfo.seed.password"] = ["Password del file wallet per sbloccare il seed:",                  "Wallet file password to unlock the seed:", "Contraseña del archivo para desbloquear la seed:", "Mot de passe du fichier pour déverrouiller la graine :", "Senha do arquivo para desbloquear a semente:", "Dateipasswort zum Entsperren des Seeds:"],
+        ["walletinfo.seed.reveal"]   = ["Mostra seed",                                                      "Show seed",                    "Mostrar seed",                         "Afficher la graine",                       "Mostrar semente",                          "Seed anzeigen"],
+        ["walletinfo.seed.hide"]     = ["Nascondi",                                                         "Hide",                         "Ocultar",                              "Masquer",                                  "Ocultar",                                  "Ausblenden"],
+        ["walletinfo.seed.warning"]  = [
+            "Non condividere mai queste parole. Chi le possiede controlla i fondi.",
+            "Never share these words. Whoever holds them controls the funds.",
+            "Nunca compartas estas palabras. Quien las tenga controla los fondos.",
+            "Ne partagez jamais ces mots. Celui qui les possède contrôle les fonds.",
+            "Nunca compartilhe essas palavras. Quem as tiver controla os fundos.",
+            "Teilen Sie diese Wörter niemals. Wer sie hat, kontrolliert die Gelder."],
+        ["walletinfo.passphrase"]    = ["Passphrase BIP39",                                                 "BIP39 passphrase",             "Frase de contraseña BIP39",            "Phrase de passe BIP39",                    "Frase-senha BIP39",                        "BIP39-Passphrase"],
+        ["walletinfo.passphrase.set"] = ["(impostata)",                                                     "(set)",                        "(establecida)",                        "(définie)",                                "(definida)",                               "(gesetzt)"],
+
+        // Connection status
         ["conn.none"]             = ["non connesso",                                                      "not connected",                "no conectado",                         "non connecté",                             "não conectado",                            "nicht verbunden"],
         ["conn.disconnected"]     = ["disconnesso",                                                       "disconnected",                 "desconectado",                         "déconnecté",                               "desconectado",                             "getrennt"],
         ["conn.reconnecting"]     = ["riconnessione…",                                                    "reconnecting…",                "reconectando…",                        "reconnexion…",                             "reconectando…",                            "Verbindung wird wiederhergestellt…"],
         ["conn.error"]            = ["errore di connessione",                                             "connection error",             "error de conexión",                    "erreur de connexion",                      "erro de conexão",                          "Verbindungsfehler"],
         ["conn.certchanged"]      = ["certificato cambiato",                                              "certificate changed",          "certificado cambiado",                 "certificat modifié",                       "certificado alterado",                     "Zertifikat geändert"],
-        ["conn.connectedto"]      = ["connesso a",                                                        "connected to",                 "conectado a",                          "connecté à",                               "conectado a",                              "verbunden mit"],
+        ["conn.connectedto"]      = ["connesso",                                                          "connected",                    "conectado",                            "connecté",                                 "conectado",                                "verbunden"],
         ["conn.connectingto"]     = ["connessione a",                                                     "connecting to",                "conectando a",                         "connexion à",                              "conectando a",                             "Verbindung zu"],
 
-        // Messaggi di stato principali
+        // Main status messages
         ["msg.welcome.existing"]  = [
             "Trovato un wallet esistente su questa rete: aprilo, oppure creane un altro.",
             "Found an existing wallet on this network: open it, or create another one.",
@@ -281,6 +379,8 @@ public sealed class Loc
             "As duas senhas não coincidem.",
             "Die beiden Passwörter stimmen nicht überein."],
         ["msg.wrongpassword"]     = ["Password errata.",                                                  "Wrong password.",              "Contraseña incorrecta.",               "Mot de passe incorrect.",                  "Senha incorreta.",                         "Falsches Passwort."],
+        ["msg.wallet.locked"]     = ["Wallet già aperto in un'altra istanza dell'applicazione.",          "Wallet already open in another instance of the application.", "El wallet ya está abierto en otra instancia de la aplicación.", "Le wallet est déjà ouvert dans une autre instance de l'application.", "A carteira já está aberta em outra instância do aplicativo.", "Wallet ist bereits in einer anderen Instanz der Anwendung geöffnet."],
+        ["msg.wallet.noaccess"]   = ["Impossibile accedere al file del wallet: verificare i permessi.",   "Cannot access the wallet file: check file permissions.", "No se puede acceder al archivo del wallet: verifique los permisos.", "Impossible d'accéder au fichier du wallet : vérifiez les autorisations.", "Não é possível acessar o arquivo da carteira: verifique as permissões.", "Zugriff auf die Wallet-Datei nicht möglich: Berechtigungen prüfen."],
         ["msg.opened"]            = ["Wallet aperto: connessione al server…",                             "Wallet opened: connecting to server…", "Wallet abierto: conectando al servidor…", "Wallet ouvert : connexion au serveur…",  "Carteira aberta: conectando ao servidor…", "Wallet geöffnet: Verbindung zum Server…"],
         ["msg.synced"]            = ["Sincronizzato",                                                     "Synchronized",                 "Sincronizado",                         "Synchronisé",                              "Sincronizado",                             "Synchronisiert"],
         ["msg.synced.detail"]     = [
@@ -293,6 +393,7 @@ public sealed class Loc
         ["msg.height"]            = ["altezza",                                                           "height",                       "altura",                               "hauteur",                                  "altura",                                   "Höhe"],
         ["msg.pending"]           = ["in attesa di conferma",                                             "pending confirmation",         "pendiente de confirmación",            "en attente de confirmation",               "aguardando confirmação",                   "ausstehende Bestätigung"],
         ["msg.notspendable"]      = ["non ancora spendibile",                                             "not yet spendable",            "aún no gastable",                      "pas encore dépensable",                    "ainda não gastável",                       "noch nicht verwendbar"],
+        ["msg.immature"]          = ["in maturazione",                                                    "maturing",                      "en maduración",                        "en maturation",                            "em maturação",                             "in Reifung"],
         ["msg.settings.saved"]    = ["Impostazioni salvate.",                                             "Settings saved.",              "Configuración guardada.",              "Paramètres enregistrés.",                  "Configurações salvas.",                    "Einstellungen gespeichert."],
         ["msg.certreset"]         = [
             "Certificati SSL azzerati: riprova la connessione.",
@@ -303,7 +404,7 @@ public sealed class Loc
             "SSL-Zertifikate zurückgesetzt: Verbindung erneut versuchen."],
         ["msg.error"]             = ["Errore",                                                            "Error",                        "Error",                                "Erreur",                                   "Erro",                                     "Fehler"],
 
-        // Contatti
+        // Contacts
         ["contacts.name"]         = ["Nome",                                                              "Name",                         "Nombre",                               "Nom",                                      "Nome",                                     "Name"],
         ["contacts.address"]      = ["Indirizzo",                                                         "Address",                      "Dirección",                            "Adresse",                                  "Endereço",                                 "Adresse"],
         ["contacts.name.ph"]      = ["Nome contatto",                                                     "Contact name",                 "Nombre del contacto",                  "Nom du contact",                           "Nome do contato",                          "Kontaktname"],
@@ -312,7 +413,7 @@ public sealed class Loc
         ["contacts.remove"]       = ["Rimuovi selezionato",                                               "Remove selected",              "Eliminar seleccionado",                "Supprimer la sélection",                   "Remover selecionado",                      "Auswahl entfernen"],
         ["contacts.empty"]        = ["Nessun contatto salvato.",                                          "No saved contacts.",           "No hay contactos guardados.",          "Aucun contact enregistré.",                "Nenhum contato salvo.",                    "Keine gespeicherten Kontakte."],
 
-        // Finestra impostazioni
+        // Settings window
         ["settings.title"]        = ["Impostazioni",                                                      "Settings",                     "Configuración",                        "Paramètres",                               "Configurações",                            "Einstellungen"],
         ["settings.language"]     = ["Lingua",                                                            "Language",                     "Idioma",                               "Langue",                                   "Idioma",                                   "Sprache"],
         ["settings.unit"]         = ["Unità degli importi",                                               "Amount unit",                  "Unidad de importes",                   "Unité des montants",                       "Unidade dos valores",                      "Betrageinheit"],
@@ -320,7 +421,7 @@ public sealed class Loc
         ["settings.cancel"]       = ["Annulla",                                                           "Cancel",                       "Cancelar",                             "Annuler",                                  "Cancelar",                                 "Abbrechen"],
         ["settings.server"]       = ["Server di indicizzazione…",                                         "Indexing server…",             "Servidor de indexación…",              "Serveur d'indexation…",                    "Servidor de indexação…",                   "Indexierungsserver…"],
 
-        // Finestra server
+        // Server window
         ["server.title"]          = ["Server di indicizzazione",                                          "Indexing server",              "Servidor de indexación",               "Serveur d'indexation",                     "Servidor de indexação",                    "Indexierungsserver"],
         ["server.host"]           = ["Host",                                                              "Host",                         "Host",                                 "Hôte",                                     "Host",                                     "Host"],
         ["server.port"]           = ["Porta",                                                             "Port",                         "Puerto",                               "Port",                                     "Porta",                                    "Port"],

src/App/PalladiumWallet.App.csproj

@@ -1,35 +1,30 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <OutputType>WinExe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
-    <!-- Versione dell'applicazione: unico punto da modificare. Compare nel
-         titolo della finestra ed è incisa nei binari pubblicati. -->
-    <Version>0.9.0</Version>
-    <Nullable>enable</Nullable>
-    <ApplicationManifest>app.manifest</ApplicationManifest>
-    <ApplicationIcon>Assets\logo.ico</ApplicationIcon>
-    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <Folder Include="Models\" />
-    <AvaloniaResource Include="Assets\**" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Avalonia" Version="12.0.4" />
-    <PackageReference Include="Avalonia.Desktop" Version="12.0.4" />
-    <PackageReference Include="Avalonia.Themes.Fluent" Version="12.0.4" />
-    <PackageReference Include="Avalonia.Fonts.Inter" Version="12.0.4" />
-    <PackageReference Include="AvaloniaUI.DiagnosticsSupport" Version="2.2.1">
-      <IncludeAssets Condition="'$(Configuration)' != 'Debug'">None</IncludeAssets>
-      <PrivateAssets Condition="'$(Configuration)' != 'Debug'">All</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.1" />
-    <PackageReference Include="QRCoder" Version="1.8.0" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\Core\PalladiumWallet.Core.csproj" />
-  </ItemGroup>
-</Project>
+<Project Sdk="Microsoft.NET.Sdk">
+  <!-- Libreria UI condivisa: il codice Avalonia (App, Views, ViewModels, Loc,
+       Assets) usato sia dall'head Desktop sia dall'head Android. Gli head
+       portano l'entry-point e i pacchetti specifici di piattaforma. -->
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <!-- Versione dell'applicazione: unico punto da modificare. Compare nel
+         titolo della finestra ed è incisa nei binari pubblicati. -->
+    <Version>0.9.0</Version>
+    <Nullable>enable</Nullable>
+    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="Models\" />
+    <AvaloniaResource Include="Assets\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia" Version="12.0.4" />
+    <PackageReference Include="Avalonia.Themes.Fluent" Version="12.0.4" />
+    <PackageReference Include="Avalonia.Fonts.Inter" Version="12.0.4" />
+    <PackageReference Include="CommunityToolkit.Mvvm" Version="8.4.1" />
+    <PackageReference Include="QRCoder" Version="1.8.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Core\PalladiumWallet.Core.csproj" />
+  </ItemGroup>
+</Project>

src/App/Services/PlatformServices.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Threading.Tasks;
+
+namespace PalladiumWallet.App.Services;
+
+/// <summary>
+/// Seam for platform-specific services (Android/desktop).
+/// The Android head sets the delegates in OnCreate; desktop leaves them null.
+/// </summary>
+public static class PlatformServices
+{
+    /// <summary>
+    /// Opens the native QR scanner and returns the raw code text,
+    /// or null if the user cancels or the scanner is unavailable.
+    /// </summary>
+    public static Func<Task<string?>>? ScanQrAsync { get; set; }
+}

src/App/Styles/Controls.axaml

@@ -0,0 +1,172 @@
+<Styles xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <!-- ============================================================
+         Palladium wallet control styles ("clean fintech").
+         Applied on top of FluentTheme: refine spacing, states and
+         reusable classes without re-templating controls. The "accent"
+         buttons remain managed by Fluent but inherit the brand blue
+         via SystemAccentColor (see Theme.axaml).
+         ============================================================ -->
+
+    <Design.PreviewWith>
+        <Border Padding="20" Width="320">
+            <StackPanel Spacing="12">
+                <TextBlock Classes="h1" Text="Saldo disponibile"/>
+                <TextBlock Classes="amount" Text="1 234,56 PLM"/>
+                <Button Classes="accent" Content="Invia"/>
+                <Button Content="Annulla"/>
+                <Border Classes="card" Padding="16">
+                    <TextBlock Text="Card di esempio"/>
+                </Border>
+            </StackPanel>
+        </Border>
+    </Design.PreviewWith>
+
+    <!-- ===== Typography ===== -->
+    <Style Selector="TextBlock.h1">
+        <Setter Property="FontSize" Value="20"/>
+        <Setter Property="FontWeight" Value="SemiBold"/>
+        <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}"/>
+    </Style>
+    <Style Selector="TextBlock.label">
+        <Setter Property="FontSize" Value="11"/>
+        <Setter Property="FontWeight" Value="Medium"/>
+        <Setter Property="Foreground" Value="{DynamicResource TextSecondaryBrush}"/>
+    </Style>
+    <Style Selector="TextBlock.muted">
+        <Setter Property="Foreground" Value="{DynamicResource TextSecondaryBrush}"/>
+    </Style>
+    <!-- Amounts and numeric data: tabular figures to prevent layout jumps -->
+    <Style Selector="TextBlock.amount">
+        <Setter Property="FontSize" Value="34"/>
+        <Setter Property="FontWeight" Value="Bold"/>
+        <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}"/>
+        <Setter Property="FontFeatures" Value="+tnum"/>
+    </Style>
+    <Style Selector="TextBlock.mono, SelectableTextBlock.mono">
+        <Setter Property="FontFamily" Value="monospace"/>
+        <Setter Property="FontFeatures" Value="+tnum"/>
+    </Style>
+    <!-- Section heading (e.g. transaction detail) -->
+    <Style Selector="TextBlock.section">
+        <Setter Property="FontSize" Value="11"/>
+        <Setter Property="FontWeight" Value="SemiBold"/>
+        <Setter Property="Foreground" Value="{DynamicResource TextMutedBrush}"/>
+        <Setter Property="LetterSpacing" Value="0.8"/>
+    </Style>
+
+    <!-- ===== Buttons ===== -->
+    <Style Selector="Button">
+        <Setter Property="MinHeight" Value="36"/>
+        <Setter Property="Padding" Value="14,8"/>
+        <Setter Property="Cursor" Value="Hand"/>
+        <Setter Property="FontWeight" Value="Medium"/>
+        <Setter Property="VerticalContentAlignment" Value="Center"/>
+        <Setter Property="HorizontalContentAlignment" Value="Center"/>
+    </Style>
+    <!-- Accent (CTA) buttons are already blue via Fluent+SystemAccentColor.
+         Ensure readable white text in both light and dark variants. -->
+    <Style Selector="Button.accent">
+        <Setter Property="Foreground" Value="#FFFFFF"/>
+    </Style>
+    <!-- "ghost" variant: subtle secondary action, no fill -->
+    <Style Selector="Button.ghost">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="Foreground" Value="{DynamicResource PrimaryBrush}"/>
+        <Setter Property="BorderThickness" Value="0"/>
+    </Style>
+
+    <!-- ===== Inputs ===== -->
+    <Style Selector="TextBox">
+        <Setter Property="MinHeight" Value="36"/>
+        <Setter Property="Padding" Value="10,7"/>
+    </Style>
+    <Style Selector="ComboBox">
+        <Setter Property="MinHeight" Value="36"/>
+        <Setter Property="Padding" Value="10,6"/>
+    </Style>
+
+    <!-- ===== Lists ===== -->
+    <Style Selector="ListBox">
+        <Setter Property="Background" Value="Transparent"/>
+        <Setter Property="BorderThickness" Value="0"/>
+        <Setter Property="Padding" Value="0"/>
+    </Style>
+    <Style Selector="ListBoxItem">
+        <Setter Property="Padding" Value="12,10"/>
+        <Setter Property="CornerRadius" Value="8"/>
+        <Setter Property="Margin" Value="0,1"/>
+    </Style>
+    <!-- Hover: neutral tint; selected: subtle brand-blue tint -->
+    <Style Selector="ListBoxItem:pointerover /template/ ContentPresenter#PART_ContentPresenter">
+        <Setter Property="Background" Value="{DynamicResource SurfaceAltBrush}"/>
+    </Style>
+    <Style Selector="ListBoxItem:selected /template/ ContentPresenter#PART_ContentPresenter">
+        <Setter Property="Background" Value="{DynamicResource PrimarySoftBrush}"/>
+    </Style>
+
+    <!-- ===== Tabs (dashboard) ===== -->
+    <!-- Selected item: brand blue + bold; unselected: muted -->
+    <Style Selector="TabItem">
+        <Setter Property="Foreground" Value="{DynamicResource TextSecondaryBrush}"/>
+        <Setter Property="FontWeight" Value="Medium"/>
+    </Style>
+    <Style Selector="TabItem:selected">
+        <Setter Property="Foreground" Value="{DynamicResource PrimaryBrush}"/>
+    </Style>
+    <Style Selector="TabItem:selected /template/ ContentPresenter#PART_ContentPresenter">
+        <Setter Property="TextElement.Foreground" Value="{DynamicResource PrimaryBrush}"/>
+    </Style>
+    <!-- Push tab header content up so the 2px selection indicator (drawn at Panel bottom)
+         does not overlap the text label. -->
+    <Style Selector="TabItem /template/ ContentPresenter#PART_ContentPresenter">
+        <Setter Property="Margin" Value="0,0,0,4"/>
+    </Style>
+
+    <!-- ===== Reusable classes ===== -->
+    <!-- Card: elevated surface with a subtle border and soft corners -->
+    <Style Selector="Border.card">
+        <Setter Property="Background" Value="{DynamicResource SurfaceBrush}"/>
+        <Setter Property="BorderBrush" Value="{DynamicResource BorderSubtleBrush}"/>
+        <Setter Property="BorderThickness" Value="1"/>
+        <Setter Property="CornerRadius" Value="14"/>
+        <Setter Property="BoxShadow" Value="0 1 3 0 #14000000"/>
+        <Setter Property="Transitions">
+            <Transitions>
+                <BoxShadowsTransition Property="BoxShadow" Duration="0:0:0.18"/>
+            </Transitions>
+        </Setter>
+    </Style>
+    <Style Selector="Border.card:pointerover">
+        <Setter Property="BoxShadow" Value="0 6 16 -4 #26000000"/>
+    </Style>
+    <!-- Balance card: subtle blue accent, slightly more prominent -->
+    <Style Selector="Border.balance-card">
+        <Setter Property="Background" Value="{DynamicResource SurfaceBrush}"/>
+        <Setter Property="BorderBrush" Value="{DynamicResource BorderSubtleBrush}"/>
+        <Setter Property="BorderThickness" Value="1"/>
+        <Setter Property="CornerRadius" Value="14"/>
+        <Setter Property="Padding" Value="20,16"/>
+        <Setter Property="BoxShadow" Value="0 2 8 0 #1A000000"/>
+    </Style>
+    <!-- Hero balance card: brand gradient + blue glow. Signature dashboard
+         element; overlaid text is white (on-hero class). -->
+    <Style Selector="Border.balance-hero">
+        <Setter Property="Background" Value="{DynamicResource BalanceGradientBrush}"/>
+        <Setter Property="CornerRadius" Value="16"/>
+        <Setter Property="Padding" Value="24,20"/>
+        <Setter Property="BoxShadow" Value="0 8 24 -6 #663B82F6"/>
+    </Style>
+    <Style Selector="Border.balance-hero TextBlock.amount">
+        <Setter Property="Foreground" Value="#FFFFFF"/>
+    </Style>
+    <Style Selector="Border.balance-hero TextBlock.on-hero">
+        <Setter Property="Foreground" Value="#D6E2FF"/>
+    </Style>
+    <!-- Status pill / badge -->
+    <Style Selector="Border.chip">
+        <Setter Property="CornerRadius" Value="20"/>
+        <Setter Property="Padding" Value="10,5"/>
+        <Setter Property="Background" Value="{DynamicResource SurfaceAltBrush}"/>
+    </Style>
+</Styles>

src/App/Styles/Theme.axaml

@@ -0,0 +1,96 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <!-- ============================================================
+         Palladium wallet design tokens.
+         Identity: cobalt blue (trust) + green (money/positive),
+         derived from the logo. "Clean fintech" style.
+
+         All colors are SEMANTIC (role, not name): components
+         must never use inline hex but these brushes. Defined for
+         both variants (light/dark) via ThemeDictionaries, so
+         the app follows the system theme with no further configuration.
+         ============================================================ -->
+
+    <ResourceDictionary.ThemeDictionaries>
+
+        <!-- ============ LIGHT THEME ============ -->
+        <ResourceDictionary x:Key="Light">
+            <!-- Surfaces -->
+            <SolidColorBrush x:Key="AppBackgroundBrush" Color="#F1F5F9"/>     <!-- slate-100 -->
+            <SolidColorBrush x:Key="SurfaceBrush"        Color="#FFFFFF"/>
+            <SolidColorBrush x:Key="SurfaceAltBrush"     Color="#F8FAFC"/>     <!-- slate-50 -->
+            <SolidColorBrush x:Key="OverlayCardBrush"    Color="#FFFFFF"/>
+            <SolidColorBrush x:Key="ScrimBrush"          Color="#66000000"/>   <!-- 40% -->
+            <!-- Borders and separators -->
+            <SolidColorBrush x:Key="BorderSubtleBrush"   Color="#E2E8F0"/>     <!-- slate-200 -->
+            <SolidColorBrush x:Key="BorderStrongBrush"   Color="#CBD5E1"/>     <!-- slate-300 -->
+            <!-- Text -->
+            <SolidColorBrush x:Key="TextPrimaryBrush"    Color="#0F172A"/>     <!-- slate-900 -->
+            <SolidColorBrush x:Key="TextSecondaryBrush"  Color="#475569"/>     <!-- slate-600 -->
+            <SolidColorBrush x:Key="TextMutedBrush"      Color="#94A3B8"/>     <!-- slate-400 -->
+            <!-- Brand / state -->
+            <SolidColorBrush x:Key="PrimaryBrush"        Color="#2563EB"/>     <!-- blue-600 -->
+            <SolidColorBrush x:Key="PrimaryHoverBrush"   Color="#1D4ED8"/>     <!-- blue-700 -->
+            <SolidColorBrush x:Key="OnPrimaryBrush"      Color="#FFFFFF"/>
+            <SolidColorBrush x:Key="PrimarySoftBrush"    Color="#EFF6FF"/>     <!-- blue-50 -->
+            <SolidColorBrush x:Key="SuccessBrush"        Color="#16A34A"/>     <!-- green-600 -->
+            <SolidColorBrush x:Key="WarningBrush"        Color="#D97706"/>     <!-- amber-600 -->
+            <SolidColorBrush x:Key="DangerBrush"         Color="#DC2626"/>     <!-- red-600 -->
+            <!-- Hero gradient of the balance card: blue → indigo -->
+            <LinearGradientBrush x:Key="BalanceGradientBrush" StartPoint="0%,0%" EndPoint="100%,100%">
+                <GradientStop Offset="0" Color="#2563EB"/>
+                <GradientStop Offset="1" Color="#4F46E5"/>
+            </LinearGradientBrush>
+        </ResourceDictionary>
+
+        <!-- ============ DARK THEME ============ -->
+        <ResourceDictionary x:Key="Dark">
+            <!-- Surfaces -->
+            <SolidColorBrush x:Key="AppBackgroundBrush" Color="#0F172A"/>      <!-- slate-900 -->
+            <SolidColorBrush x:Key="SurfaceBrush"        Color="#1E293B"/>     <!-- slate-800 -->
+            <SolidColorBrush x:Key="SurfaceAltBrush"     Color="#273449"/>
+            <SolidColorBrush x:Key="OverlayCardBrush"    Color="#1E293B"/>
+            <SolidColorBrush x:Key="ScrimBrush"          Color="#99000000"/>   <!-- 60% -->
+            <!-- Borders and separators -->
+            <SolidColorBrush x:Key="BorderSubtleBrush"   Color="#334155"/>     <!-- slate-700 -->
+            <SolidColorBrush x:Key="BorderStrongBrush"   Color="#475569"/>     <!-- slate-600 -->
+            <!-- Text -->
+            <SolidColorBrush x:Key="TextPrimaryBrush"    Color="#F8FAFC"/>     <!-- slate-50 -->
+            <SolidColorBrush x:Key="TextSecondaryBrush"  Color="#94A3B8"/>     <!-- slate-400 -->
+            <SolidColorBrush x:Key="TextMutedBrush"      Color="#64748B"/>     <!-- slate-500 -->
+            <!-- Brand / state (brighter tones on dark background) -->
+            <SolidColorBrush x:Key="PrimaryBrush"        Color="#3B82F6"/>     <!-- blue-500 -->
+            <SolidColorBrush x:Key="PrimaryHoverBrush"   Color="#60A5FA"/>     <!-- blue-400 -->
+            <SolidColorBrush x:Key="OnPrimaryBrush"      Color="#0B1120"/>
+            <SolidColorBrush x:Key="PrimarySoftBrush"    Color="#1E3A8A"/>     <!-- blue-900 -->
+            <SolidColorBrush x:Key="SuccessBrush"        Color="#22C55E"/>     <!-- green-500 -->
+            <SolidColorBrush x:Key="WarningBrush"        Color="#F59E0B"/>     <!-- amber-500 -->
+            <SolidColorBrush x:Key="DangerBrush"         Color="#EF4444"/>     <!-- red-500 -->
+            <!-- Hero gradient of the balance card: blue → indigo (deeper tones) -->
+            <LinearGradientBrush x:Key="BalanceGradientBrush" StartPoint="0%,0%" EndPoint="100%,100%">
+                <GradientStop Offset="0" Color="#1D4ED8"/>
+                <GradientStop Offset="1" Color="#4338CA"/>
+            </LinearGradientBrush>
+        </ResourceDictionary>
+
+    </ResourceDictionary.ThemeDictionaries>
+
+    <!-- ============================================================
+         Override of the Fluent accent → brand blue. Recolors
+         consistently the controls that read SystemAccentColor (accent
+         buttons, selections, tab indicator, focus) without retemplating anything.
+         Variant-independent: #2563EB works on light and dark.
+         ============================================================ -->
+    <Color x:Key="SystemAccentColor">#2563EB</Color>
+    <Color x:Key="SystemAccentColorDark1">#1D4ED8</Color>
+    <Color x:Key="SystemAccentColorDark2">#1E40AF</Color>
+    <Color x:Key="SystemAccentColorDark3">#1E3A8A</Color>
+    <Color x:Key="SystemAccentColorLight1">#3B82F6</Color>
+    <Color x:Key="SystemAccentColorLight2">#60A5FA</Color>
+    <Color x:Key="SystemAccentColorLight3">#93C5FD</Color>
+
+    <!-- Global Fluent control corner radii: rounds buttons, inputs, combos,
+         and lists uniformly without retemplating each control. -->
+    <CornerRadius x:Key="ControlCornerRadius">8</CornerRadius>
+    <CornerRadius x:Key="OverlayCornerRadius">12</CornerRadius>
+</ResourceDictionary>

src/App/ViewModels/BoolToTabPlacementConverter.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Globalization;
+using Avalonia.Controls;
+using Avalonia.Data.Converters;
+
+namespace PalladiumWallet.App.ViewModels;
+
+/// <summary>
+/// true (mobile) → Dock.Bottom — tab strip at the bottom, Android standard.
+/// false (desktop) → Dock.Top — Avalonia default behavior.
+/// </summary>
+public sealed class BoolToTabPlacementConverter : IValueConverter
+{
+    public static readonly BoolToTabPlacementConverter Instance = new();
+
+    public object Convert(object? value, Type targetType, object? parameter, CultureInfo culture) =>
+        value is true ? Dock.Bottom : Dock.Top;
+
+    public object ConvertBack(object? value, Type targetType, object? parameter, CultureInfo culture) =>
+        throw new NotSupportedException();
+}

src/App/ViewModels/MainWindowViewModel.Contacts.cs

@@ -0,0 +1,70 @@
+using System.Collections.ObjectModel;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PalladiumWallet.Core.Storage;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    public ObservableCollection<ContactEntry> Contacts { get; } = [];
+
+    [ObservableProperty]
+    private ContactEntry? selectedContactInList;
+
+    /// <summary>Contact selected in the Send panel's ComboBox: fills SendTo.</summary>
+    [ObservableProperty]
+    private ContactEntry? sendToContact;
+
+    partial void OnSendToContactChanged(ContactEntry? value)
+    {
+        if (value is not null)
+            SendTo = value.Address;
+    }
+
+    [ObservableProperty]
+    private string newContactName = "";
+
+    [ObservableProperty]
+    private string newContactAddress = "";
+
+    [RelayCommand]
+    private void AddContact()
+    {
+        var name = NewContactName.Trim();
+        var addr = NewContactAddress.Trim();
+        if (string.IsNullOrEmpty(name) || string.IsNullOrEmpty(addr)) return;
+        Contacts.Add(new ContactEntry(name, addr));
+        NewContactName = NewContactAddress = "";
+        PersistContacts();
+    }
+
+    [RelayCommand]
+    private void RemoveSelectedContact()
+    {
+        if (SelectedContactInList is { } c)
+        {
+            Contacts.Remove(c);
+            SelectedContactInList = null;
+            PersistContacts();
+        }
+    }
+
+    private void PersistContacts()
+    {
+        if (_doc is null || _walletPath is null) return;
+        _doc.Contacts = Contacts
+            .Select(c => new StoredContact { Name = c.Name, Address = c.Address })
+            .ToList();
+        WalletStore.Save(_doc, _walletPath, _password);
+    }
+
+    private void LoadContacts()
+    {
+        Contacts.Clear();
+        if (_doc is null) return;
+        foreach (var c in _doc.Contacts)
+            Contacts.Add(new ContactEntry(c.Name, c.Address));
+    }
+}

src/App/ViewModels/MainWindowViewModel.Donate.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using NBitcoin;
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Net;
+using PalladiumWallet.Core.Wallet;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    public const string DevAddress = "plm1qdq3gu2zvg9lyr8gxd6yln4wavc5tlp8prmvfay";
+
+    [ObservableProperty]
+    private string donateAmount = "";
+
+    [ObservableProperty]
+    private string donatePreview = "";
+
+    [ObservableProperty]
+    private bool hasPendingDonate;
+
+    private BuiltTransaction? _pendingDonate;
+
+    [RelayCommand]
+    private async Task PrepareDonate()
+    {
+        _pendingDonate = null;
+        HasPendingDonate = false;
+
+        if (_account is null || _doc?.Cache is null || _lastTransactions is null)
+        {
+            DonatePreview = "Sincronizza prima di inviare.";
+            return;
+        }
+        try
+        {
+            var destination = BitcoinAddress.Create(DevAddress, PalladiumNetworks.For(Net));
+            if (!CoinAmount.TryParseIn(DonateAmount.Trim(), _config.Unit, out var amount) || amount <= 0)
+            {
+                DonatePreview = "Importo non valido.";
+                return;
+            }
+            if (!decimal.TryParse(SendFeeRate, System.Globalization.NumberStyles.Any,
+                    System.Globalization.CultureInfo.InvariantCulture, out var feeRate) || feeRate <= 0)
+                feeRate = 1m;
+
+            _pendingDonate = new TransactionFactory(_account).Build(
+                _doc.Cache.Utxos, _lastTransactions, destination, amount, feeRate,
+                _doc.Cache.NextChangeIndex, _doc.Cache.TipHeight, sendAll: false);
+
+            DonatePreview = $"txid {_pendingDonate.Txid[..16]}… · " +
+                $"fee {Fmt(_pendingDonate.Fee.Satoshi)} " +
+                $"({_pendingDonate.Transaction.GetVirtualSize()} vB)" +
+                (_pendingDonate.Signed ? "" : " · watch-only");
+            HasPendingDonate = _pendingDonate.Signed;
+        }
+        catch (Exception ex)
+        {
+            _pendingDonate = null;
+            HasPendingDonate = false;
+            DonatePreview = $"Errore: {ex.Message}";
+        }
+        await Task.CompletedTask;
+    }
+
+    [RelayCommand]
+    private async Task ConfirmDonate()
+    {
+        if (_pendingDonate is null || _client is null)
+            return;
+        try
+        {
+            var txid = await _client.BroadcastAsync(_pendingDonate.ToHex());
+            DonatePreview = $"Grazie! txid: {txid}";
+            DonateAmount = "";
+            _pendingDonate = null;
+            HasPendingDonate = false;
+            await ConnectAndSync();
+        }
+        catch (Exception ex)
+        {
+            DonatePreview = $"Errore broadcast: {ex.Message}";
+        }
+    }
+
+    private void ResetDonate()
+    {
+        DonateAmount = "";
+        DonatePreview = "";
+        HasPendingDonate = false;
+        _pendingDonate = null;
+    }
+}

src/App/ViewModels/MainWindowViewModel.Receive.cs

@@ -0,0 +1,297 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia.Media.Imaging;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PalladiumWallet.App.Localization;
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Spv;
+using PalladiumWallet.Core.Storage;
+using PalladiumWallet.Core.Wallet;
+using QRCoder;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    // ---- balance and wallet info ----
+
+    [ObservableProperty]
+    private string balanceText = "—";
+
+    [ObservableProperty]
+    private string unconfirmedText = "";
+
+    [ObservableProperty]
+    private string immatureText = "";
+
+    [ObservableProperty]
+    private string networkInfo = "";
+
+    // ---- receive address and QR ----
+
+    [ObservableProperty]
+    private string receiveAddress = "";
+
+    [ObservableProperty]
+    private Bitmap? receiveQr;
+
+    partial void OnReceiveAddressChanged(string value)
+    {
+        var previous = ReceiveQr;
+        ReceiveQr = string.IsNullOrEmpty(value) ? null : GenerateQr(value);
+        previous?.Dispose();
+    }
+
+    public void NotifyAddressCopied() => StatusMessage = Loc.Tr("addr.copied");
+
+    private static Bitmap? GenerateQr(string text)
+    {
+        try
+        {
+            using var generator = new QRCodeGenerator();
+            using var data = generator.CreateQrCode(text, QRCodeGenerator.ECCLevel.M);
+            var png = new PngByteQRCode(data).GetGraphic(8);
+            return new Bitmap(new MemoryStream(png));
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    // ---- addresses tab ----
+
+    [ObservableProperty]
+    private AddressRow? selectedAddressRow;
+
+    [ObservableProperty]
+    private AddressInfo? addressInfo;
+
+    [ObservableProperty]
+    private bool isAddressPrivKeyRevealed;
+
+    // ---- private key password prompt ----
+
+    [ObservableProperty]
+    private bool isPrivKeyPromptOpen;
+
+    [ObservableProperty]
+    private string privKeyPromptPassword = "";
+
+    [ObservableProperty]
+    private string privKeyPromptError = "";
+
+    partial void OnAddressInfoChanged(AddressInfo? value)
+    {
+        IsAddressPrivKeyRevealed = false;
+        ClosePrivKeyPromptInternal();
+    }
+
+    private void ClosePrivKeyPromptInternal()
+    {
+        IsPrivKeyPromptOpen = false;
+        PrivKeyPromptPassword = "";
+        PrivKeyPromptError = "";
+    }
+
+    public void ShowAddressInfo(AddressRow row) =>
+        AddressInfo = new AddressInfo(Loc, row.Indirizzo, row.DerivPath, row.PubKey, row.PrivKey);
+
+    [RelayCommand]
+    private void CloseAddressInfo()
+    {
+        ClosePrivKeyPromptInternal();
+        AddressInfo = null;
+    }
+
+    [RelayCommand]
+    private void RequestPrivKeyReveal()
+    {
+        if (AddressInfo is null || !AddressInfo.HasPrivKey) return;
+        if (string.IsNullOrEmpty(_password))
+        {
+            // No encryption: reveal directly
+            IsAddressPrivKeyRevealed = true;
+        }
+        else
+        {
+            // Encrypted: open password prompt
+            PrivKeyPromptPassword = "";
+            PrivKeyPromptError = "";
+            IsPrivKeyPromptOpen = true;
+        }
+    }
+
+    [RelayCommand]
+    private void ConfirmPrivKeyPassword()
+    {
+        if (PrivKeyPromptPassword != _password)
+        {
+            PrivKeyPromptError = Loc.Tr("msg.wrongpassword");
+            return;
+        }
+        IsAddressPrivKeyRevealed = true;
+        ClosePrivKeyPromptInternal();
+    }
+
+    [RelayCommand]
+    private void CancelPrivKeyPrompt() => ClosePrivKeyPromptInternal();
+
+    [RelayCommand]
+    private void HideAddressPrivKey()
+    {
+        IsAddressPrivKeyRevealed = false;
+    }
+
+    // ---- transaction detail overlay ----
+
+    [ObservableProperty]
+    private bool isTxDetailsOpen;
+
+    [ObservableProperty]
+    private bool isTxDetailsLoading;
+
+    [ObservableProperty]
+    private TransactionDetailsViewModel? txDetails;
+
+    public async Task ShowTransactionDetailsAsync(string txid)
+    {
+        if (_client is null || !_client.IsConnected)
+        {
+            StatusMessage = Loc.Tr("tx.needconnection");
+            return;
+        }
+
+        _txDetailsCts?.Cancel();
+        _txDetailsCts = new CancellationTokenSource();
+        var ct = _txDetailsCts.Token;
+
+        TxDetails = null;
+        IsTxDetailsLoading = true;
+        IsTxDetailsOpen = true;
+
+        var details = await BuildTransactionDetailsAsync(txid, ct);
+
+        if (ct.IsCancellationRequested || !IsTxDetailsOpen)
+            return;
+
+        if (details is null)
+        {
+            IsTxDetailsOpen = false;
+            IsTxDetailsLoading = false;
+            return;
+        }
+
+        TxDetails = details;
+        IsTxDetailsLoading = false;
+    }
+
+    [RelayCommand]
+    private void CloseTransactionDetails()
+    {
+        _txDetailsCts?.Cancel();
+        IsTxDetailsOpen = false;
+        IsTxDetailsLoading = false;
+        TxDetails = null;
+    }
+
+    public async Task<TransactionDetailsViewModel?> BuildTransactionDetailsAsync(
+        string txid, CancellationToken ct = default)
+    {
+        if (_client is null || !_client.IsConnected)
+        {
+            StatusMessage = Loc.Tr("tx.needconnection");
+            return null;
+        }
+        if (_doc?.Cache is not { } cache)
+            return null;
+
+        var client = _client;
+        var network = PalladiumNetworks.For(Net);
+        var row = cache.History.FirstOrDefault(t => t.Txid == txid);
+        var owned = cache.Addresses.Select(a => a.Address).ToHashSet();
+        var tipHeight = cache.TipHeight;
+        var height = row?.Height ?? 0;
+        var delta = row?.DeltaSats ?? 0;
+        var verified = row?.Verified ?? false;
+        var transactions = _lastTransactions;
+        var loc = _loc;
+        var unit = _config.Unit;
+
+        try
+        {
+            return await Task.Run(async () =>
+            {
+                var details = await TransactionInspector.FetchAsync(
+                    client, network, txid, tipHeight, height, owned, delta, verified, transactions, ct);
+                return new TransactionDetailsViewModel(details, loc, unit);
+            }, ct);
+        }
+        catch (OperationCanceledException)
+        {
+            return null;
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"{Loc.Tr("msg.error")}: {ex.Message}";
+            return null;
+        }
+    }
+
+    // ---- update display from the sync result ----
+
+    private void ApplyCache(SyncCache? cache)
+    {
+        if (_account is null)
+            return;
+        if (cache is null)
+        {
+            BalanceText = $"0.00000000 {Profile.CoinUnit}";
+            UnconfirmedText = "";
+            ImmatureText = "";
+            ReceiveAddress = _account.GetReceiveAddress(0).ToString();
+            History.Clear();
+            Addresses.Clear();
+            for (var i = 0; i < 10; i++)
+                Addresses.Add(new AddressRow(_loc["addr.receive"], i,
+                    _account.GetReceiveAddress(i).ToString(), "—", "—",
+                    false,
+                    _account.GetPublicKey(false, i)?.ToHex() ?? "",
+                    KeyWif(false, i),
+                    $"m/{_doc!.AccountPath}/0/{i}"));
+            return;
+        }
+        BalanceText = Fmt(cache.ConfirmedSats - cache.ImmatureSats);
+        var pending = cache.History.Where(t => t.Height <= 0).Sum(t => t.DeltaSats);
+        UnconfirmedText = pending != 0
+            ? $"{Loc.Tr("msg.pending")}: {(pending > 0 ? "+" : "")}{Fmt(pending)} — {Loc.Tr("msg.notspendable")}"
+            : "";
+        ImmatureText = cache.ImmatureSats != 0
+            ? $"{Loc.Tr("msg.immature")}: {Fmt(cache.ImmatureSats)} — {Loc.Tr("msg.notspendable")}"
+            : "";
+        ReceiveAddress = _account.GetReceiveAddress(cache.NextReceiveIndex).ToString();
+        History.Clear();
+        foreach (var tx in cache.History)
+            History.Add(new HistoryRow(
+                tx.Height > 0 ? tx.Height.ToString() : "mempool",
+                (tx.DeltaSats >= 0 ? "+" : "") + Fmt(tx.DeltaSats, withLabel: false),
+                tx.Txid));
+
+        Addresses.Clear();
+        foreach (var a in cache.Addresses)
+            Addresses.Add(new AddressRow(
+                a.IsChange ? _loc["addr.change"] : _loc["addr.receive"],
+                a.Index,
+                a.Address,
+                a.BalanceSats > 0 ? Fmt(a.BalanceSats, withLabel: false) : (a.TxCount > 0 ? "0" : "—"),
+                a.TxCount > 0 ? a.TxCount.ToString() : "—",
+                a.IsChange,
+                _account.GetPublicKey(a.IsChange, a.Index)?.ToHex() ?? "",
+                KeyWif(a.IsChange, a.Index),
+                $"m/{_doc!.AccountPath}/{(a.IsChange ? 1 : 0)}/{a.Index}"));
+    }
+}

src/App/ViewModels/MainWindowViewModel.Send.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using NBitcoin;
+using PalladiumWallet.App.Services;
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Net;
+using PalladiumWallet.Core.Wallet;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    [ObservableProperty]
+    private string sendTo = "";
+
+    [ObservableProperty]
+    private string sendAmount = "";
+
+    [ObservableProperty]
+    private string sendFeeRate = "1";
+
+    [ObservableProperty]
+    private bool sendAll;
+
+    [ObservableProperty]
+    private string sendPreview = "";
+
+    [ObservableProperty]
+    private bool hasPendingSend;
+
+    [RelayCommand]
+    private async Task ScanQr()
+    {
+        if (PlatformServices.ScanQrAsync is not { } scan) return;
+        var raw = await scan();
+        if (string.IsNullOrWhiteSpace(raw)) return;
+        // Handle URIs like "palladium:ADDRESS?amount=X" — extract address only
+        var address = raw.Contains(':') ? raw.Split(':')[1] : raw;
+        if (address.Contains('?')) address = address.Split('?')[0];
+        SendTo = address.Trim();
+    }
+
+    [RelayCommand]
+    private async Task PrepareSend()
+    {
+        if (_account is null || _doc?.Cache is null)
+        {
+            SendPreview = "Sincronizza prima di inviare.";
+            return;
+        }
+        try
+        {
+            if (_lastTransactions is null)
+            {
+                SendPreview = "Connettiti al server e sincronizza prima di inviare.";
+                return;
+            }
+
+            var destination = BitcoinAddress.Create(SendTo.Trim(), PalladiumNetworks.For(Net));
+            long amount = 0;
+            if (!SendAll && !CoinAmount.TryParseIn(SendAmount, _config.Unit, out amount))
+            {
+                SendPreview = "Importo non valido.";
+                return;
+            }
+            if (!decimal.TryParse(SendFeeRate, out var feeRate) || feeRate <= 0)
+            {
+                SendPreview = "Fee rate non valido.";
+                return;
+            }
+
+            _pendingSend = new TransactionFactory(_account).Build(
+                _doc.Cache.Utxos, _lastTransactions, destination, amount, feeRate,
+                _doc.Cache.NextChangeIndex, _doc.Cache.TipHeight, SendAll);
+
+            SendPreview = $"txid {_pendingSend.Txid[..16]}… · " +
+                $"fee {Fmt(_pendingSend.Fee.Satoshi)} " +
+                $"({_pendingSend.Transaction.GetVirtualSize()} vB)" +
+                (_pendingSend.Signed ? "" : " · NON firmata (watch-only)");
+            HasPendingSend = _pendingSend.Signed;
+        }
+        catch (Exception ex)
+        {
+            _pendingSend = null;
+            HasPendingSend = false;
+            SendPreview = $"Errore: {ex.Message}";
+        }
+        await Task.CompletedTask;
+    }
+
+    [RelayCommand]
+    private async Task ConfirmSend()
+    {
+        if (_pendingSend is null || _client is null)
+            return;
+        try
+        {
+            var txid = await _client.BroadcastAsync(_pendingSend.ToHex());
+            SendPreview = $"Trasmessa: {txid}";
+            SendTo = SendAmount = "";
+            _pendingSend = null;
+            HasPendingSend = false;
+            await ConnectAndSync();
+        }
+        catch (Exception ex)
+        {
+            SendPreview = $"Errore broadcast: {ex.Message}";
+        }
+    }
+}

src/App/ViewModels/MainWindowViewModel.Settings.cs

@@ -0,0 +1,80 @@
+using CommunityToolkit.Mvvm.Input;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    // ---- spunte del menu Impostazioni (ToggleType Radio) ----
+
+    public bool IsLangIt => _config.Language == "it";
+    public bool IsLangEn => _config.Language == "en";
+    public bool IsLangEs => _config.Language == "es";
+    public bool IsLangFr => _config.Language == "fr";
+    public bool IsLangPt => _config.Language == "pt";
+    public bool IsLangDe => _config.Language == "de";
+    public bool IsUnitPlm => _config.Unit == "PLM";
+    public bool IsUnitMilli => _config.Unit == "mPLM";
+    public bool IsUnitMicro => _config.Unit == "µPLM";
+    public bool IsUnitSat => _config.Unit == "sat";
+
+    [RelayCommand]
+    private void SetLanguage(string language)
+    {
+        _config.Language = language;
+        ApplySettings(_config);
+    }
+
+    [RelayCommand]
+    private void SetUnit(string unit)
+    {
+        _config.Unit = unit;
+        ApplySettings(_config);
+    }
+
+    public void ApplySettings(PalladiumWallet.Core.Storage.AppConfig config)
+    {
+        _config = config;
+        _config.Save();
+        _loc = Localization.Loc.SwitchTo(config.Language);
+        OnPropertyChanged(nameof(Loc));
+        OnPropertyChanged(nameof(UnitLabel));
+        OnPropertyChanged(nameof(IsLangIt));
+        OnPropertyChanged(nameof(IsLangEn));
+        OnPropertyChanged(nameof(IsLangEs));
+        OnPropertyChanged(nameof(IsLangFr));
+        OnPropertyChanged(nameof(IsLangPt));
+        OnPropertyChanged(nameof(IsLangDe));
+        OnPropertyChanged(nameof(IsUnitPlm));
+        OnPropertyChanged(nameof(IsUnitMilli));
+        OnPropertyChanged(nameof(IsUnitMicro));
+        OnPropertyChanged(nameof(IsUnitSat));
+        ApplyCache(_doc?.Cache);
+        StatusMessage = Localization.Loc.Tr("msg.settings.saved");
+    }
+
+    // ---- overlay impostazioni, server, help ----
+
+    [CommunityToolkit.Mvvm.ComponentModel.ObservableProperty]
+    private bool isSettingsOpen;
+
+    [RelayCommand]
+    private void OpenSettings() => IsSettingsOpen = true;
+
+    [RelayCommand]
+    private void CloseSettings() => IsSettingsOpen = false;
+
+    [CommunityToolkit.Mvvm.ComponentModel.ObservableProperty]
+    private bool isHelpOpen;
+
+    [RelayCommand]
+    private void OpenHelp() => IsHelpOpen = true;
+
+    [RelayCommand]
+    private static void QuitApp() =>
+        (Avalonia.Application.Current?.ApplicationLifetime
+            as Avalonia.Controls.ApplicationLifetimes.IClassicDesktopStyleApplicationLifetime)
+            ?.Shutdown();
+
+    [RelayCommand]
+    private void CloseHelp() { IsHelpOpen = false; ResetDonate(); }
+}

src/App/ViewModels/MainWindowViewModel.Sync.cs

@@ -0,0 +1,465 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia.Threading;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PalladiumWallet.App.Localization;
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Net;
+using PalladiumWallet.Core.Spv;
+using PalladiumWallet.Core.Storage;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    // ---- server and connection ----
+
+    [ObservableProperty]
+    private string serverHost = "";
+
+    [ObservableProperty]
+    private string serverPort = "";
+
+    [ObservableProperty]
+    private bool useSsl = true;
+
+    [ObservableProperty]
+    private bool isServerSettingsOpen;
+
+    [RelayCommand]
+    private async Task OpenServerSettings()
+    {
+        IsSettingsOpen = false;
+        RefreshServers();
+        IsServerSettingsOpen = true;
+        if (_client is { IsConnected: true })
+            await DiscoverServers();
+    }
+
+    [RelayCommand]
+    private void CloseServerSettings() => IsServerSettingsOpen = false;
+
+    [ObservableProperty]
+    private string connectionStatus = Loc.Tr("conn.none");
+
+    [ObservableProperty]
+    private string connectionStatusShort = Loc.Tr("conn.none");
+
+    [ObservableProperty]
+    private bool isConnected;
+
+    [ObservableProperty]
+    private bool isSyncing;
+
+    private CancellationTokenSource _syncCts = new();
+
+    public ObservableCollection<KnownServer> KnownServers { get; } = [];
+
+    [ObservableProperty]
+    private KnownServer? selectedKnownServer;
+
+    partial void OnSelectedKnownServerChanged(KnownServer? value)
+    {
+        if (value is null)
+            return;
+        _syncingServerFields = true;
+        ServerHost = value.Host;
+        ServerPort = value.PortFor(UseSsl).ToString();
+        _syncingServerFields = false;
+    }
+
+    partial void OnUseSslChanged(bool value)
+    {
+        if (_syncingServerFields)
+            return;
+        _syncingServerFields = true;
+        ServerPort = SelectedKnownServer is { } server
+            ? server.PortFor(value).ToString()
+            : (value ? Profile.DefaultSslPort : Profile.DefaultTcpPort).ToString();
+        _syncingServerFields = false;
+    }
+
+    partial void OnServerPortChanged(string value)
+    {
+        if (_syncingServerFields)
+            return;
+        if (!int.TryParse(value.Trim(), out var port))
+            return;
+        bool? wantSsl =
+            SelectedKnownServer is { } s && port == s.SslPort ? true :
+            SelectedKnownServer is { } t && port == t.TcpPort ? false :
+            port == Profile.DefaultSslPort ? true :
+            port == Profile.DefaultTcpPort ? false :
+            null;
+        if (wantSsl is bool b && b != UseSsl)
+        {
+            _syncingServerFields = true;
+            UseSsl = b;
+            _syncingServerFields = false;
+        }
+    }
+
+    private void RefreshServers()
+    {
+        KnownServers.Clear();
+        foreach (var server in Registry.All)
+            KnownServers.Add(server);
+
+        if (_config.LastServerHost is { Length: > 0 } savedHost && _config.LastServerPort is { } savedPort)
+        {
+            _syncingServerFields = true;
+            UseSsl = _config.LastServerUseSsl;
+            ServerHost = savedHost;
+            ServerPort = savedPort.ToString();
+            SelectedKnownServer = KnownServers.FirstOrDefault(s => s.Host == savedHost);
+            _syncingServerFields = false;
+        }
+        else
+        {
+            SelectedKnownServer = KnownServers.FirstOrDefault();
+            if (SelectedKnownServer is null)
+            {
+                ServerHost = "127.0.0.1";
+                ServerPort = (UseSsl ? Profile.DefaultSslPort : Profile.DefaultTcpPort).ToString();
+            }
+        }
+    }
+
+    private (string Host, int Port) ParseServer()
+    {
+        var host = ServerHost.Trim();
+        var port = int.TryParse(ServerPort.Trim(), out var p)
+            ? p
+            : UseSsl ? Profile.DefaultSslPort : Profile.DefaultTcpPort;
+        return (host, port);
+    }
+
+    /// <summary>
+    /// Returns servers to try in order: first the one selected in the UI
+    /// (or manually typed), then the remaining KnownServers, with duplicates skipped.
+    /// </summary>
+    private IEnumerable<(string Host, int Port)> BuildServerCandidates(string selectedHost, int selectedPort)
+    {
+        var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        // 1. Current server (selected or manually typed).
+        if (!string.IsNullOrWhiteSpace(selectedHost))
+        {
+            var key = $"{selectedHost}:{selectedPort}";
+            if (seen.Add(key))
+                yield return (selectedHost, selectedPort);
+        }
+        // 2. Other known servers, in list order.
+        foreach (var s in KnownServers)
+        {
+            var p = s.PortFor(UseSsl);
+            var key = $"{s.Host}:{p}";
+            if (seen.Add(key))
+                yield return (s.Host, p);
+        }
+    }
+
+    [RelayCommand]
+    private async Task ConnectAndSync()
+    {
+        if (IsSyncing)
+        {
+            var (newHost, newPort) = ParseServer();
+            bool serverChanged = _client is null
+                || _client.Host != newHost
+                || _client.Port != newPort
+                || _client.UseSsl != UseSsl;
+            if (serverChanged)
+                _syncCts.Cancel();
+            else
+                _resyncRequested = true;
+            return;
+        }
+
+        _syncCts = new CancellationTokenSource();
+        var ct = _syncCts.Token;
+        IsSyncing = true;
+        StatusMessage = "";
+        bool cancelled = false;
+        try
+        {
+            var (host, port) = ParseServer();
+
+            if (_client is { } current &&
+                (current.Host != host || current.Port != port || current.UseSsl != UseSsl))
+            {
+                await DisconnectAsync();
+            }
+
+            if (_client is null || !_client.IsConnected)
+            {
+                // Persist caches before destroying the synchronizer: the new
+                // synchronizer will use a different client and must be recreated,
+                // but already-downloaded data is preserved via _doc.Cache.
+                PersistPartialTxCache();
+                _synchronizer = null;
+
+                // Try all known servers in order; starts with the selected one
+                // and walks the list until the first that responds.
+                var candidates = BuildServerCandidates(host, port);
+                Exception? lastError = null;
+                foreach (var (h, p) in candidates)
+                {
+                    ct.ThrowIfCancellationRequested();
+                    ConnectionStatus = $"{Loc.Tr("conn.connectingto")} {h}:{p}…";
+                    ConnectionStatusShort = Loc.Tr("conn.connectingto") + "…";
+                    try
+                    {
+                        var pins = new CertificatePinStore(AppPaths.CertificatePinsPath(Net));
+                        _client = await ElectrumClient.ConnectAsync(h, p, UseSsl, pins, ct);
+                        _client.NotificationReceived += OnServerNotification;
+                        _client.Disconnected += _ => Dispatcher.UIThread.Post(() =>
+                        {
+                            IsConnected = false;
+                            ConnectionStatus = Loc.Tr("conn.none");
+                            ConnectionStatusShort = Loc.Tr("conn.none");
+                        });
+                        IsConnected = true;
+                        _autoReconnect = true;
+                        ConnectionStatus = $"{Loc.Tr("conn.connectedto")} {h}:{p}";
+                        ConnectionStatusShort = Loc.Tr("conn.connectedto");
+                        // Update the UI to reflect the server actually connected.
+                        _syncingServerFields = true;
+                        ServerHost = h;
+                        ServerPort = p.ToString();
+                        SelectedKnownServer = KnownServers.FirstOrDefault(s => s.Host == h)
+                            ?? SelectedKnownServer;
+                        _syncingServerFields = false;
+                        // Persist the last-used server so it is restored on next launch.
+                        _config.LastServerHost = h;
+                        _config.LastServerPort = p;
+                        _config.LastServerUseSsl = UseSsl;
+                        _config.Save();
+                        lastError = null;
+                        break;
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        throw;
+                    }
+                    catch (Exception ex)
+                    {
+                        lastError = ex;
+                        _client = null;
+                    }
+                }
+                if (lastError is not null)
+                    throw lastError;
+            }
+
+            if (_account is null || _doc is null)
+                return;
+
+            if (_synchronizer is null)
+            {
+                _synchronizer = new WalletSynchronizer(_account, _client!, _doc.GapLimit);
+                // Reload from disk cache: avoids re-downloading already known transactions
+                // (essential for wallets with thousands of historical txs — prevents -101).
+                var net = PalladiumNetworks.For(_account.Profile.Kind);
+                _synchronizer.PreloadCaches(
+                    _doc.Cache?.RawTxHex ?? [],
+                    _doc.Cache?.VerifiedAt ?? [],
+                    _doc.Cache?.BlockHeaders,
+                    _doc.Cache?.NextReceiveIndex ?? 0,
+                    _doc.Cache?.NextChangeIndex ?? 0,
+                    net);
+                _synchronizer.Progress += msg => Dispatcher.UIThread.Post(() => StatusMessage = msg);
+            }
+
+            do
+            {
+                _resyncRequested = false;
+                var result = await _synchronizer.SyncOnceAsync(ct);
+                _lastTransactions = result.Transactions;
+
+                var (rawHex, verifiedAt, blockHeaders) = _synchronizer.ExportCaches(
+                    PalladiumNetworks.For(_account.Profile.Kind));
+                _doc.Cache = new SyncCache
+                {
+                    TipHeight = result.TipHeight,
+                    ConfirmedSats = result.ConfirmedSats,
+                    UnconfirmedSats = result.UnconfirmedSats,
+                    ImmatureSats = result.ImmatureSats,
+                    NextReceiveIndex = result.NextReceiveIndex,
+                    NextChangeIndex = result.NextChangeIndex,
+                    History = [.. result.History],
+                    Utxos = [.. result.Utxos],
+                    Addresses = [.. result.AddressRows],
+                    RawTxHex = rawHex,
+                    VerifiedAt = verifiedAt,
+                    BlockHeaders = blockHeaders,
+                };
+                WalletStore.Save(_doc, _walletPath!, _password);
+                ApplyCache(_doc.Cache);
+                _syncFailed = false;
+                StatusMessage = $"{Loc.Tr("msg.synced")}: {Loc.Tr("msg.height")} {result.TipHeight}, " +
+                    $"{result.History.Count} {Loc.Tr("msg.synced.detail")}";
+            } while (_resyncRequested && !ct.IsCancellationRequested);
+        }
+        catch (OperationCanceledException)
+        {
+            // Intentional cancellation due to server change request — not an error.
+            cancelled = true;
+            IsConnected = false;
+            ConnectionStatus = Loc.Tr("conn.none");
+            ConnectionStatusShort = Loc.Tr("conn.none");
+            StatusMessage = "";
+        }
+        catch (CertificatePinMismatchException ex)
+        {
+            IsConnected = false;
+            ConnectionStatus = Loc.Tr("conn.none");
+            ConnectionStatusShort = Loc.Tr("conn.none");
+            StatusMessage = ex.Message;
+        }
+        catch (Exception ex)
+        {
+            IsConnected = _client?.IsConnected == true;
+            ConnectionStatus = IsConnected ? ConnectionStatus : Loc.Tr("conn.none");
+            ConnectionStatusShort = IsConnected ? Loc.Tr("conn.connectedto") : Loc.Tr("conn.none");
+            StatusMessage = $"Errore: {ex.Message}";
+            if (_account is not null)
+            {
+                _syncFailed = true;
+                // Persist already-downloaded transactions: on retry the synchronizer
+                // resumes from here instead of starting from scratch (e.g. after -101).
+                PersistPartialTxCache();
+            }
+        }
+        finally
+        {
+            IsSyncing = false;
+        }
+
+        // If cancelled due to a server change, restart immediately with the new server.
+        if (cancelled)
+            _ = ConnectAndSync();
+    }
+
+    /// <summary>
+    /// Peer discovery. Always clickable: if the wallet is already connected, it reuses
+    /// that connection; otherwise it opens a short-lived connection to a candidate server
+    /// just to query its peer list, without touching the wallet's connection state.
+    /// </summary>
+    [RelayCommand]
+    private async Task DiscoverServers()
+    {
+        if (_client is { IsConnected: true } connected)
+        {
+            await DiscoverServersUsing(connected);
+            return;
+        }
+
+        var (host, port) = ParseServer();
+        ElectrumClient? temp = null;
+        Exception? lastError = null;
+        foreach (var (h, p) in BuildServerCandidates(host, port))
+        {
+            try
+            {
+                var pins = new CertificatePinStore(AppPaths.CertificatePinsPath(Net));
+                temp = await ElectrumClient.ConnectAsync(h, p, UseSsl, pins);
+                lastError = null;
+                break;
+            }
+            catch (Exception ex)
+            {
+                lastError = ex;
+            }
+        }
+        if (temp is null)
+        {
+            StatusMessage = $"Errore nella scoperta peer: {lastError?.Message ?? Loc.Tr("conn.none")}";
+            return;
+        }
+        try
+        {
+            await DiscoverServersUsing(temp);
+        }
+        finally
+        {
+            await temp.DisposeAsync();
+        }
+    }
+
+    private async Task DiscoverServersUsing(ElectrumClient client)
+    {
+        try
+        {
+            var added = await Registry.DiscoverAsync(client);
+            var selected = SelectedKnownServer;
+            RefreshServers();
+            SelectedKnownServer = KnownServers.FirstOrDefault(s => s.Host == selected?.Host)
+                ?? KnownServers.FirstOrDefault();
+            StatusMessage = added > 0
+                ? $"Trovati {added} nuovi server dai peer (totale {KnownServers.Count})."
+                : $"Nessun nuovo server annunciato (totale {KnownServers.Count}).";
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Errore nella scoperta peer: {ex.Message}";
+        }
+    }
+
+    private void OnServerNotification(string method, System.Text.Json.JsonElement payload)
+    {
+        if (method is "blockchain.scripthash.subscribe" or "blockchain.headers.subscribe")
+            Dispatcher.UIThread.Post(() =>
+            {
+                if (IsSyncing)
+                    _resyncRequested = true;
+                else
+                    _ = ConnectAndSync();
+            });
+    }
+
+    [RelayCommand]
+    private void ResetCertificates()
+    {
+        new CertificatePinStore(AppPaths.CertificatePinsPath(Net)).ResetAll();
+        StatusMessage = Loc.Tr("msg.certreset");
+    }
+
+    /// <summary>
+    /// Persists the transactions and Merkle proofs already accumulated by the synchronizer
+    /// into SyncCache, even if sync is not yet complete. Allows the next retry
+    /// (or app restart) to resume without re-downloading from scratch.
+    /// </summary>
+    private void PersistPartialTxCache()
+    {
+        if (_synchronizer is null || _doc is null || _walletPath is null || _account is null)
+            return;
+        try
+        {
+            var net = PalladiumNetworks.For(_account.Profile.Kind);
+            var (rawHex, verifiedAt, blockHeaders) = _synchronizer.ExportCaches(net);
+            if (rawHex.Count == 0 && verifiedAt.Count == 0)
+                return;
+            (_doc.Cache ??= new SyncCache()).RawTxHex = rawHex;
+            _doc.Cache.VerifiedAt = verifiedAt;
+            _doc.Cache.BlockHeaders = blockHeaders;
+            WalletStore.Save(_doc, _walletPath, _password);
+        }
+        catch { /* non-fatal: the next full save will recover */ }
+    }
+
+    private async Task DisconnectAsync()
+    {
+        if (_client is { } client)
+        {
+            _client = null;
+            _synchronizer = null;
+            try { await client.DisposeAsync(); } catch { }
+        }
+        IsConnected = false;
+    }
+}

src/App/ViewModels/MainWindowViewModel.Update.cs

@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PalladiumWallet.Core.Net;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    // ---- update-available overlay ----
+
+    [ObservableProperty]
+    private bool isUpdateAvailableOpen;
+
+    [ObservableProperty]
+    private string updateAvailableTag = "";
+
+    public string UpdateReleaseUrl { get; private set; } = "";
+
+    [RelayCommand]
+    private void CloseUpdateAvailable() => IsUpdateAvailableOpen = false;
+
+    /// <summary>
+    /// Fire-and-forget check run once at startup. Best-effort: any failure or an
+    /// up-to-date app silently does nothing (see <see cref="UpdateChecker"/>).
+    /// </summary>
+    private async Task CheckForUpdatesAsync()
+    {
+        var latest = await UpdateChecker.CheckAsync(AppVersion);
+        if (latest is null) return;
+
+        UpdateReleaseUrl = latest.HtmlUrl;
+        UpdateAvailableTag = latest.Tag;
+        IsUpdateAvailableOpen = true;
+    }
+}

src/App/ViewModels/MainWindowViewModel.WalletInfo.cs

@@ -0,0 +1,114 @@
+using System.IO;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PalladiumWallet.App.Localization;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    [ObservableProperty]
+    private bool isWalletInfoOpen;
+
+    [ObservableProperty]
+    private string walletInfoSeedPasswordInput = "";
+
+    [ObservableProperty]
+    private bool isWalletInfoSeedRevealed;
+
+    [ObservableProperty]
+    private string walletInfoSeedError = "";
+
+    // ---- computed wallet info (populated when overlay opens) ----
+
+    public string WalletInfoFileName =>
+        _walletPath is null ? "" :
+        Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(_walletPath));
+
+    public string WalletInfoNetwork => _doc?.Network ?? "";
+
+    public string WalletInfoType
+    {
+        get
+        {
+            if (_doc is null) return "";
+            if (_doc.Mnemonic is not null) return Loc.Tr("walletinfo.type.seed");
+            if (_doc.AccountXprv is not null) return Loc.Tr("walletinfo.type.xprv");
+            if (_doc.WifKeys is { Count: > 0 }) return Loc.Tr("walletinfo.type.wif");
+            return Loc.Tr("walletinfo.type.watchonly");
+        }
+    }
+
+    public string WalletInfoScriptKind => _doc?.ScriptKind ?? "";
+
+    public string WalletInfoDerivPath => _doc?.AccountPath ?? "";
+
+    public string WalletInfoXpub => _doc?.AccountXpub ?? "";
+
+    public string WalletInfoFingerprint => _doc?.MasterFingerprint ?? "";
+
+    public bool WalletInfoHasSeed => _doc?.Mnemonic is not null;
+
+    public bool WalletInfoSeedNeedsPassword => !string.IsNullOrEmpty(_password);
+
+    public string WalletInfoSeedText => IsWalletInfoSeedRevealed ? (_doc?.Mnemonic ?? "") : "";
+
+    public bool WalletInfoHasPassphrase => !string.IsNullOrEmpty(_doc?.Passphrase);
+
+    [RelayCommand]
+    private void OpenWalletInfo()
+    {
+        WalletInfoSeedPasswordInput = "";
+        IsWalletInfoSeedRevealed = false;
+        WalletInfoSeedError = "";
+        OnPropertyChanged(nameof(WalletInfoFileName));
+        OnPropertyChanged(nameof(WalletInfoNetwork));
+        OnPropertyChanged(nameof(WalletInfoType));
+        OnPropertyChanged(nameof(WalletInfoScriptKind));
+        OnPropertyChanged(nameof(WalletInfoDerivPath));
+        OnPropertyChanged(nameof(WalletInfoXpub));
+        OnPropertyChanged(nameof(WalletInfoFingerprint));
+        OnPropertyChanged(nameof(WalletInfoHasSeed));
+        OnPropertyChanged(nameof(WalletInfoSeedNeedsPassword));
+        OnPropertyChanged(nameof(WalletInfoHasPassphrase));
+        IsWalletInfoOpen = true;
+    }
+
+    [RelayCommand]
+    private void CloseWalletInfo()
+    {
+        IsWalletInfoOpen = false;
+        WalletInfoSeedPasswordInput = "";
+        IsWalletInfoSeedRevealed = false;
+        WalletInfoSeedError = "";
+        OnPropertyChanged(nameof(WalletInfoSeedText));
+    }
+
+    [RelayCommand]
+    private void RevealSeed()
+    {
+        if (_doc?.Mnemonic is null) return;
+
+        if (WalletInfoSeedNeedsPassword)
+        {
+            if (WalletInfoSeedPasswordInput != _password)
+            {
+                WalletInfoSeedError = Loc.Tr("msg.wrongpassword");
+                return;
+            }
+        }
+
+        WalletInfoSeedError = "";
+        IsWalletInfoSeedRevealed = true;
+        OnPropertyChanged(nameof(WalletInfoSeedText));
+    }
+
+    [RelayCommand]
+    private void HideSeed()
+    {
+        IsWalletInfoSeedRevealed = false;
+        WalletInfoSeedPasswordInput = "";
+        WalletInfoSeedError = "";
+        OnPropertyChanged(nameof(WalletInfoSeedText));
+    }
+}

src/App/ViewModels/MainWindowViewModel.Wizard.cs

@@ -0,0 +1,519 @@
+using System;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PalladiumWallet.App.Localization;
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Crypto;
+using PalladiumWallet.Core.Storage;
+using PalladiumWallet.Core.Wallet;
+
+namespace PalladiumWallet.App.ViewModels;
+
+public partial class MainWindowViewModel
+{
+    // ---- setup wizard
+
+    public const string StepDataLocation = "data-location";
+    public const string StepStart = "start";
+    public const string StepChooseWallet = "choose-wallet";
+    public const string StepOpen = "open";
+    public const string StepShowSeed = "show-seed";
+    public const string StepConfirmSeed = "confirm-seed";
+    public const string StepWords = "words";
+    public const string StepPassphrase = "passphrase";
+    public const string StepScriptType = "script-type";
+    public const string StepImportXkey = "import-xkey";
+    public const string StepImportWif = "import-wif";
+    public const string StepPassword = "password";
+
+    private enum WizardFlowKind { New, Restore, ImportXkey, ImportWif }
+    private WizardFlowKind _wizardFlow;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsStepDataLocation))]
+    [NotifyPropertyChangedFor(nameof(IsStepStart))]
+    [NotifyPropertyChangedFor(nameof(IsStepChooseWallet))]
+    [NotifyPropertyChangedFor(nameof(IsStepOpen))]
+    [NotifyPropertyChangedFor(nameof(IsStepShowSeed))]
+    [NotifyPropertyChangedFor(nameof(IsStepConfirmSeed))]
+    [NotifyPropertyChangedFor(nameof(IsStepWords))]
+    [NotifyPropertyChangedFor(nameof(IsStepPassphrase))]
+    [NotifyPropertyChangedFor(nameof(IsStepScriptType))]
+    [NotifyPropertyChangedFor(nameof(IsStepImportXkey))]
+    [NotifyPropertyChangedFor(nameof(IsStepImportWif))]
+    [NotifyPropertyChangedFor(nameof(IsStepPassword))]
+    private string setupStep = StepStart;
+
+    public bool IsStepDataLocation => SetupStep == StepDataLocation;
+    public bool IsStepStart        => SetupStep == StepStart;
+    public bool IsStepChooseWallet => SetupStep == StepChooseWallet;
+    public bool IsStepOpen         => SetupStep == StepOpen;
+    public bool IsStepShowSeed     => SetupStep == StepShowSeed;
+    public bool IsStepConfirmSeed  => SetupStep == StepConfirmSeed;
+    public bool IsStepWords        => SetupStep == StepWords;
+    public bool IsStepPassphrase   => SetupStep == StepPassphrase;
+    public bool IsStepScriptType   => SetupStep == StepScriptType;
+    public bool IsStepImportXkey   => SetupStep == StepImportXkey;
+    public bool IsStepImportWif    => SetupStep == StepImportWif;
+    public bool IsStepPassword     => SetupStep == StepPassword;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsLegacySelected))]
+    [NotifyPropertyChangedFor(nameof(IsWrappedSegwitSelected))]
+    [NotifyPropertyChangedFor(nameof(IsNativeSegwitSelected))]
+    [NotifyPropertyChangedFor(nameof(IsTaprootSelected))]
+    private ScriptKind selectedScriptKind = ScriptKind.NativeSegwit;
+
+    public bool IsLegacySelected        => SelectedScriptKind == ScriptKind.Legacy;
+    public bool IsWrappedSegwitSelected => SelectedScriptKind == ScriptKind.WrappedSegwit;
+    public bool IsNativeSegwitSelected  => SelectedScriptKind == ScriptKind.NativeSegwit;
+    public bool IsTaprootSelected       => SelectedScriptKind == ScriptKind.Taproot;
+
+    [RelayCommand] private void SelectLegacy()        => SelectedScriptKind = ScriptKind.Legacy;
+    [RelayCommand] private void SelectWrappedSegwit() => SelectedScriptKind = ScriptKind.WrappedSegwit;
+    [RelayCommand] private void SelectNativeSegwit()  => SelectedScriptKind = ScriptKind.NativeSegwit;
+    [RelayCommand] private void SelectTaproot()       => SelectedScriptKind = ScriptKind.Taproot;
+
+    public string DefaultDataPath => AppPaths.DefaultDataRoot();
+
+    [ObservableProperty]
+    private string importXkeyInput = "";
+
+    [ObservableProperty]
+    private string importWifInput = "";
+
+    // Script type detected during xkey decoding (to display to the user)
+    [ObservableProperty]
+    private string importXkeyDetectedKind = "";
+
+    [ObservableProperty]
+    private string mnemonicInput = "";
+
+    [ObservableProperty]
+    private string confirmMnemonicInput = "";
+
+    [ObservableProperty]
+    private string passphraseInput = "";
+
+    [ObservableProperty]
+    private string walletNameInput = "";
+
+    [ObservableProperty]
+    private string passwordInput = "";
+
+    [ObservableProperty]
+    private string confirmPasswordInput = "";
+
+    [ObservableProperty]
+    private bool encryptWallet = true;
+
+    [ObservableProperty]
+    private bool walletFileExists;
+
+    public ObservableCollection<WalletFileEntry> WalletList { get; } = [];
+
+    [RelayCommand]
+    private void UseDefaultDataLocation() => ApplyDataLocation(AppPaths.DefaultDataRoot());
+
+    public void ApplyDataLocation(string root)
+    {
+        try
+        {
+            AppPaths.ConfigureDataLocation(root);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"{Loc.Tr("msg.error")}: {ex.Message}";
+            return;
+        }
+        _config = AppConfig.Load();
+        _loc = Loc.SwitchTo(_config.Language);
+        OnPropertyChanged(nameof(Loc));
+        OnPropertyChanged(nameof(UnitLabel));
+        RefreshSetupState();
+    }
+
+    private void RefreshSetupState()
+    {
+        SetupStep = StepStart;
+        SelectedScriptKind = ScriptKind.NativeSegwit;
+        MnemonicInput = ConfirmMnemonicInput = PassphraseInput = PasswordInput = ConfirmPasswordInput = "";
+        WalletFileExists = AppPaths.WalletFiles(Net).Count > 0;
+        StatusMessage = "";
+        RefreshServers();
+        _ = ConnectAndSync();
+    }
+
+    [RelayCommand]
+    private void WizardStartOpen()
+    {
+        var files = AppPaths.WalletFiles(Net);
+        if (files.Count > 1)
+        {
+            WalletList.Clear();
+            foreach (var path in files)
+                WalletList.Add(new WalletFileEntry(Path.GetFileName(path), path));
+            SetupStep = StepChooseWallet;
+            StatusMessage = "";
+            return;
+        }
+        _pendingOpenPath = files.Count == 1 ? files[0] : AppPaths.DefaultWalletPath(Net);
+        PasswordInput = "";
+        SetupStep = StepOpen;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void ChooseWallet(WalletFileEntry? entry)
+    {
+        if (entry is null)
+            return;
+        _pendingOpenPath = entry.Path;
+        PasswordInput = "";
+        SetupStep = StepOpen;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardStartNew()
+    {
+        _wizardFlow = WizardFlowKind.New;
+        MnemonicInput = Bip39.Generate(MnemonicLength.Twelve).ToString();
+        SetupStep = StepShowSeed;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardStartRestore()
+    {
+        _wizardFlow = WizardFlowKind.Restore;
+        MnemonicInput = "";
+        SetupStep = StepWords;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardStartImportXkey()
+    {
+        _wizardFlow = WizardFlowKind.ImportXkey;
+        ImportXkeyInput = "";
+        ImportXkeyDetectedKind = "";
+        SetupStep = StepImportXkey;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardStartImportWif()
+    {
+        _wizardFlow = WizardFlowKind.ImportWif;
+        ImportWifInput = "";
+        SetupStep = StepImportWif;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardNextFromShowSeed()
+    {
+        ConfirmMnemonicInput = "";
+        SetupStep = StepConfirmSeed;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardNextFromConfirmSeed()
+    {
+        var normalized = string.Join(' ',
+            ConfirmMnemonicInput.Split(' ', StringSplitOptions.RemoveEmptyEntries));
+        if (!string.Equals(normalized, MnemonicInput, StringComparison.OrdinalIgnoreCase))
+        {
+            StatusMessage = Loc.Tr("msg.seed.mismatch");
+            return;
+        }
+        GoToPassphraseStep();
+    }
+
+    [RelayCommand]
+    private void WizardNextFromWords()
+    {
+        if (!Bip39.TryParse(MnemonicInput, out _))
+        {
+            StatusMessage = Loc.Tr("msg.words.invalid");
+            return;
+        }
+        GoToPassphraseStep();
+    }
+
+    private void GoToPassphraseStep()
+    {
+        PassphraseInput = "";
+        SetupStep = StepPassphrase;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardNextFromPassphrase()
+    {
+        SetupStep = StepScriptType;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardNextFromImportXkey()
+    {
+        if (string.IsNullOrWhiteSpace(ImportXkeyInput))
+        {
+            StatusMessage = Loc.Tr("msg.xkey.required");
+            return;
+        }
+        // Validate and detect the type: try as xpub first, then as xprv.
+        if (Slip132.TryDecodePublic(ImportXkeyInput.Trim(), Profile, out _, out var pubKind))
+        {
+            SelectedScriptKind = pubKind;
+            ImportXkeyDetectedKind = $"{pubKind} (watch-only)";
+        }
+        else if (Slip132.TryDecodePrivate(ImportXkeyInput.Trim(), Profile, out _, out var prvKind))
+        {
+            SelectedScriptKind = prvKind;
+            ImportXkeyDetectedKind = prvKind.ToString();
+        }
+        else
+        {
+            StatusMessage = Loc.Tr("msg.xkey.invalid");
+            return;
+        }
+        PasswordInput = ConfirmPasswordInput = "";
+        EncryptWallet = true;
+        SetupStep = StepPassword;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardNextFromImportWif()
+    {
+        if (string.IsNullOrWhiteSpace(ImportWifInput))
+        {
+            StatusMessage = Loc.Tr("msg.wif.required");
+            return;
+        }
+        // Validate the WIF with an early parse.
+        try
+        {
+            _ = new NBitcoin.BitcoinSecret(ImportWifInput.Trim(), PalladiumNetworks.For(Net));
+        }
+        catch
+        {
+            StatusMessage = Loc.Tr("msg.wif.invalid");
+            return;
+        }
+        SetupStep = StepScriptType;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardNextFromScriptType()
+    {
+        PasswordInput = ConfirmPasswordInput = "";
+        EncryptWallet = true;
+        SetupStep = StepPassword;
+        StatusMessage = "";
+    }
+
+    [RelayCommand]
+    private void WizardBack()
+    {
+        SetupStep = SetupStep switch
+        {
+            StepOpen => WalletList.Count > 1 ? StepChooseWallet : StepStart,
+            StepChooseWallet or StepShowSeed or StepWords or StepImportXkey or StepImportWif => StepStart,
+            StepConfirmSeed => StepShowSeed,
+            StepPassphrase => _wizardFlow == WizardFlowKind.Restore ? StepWords : StepConfirmSeed,
+            StepScriptType => _wizardFlow == WizardFlowKind.ImportWif ? StepImportWif : StepPassphrase,
+            StepPassword => _wizardFlow == WizardFlowKind.ImportXkey ? StepImportXkey : StepScriptType,
+            _ => StepStart,
+        };
+        if (SetupStep == StepStart)
+            RefreshSetupState();
+    }
+
+    [RelayCommand]
+    private void CreateOrRestore()
+    {
+        string? password;
+        if (EncryptWallet)
+        {
+            if (string.IsNullOrEmpty(PasswordInput))
+            {
+                StatusMessage = Loc.Tr("msg.password.required");
+                return;
+            }
+            if (PasswordInput != ConfirmPasswordInput)
+            {
+                StatusMessage = Loc.Tr("msg.password.mismatch");
+                return;
+            }
+            password = PasswordInput;
+        }
+        else
+        {
+            password = null;
+        }
+
+        try
+        {
+            WalletDocument doc;
+            IWalletAccount account;
+
+            switch (_wizardFlow)
+            {
+                case WizardFlowKind.ImportXkey:
+                {
+                    var input = ImportXkeyInput.Trim();
+                    if (Slip132.TryDecodePublic(input, Profile, out _, out _))
+                    {
+                        var (d, a) = WalletLoader.NewFromXpub(input, Profile, SelectedScriptKind);
+                        (doc, account) = (d, a);
+                    }
+                    else
+                    {
+                        var (d, a) = WalletLoader.NewFromXprv(input, Profile, SelectedScriptKind);
+                        (doc, account) = (d, a);
+                    }
+                    break;
+                }
+                case WizardFlowKind.ImportWif:
+                {
+                    var wifLines = ImportWifInput.Split('\n',
+                        StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+                    var (d, a) = WalletLoader.NewFromWif(wifLines, SelectedScriptKind, Profile);
+                    (doc, account) = (d, a);
+                    break;
+                }
+                default:
+                {
+                    var (d, a) = WalletLoader.NewFromMnemonic(
+                        MnemonicInput,
+                        string.IsNullOrEmpty(PassphraseInput) ? null : PassphraseInput,
+                        SelectedScriptKind,
+                        Profile);
+                    (doc, account) = (d, a);
+                    break;
+                }
+            }
+
+            var path = WalletPathFromName(WalletNameInput);
+            if (WalletStore.Exists(path))
+            {
+                StatusMessage = Loc.Tr("msg.wallet.exists");
+                return;
+            }
+            WalletStore.Save(doc, path, password);
+            var newLock = WalletLock.TryAcquire(path);
+            if (newLock is null) { StatusMessage = Loc.Tr("msg.wallet.locked"); return; }
+            OpenLoaded(doc, account, path, password, newLock);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Errore: {ex.Message}";
+        }
+    }
+
+    /// <summary>
+    /// Builds the file path from the name entered by the user.
+    /// If the name is empty, generates an automatic name (default, wallet-2, …).
+    /// Removes characters that are invalid for the filesystem.
+    /// </summary>
+    private string WalletPathFromName(string name)
+    {
+        var clean = string.IsNullOrWhiteSpace(name)
+            ? ""
+            : string.Concat(name.Trim()
+                .Select(c => Path.GetInvalidFileNameChars().Contains(c) ? '_' : c))
+              .Trim('.');
+
+        if (string.IsNullOrEmpty(clean))
+        {
+            // No name provided → auto-generated name
+            var def = AppPaths.DefaultWalletPath(Net);
+            for (var n = 2; WalletStore.Exists(def); n++)
+                def = Path.Combine(AppPaths.WalletsDir(Net), $"wallet-{n}.wallet.json");
+            return def;
+        }
+
+        return Path.Combine(AppPaths.WalletsDir(Net), $"{clean}.wallet.json");
+    }
+
+    [RelayCommand]
+    private void OpenExisting()
+    {
+        var path = _pendingOpenPath ?? AppPaths.DefaultWalletPath(Net);
+        var password = string.IsNullOrEmpty(PasswordInput) ? null : PasswordInput;
+
+        var newLock = WalletLock.TryAcquire(path);
+        if (newLock is null) { StatusMessage = Loc.Tr("msg.wallet.locked"); return; }
+
+        try
+        {
+            var doc = WalletStore.Load(path, password);
+            _pendingOpenPath = null;
+            OpenLoaded(doc, WalletLoader.ToAccount(doc), path, password, newLock);
+        }
+        catch (WrongPasswordException)
+        {
+            newLock.Dispose();
+            StatusMessage = Loc.Tr("msg.wrongpassword");
+        }
+        catch (UnauthorizedAccessException)
+        {
+            newLock.Dispose();
+            StatusMessage = Loc.Tr("msg.wallet.noaccess");
+        }
+        catch (Exception ex)
+        {
+            newLock.Dispose();
+            StatusMessage = $"Errore: {ex.Message}";
+        }
+    }
+
+    [RelayCommand]
+    private void NewWallet()
+    {
+        if (IsWalletOpen)
+            CloseWallet();
+        _pendingOpenPath = null;
+        StatusMessage = "";
+    }
+
+    private void OpenLoaded(
+        WalletDocument doc, IWalletAccount account, string path, string? password, WalletLock walletLock)
+    {
+        _walletLock?.Dispose();
+        _walletLock = walletLock;
+
+        _doc = doc;
+        _account = account;
+        _walletPath = path;
+        _password = password;
+        MnemonicInput = ConfirmMnemonicInput = PassphraseInput = PasswordInput = ConfirmPasswordInput = WalletNameInput = "";
+        ImportXkeyInput = ImportWifInput = ImportXkeyDetectedKind = "";
+        SetupStep = StepStart;
+
+        var walletKindTag = account switch
+        {
+            ImportedKeyAccount => " · imported",
+            { IsWatchOnly: true } => " · watch-only",
+            _ => ""
+        };
+        var pathTag = !string.IsNullOrEmpty(doc.AccountPath) ? $" · m/{doc.AccountPath}" : "";
+        NetworkInfo = $"{doc.Network} · {doc.ScriptKind}{pathTag}{walletKindTag}";
+        LoadContacts();
+        ApplyCache(doc.Cache);
+        IsWalletOpen = true;
+        StatusMessage = Loc.Tr("msg.opened");
+        _autoReconnect = true;  // keepalive retries the connection even if the first attempt fails
+        _syncFailed = true;     // force the first automatic sync
+        _ = ConnectAndSync();
+    }
+}

src/App/ViewModels/MineColorConverter.cs

@@ -7,8 +7,8 @@ using Avalonia.Media;
 namespace PalladiumWallet.App.ViewModels;
 
 /// <summary>
-/// bool → pennello: gli indirizzi del wallet (input/output "nostri") sono
-/// evidenziati in verde, gli altri usano il colore di testo predefinito.
+/// bool → brush: the wallet's own addresses ("our" inputs/outputs) are
+/// highlighted in green, the others use the default text color.
 /// </summary>
 public sealed class MineColorConverter : IValueConverter
 {

src/App/ViewModels/TransactionDetailsViewModel.cs

@@ -7,13 +7,13 @@ using PalladiumWallet.Core.Wallet;
 
 namespace PalladiumWallet.App.ViewModels;
 
-/// <summary>Riga input/output per le tabelle della finestra di dettaglio.</summary>
+/// <summary>Input/output row for the transaction detail tables.</summary>
 public sealed record TxIoRow(string Position, string Address, string Amount, bool IsMine);
 
 /// <summary>
-/// ViewModel della finestra di dettaglio transazione: prende un
-/// <see cref="TransactionDetails"/> (assemblato dal server) e ne ricava tutte
-/// le stringhe già formattate e localizzate per la vista. È di sola lettura.
+/// ViewModel for the transaction detail view: takes a
+/// <see cref="TransactionDetails"/> (assembled from server data) and produces
+/// all strings already formatted and localised for the view. Read-only.
 /// </summary>
 public sealed class TransactionDetailsViewModel
 {
@@ -27,6 +27,7 @@ public sealed class TransactionDetailsViewModel
         _unit = unit;
 
         Txid = d.Txid;
+        IsCoinbase = d.IsCoinbase;
         StatusText = BuildStatus(d, loc);
         DateText = d.BlockTime is { } t
             ? t.ToLocalTime().ToString("dd/MM/yyyy HH:mm")
@@ -34,11 +35,14 @@ public sealed class TransactionDetailsViewModel
 
         var counterparties = d.CounterpartyAddresses;
         CounterpartyHeader = d.IsIncoming ? loc["tx.from"] : loc["tx.to"];
-        CounterpartyText = counterparties.Count > 0
-            ? string.Join(Environment.NewLine, counterparties)
-            : "—";
+        // Coinbase has no sender: coins are newly generated by mining.
+        CounterpartyText = d.IsCoinbase
+            ? loc["tx.coinbase.newcoins"]
+            : counterparties.Count > 0
+                ? string.Join(Environment.NewLine, counterparties)
+                : "—";
 
-        // Debito (uscita verso terzi) o Credito (entrata netta sui nostri output).
+        // Debit (outflow to third parties) or Credit (net inflow on our outputs).
         AmountHeader = d.IsIncoming ? loc["tx.credit"] : loc["tx.debit"];
         AmountText = d.IsIncoming
             ? Signed(d.ReceivedSats)
@@ -58,11 +62,9 @@ public sealed class TransactionDetailsViewModel
         VersionText = d.Version.ToString();
         LockTimeText = d.LockTime.ToString();
         RbfText = loc[d.RbfSignaled ? "tx.yes" : "tx.no"];
-        VerifiedText = d.Verified ? "✓ SPV" : "—";
-
         Inputs = new ObservableCollection<TxIoRow>(d.Inputs.Select((i, n) => new TxIoRow(
-            i.IsCoinbase ? "coinbase" : $"{Shorten(i.PrevTxid)}:{i.PrevIndex}",
-            i.Address ?? "—",
+            i.IsCoinbase ? loc["tx.coinbase"] : $"{i.PrevTxid}:{i.PrevIndex}",
+            i.IsCoinbase ? loc["tx.coinbase.newcoins"] : i.Address ?? "—",
             i.AmountSats is { } a ? CoinAmount.FormatIn(a, unit) : "—",
             i.IsMine)));
 
@@ -74,6 +76,7 @@ public sealed class TransactionDetailsViewModel
     }
 
     public string Txid { get; }
+    public bool IsCoinbase { get; }
     public string StatusText { get; }
     public string DateText { get; }
     public string CounterpartyHeader { get; }
@@ -88,7 +91,6 @@ public sealed class TransactionDetailsViewModel
     public string VersionText { get; }
     public string LockTimeText { get; }
     public string RbfText { get; }
-    public string VerifiedText { get; }
     public ObservableCollection<TxIoRow> Inputs { get; }
     public ObservableCollection<TxIoRow> Outputs { get; }
 
@@ -106,7 +108,4 @@ public sealed class TransactionDetailsViewModel
     }
 
     private string Abs(long sats) => CoinAmount.FormatIn(Math.Abs(sats), _unit);
-
-    private static string Shorten(string txid) =>
-        txid.Length > 16 ? $"{txid[..8]}…{txid[^4..]}" : txid;
 }

src/App/Views/MainView.axaml.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Input.Platform;
+using Avalonia.Interactivity;
+using Avalonia.Platform.Storage;
+using Avalonia.VisualTree;
+using PalladiumWallet.App.ViewModels;
+
+namespace PalladiumWallet.App.Views;
+
+/// <summary>
+/// App root view, shared between desktop (hosted in <see cref="MainWindow"/>)
+/// and mobile (single-view root). All overlays are in-app so no separate windows
+/// are needed. Top-level APIs (file picker, clipboard) are reached via
+/// <see cref="TopLevel.GetTopLevel"/> because a UserControl does not expose them.
+/// </summary>
+public partial class MainView : UserControl
+{
+    public MainView()
+    {
+        InitializeComponent();
+    }
+
+    private void OnHistoryRowDoubleTapped(object? sender, TappedEventArgs e)
+    {
+        if (sender is not ListBox lb || DataContext is not MainWindowViewModel vm) return;
+        if (lb.SelectedItem is not HistoryRow row) return;
+
+        // In-app overlay: appears immediately with a spinner; data arrives from
+        // the server in the background. No top-level window (slow to open/close).
+        _ = vm.ShowTransactionDetailsAsync(row.Txid);
+    }
+
+    private void OnTxDetailsOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.CloseTransactionDetailsCommand.Execute(null);
+    }
+
+    private void OnAddressListTapped(object? sender, TappedEventArgs e)
+    {
+        if (DataContext is not MainWindowViewModel vm || vm.SelectedAddressRow is not { } row)
+            return;
+        vm.ShowAddressInfo(row);
+    }
+
+    private void OnAddressListPointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        if (!e.GetCurrentPoint(null).Properties.IsRightButtonPressed) return;
+        if (sender is not ListBox lb || DataContext is not MainWindowViewModel vm) return;
+
+        var item = (e.Source as Visual)?.FindAncestorOfType<ListBoxItem>();
+        if (item is not { DataContext: AddressRow row }) return;
+
+        lb.SelectedItem = row;
+        vm.ShowAddressInfo(row);
+    }
+
+    // Close the address-detail overlay: click on the dark backdrop
+    // (backdrop only, not the card itself) or press Esc.
+    private void OnAddressOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.AddressInfo = null;
+    }
+
+    private void OnServerOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.IsServerSettingsOpen = false;
+    }
+
+    private async void OnChooseDataFolderClick(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is not MainWindowViewModel vm) return;
+        if (TopLevel.GetTopLevel(this)?.StorageProvider is not { } storage) return;
+
+        var folders = await storage.OpenFolderPickerAsync(new FolderPickerOpenOptions
+        {
+            Title = "Cartella dati Palladium Wallet",
+            AllowMultiple = false,
+        });
+
+        if (folders.FirstOrDefault()?.TryGetLocalPath() is { } path)
+            vm.ApplyDataLocation(path);
+    }
+
+    private async void OnCopyReceiveAddressClick(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is not MainWindowViewModel vm || string.IsNullOrEmpty(vm.ReceiveAddress))
+            return;
+        if (TopLevel.GetTopLevel(this)?.Clipboard is { } clipboard)
+        {
+            await clipboard.SetTextAsync(vm.ReceiveAddress);
+            vm.NotifyAddressCopied();
+        }
+    }
+
+    private void OnConnectionStatusTapped(object? sender, TappedEventArgs e)
+    {
+        if (DataContext is MainWindowViewModel vm)
+            vm.IsServerSettingsOpen = true;
+    }
+
+    private void OnWalletInfoOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.CloseWalletInfoCommand.Execute(null);
+    }
+
+    private void OnSettingsOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.IsSettingsOpen = false;
+    }
+
+    private void OnHelpOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.IsHelpOpen = false;
+    }
+
+    private void OnUpdateAvailableOverlayBackdropTapped(object? sender, TappedEventArgs e)
+    {
+        if (!ReferenceEquals(e.Source, sender)) return;
+        if (DataContext is MainWindowViewModel vm)
+            vm.IsUpdateAvailableOpen = false;
+    }
+
+    private async void OnOpenBugReportClick(object? sender, RoutedEventArgs e)
+    {
+        const string issueUrl = "https://github.com/davide3011/PalladiumWallet/issues/new?template=bug_report.yml";
+        var launcher = TopLevel.GetTopLevel(this)?.Launcher;
+        if (launcher is not null)
+            await launcher.LaunchUriAsync(new Uri(issueUrl));
+    }
+
+    private async void OnOpenReleasePageClick(object? sender, RoutedEventArgs e)
+    {
+        if (DataContext is not MainWindowViewModel vm || string.IsNullOrEmpty(vm.UpdateReleaseUrl)) return;
+        var launcher = TopLevel.GetTopLevel(this)?.Launcher;
+        if (launcher is not null)
+            await launcher.LaunchUriAsync(new Uri(vm.UpdateReleaseUrl));
+        vm.IsUpdateAvailableOpen = false;
+    }
+
+    // Esc (desktop) or Back (Android) closes the topmost open overlay.
+    protected override void OnKeyDown(KeyEventArgs e)
+    {
+        if ((e.Key == Key.Escape || e.Key == Key.Back) && DataContext is MainWindowViewModel vm)
+        {
+            if (vm.IsTxDetailsOpen) { vm.CloseTransactionDetailsCommand.Execute(null); e.Handled = true; return; }
+            if (vm.IsPrivKeyPromptOpen) { vm.CancelPrivKeyPromptCommand.Execute(null); e.Handled = true; return; }
+            if (vm.AddressInfo is not null) { vm.CloseAddressInfoCommand.Execute(null); e.Handled = true; return; }
+            if (vm.IsServerSettingsOpen) { vm.IsServerSettingsOpen = false; e.Handled = true; return; }
+            if (vm.IsWalletInfoOpen) { vm.CloseWalletInfoCommand.Execute(null); e.Handled = true; return; }
+            if (vm.IsSettingsOpen) { vm.IsSettingsOpen = false; e.Handled = true; return; }
+            if (vm.IsHelpOpen) { vm.IsHelpOpen = false; e.Handled = true; return; }
+            if (vm.IsUpdateAvailableOpen) { vm.IsUpdateAvailableOpen = false; e.Handled = true; return; }
+        }
+        base.OnKeyDown(e);
+    }
+}

src/App/Views/MainWindow.axaml

@@ -1,748 +1,22 @@
 <Window xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:vm="using:PalladiumWallet.App.ViewModels"
-        xmlns:net="using:PalladiumWallet.Core.Net"
+        xmlns:views="using:PalladiumWallet.App.Views"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        mc:Ignorable="d" d:DesignWidth="900" d:DesignHeight="620"
+        mc:Ignorable="d" d:DesignWidth="1020" d:DesignHeight="680"
         x:Class="PalladiumWallet.App.Views.MainWindow"
         x:DataType="vm:MainWindowViewModel"
         Icon="/Assets/logo.ico"
-        Width="900" Height="620"
+        Width="1020" Height="680"
+        MinWidth="1020" MinHeight="680"
+        MaxWidth="1020" MaxHeight="680"
+        CanResize="False"
         Title="{Binding WindowTitle}">
 
     <Design.DataContext>
         <vm:MainWindowViewModel/>
     </Design.DataContext>
 
-    <Grid RowDefinitions="Auto,*,Auto">
-
-        <!-- ============ MENU (stile Electrum) ============ -->
-        <Menu Grid.Row="0">
-            <MenuItem Header="{Binding Loc[menu.file]}">
-                <MenuItem Header="{Binding Loc[menu.file.new]}" Command="{Binding NewWalletCommand}"/>
-                <MenuItem Header="{Binding Loc[menu.file.open]}" Click="OnOpenWalletFileClick"/>
-                <Separator/>
-                <MenuItem Header="{Binding Loc[menu.file.close]}" Command="{Binding CloseWalletCommand}"
-                          IsEnabled="{Binding IsWalletOpen}"/>
-            </MenuItem>
-            <MenuItem Header="{Binding Loc[menu.settings]}"
-                      Command="{Binding OpenSettingsCommand}"/>
-            <MenuItem Header="{Binding Loc[menu.help]}"
-                      Command="{Binding OpenHelpCommand}"/>
-        </Menu>
-
-        <!-- ============ WIZARD DI SETUP (§15): un passo alla volta ============ -->
-        <ScrollViewer Grid.Row="1" IsVisible="{Binding IsSetupVisible}">
-            <StackPanel MaxWidth="560" Margin="24,40" Spacing="18"
-                        HorizontalAlignment="Center">
-                <TextBlock Text="Palladium Wallet" FontSize="28" FontWeight="Bold"
-                           HorizontalAlignment="Center"/>
-
-                <!-- Passo 0 (primo avvio): dove salvare i dati -->
-                <StackPanel IsVisible="{Binding IsStepDataLocation}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.data.title]}" FontSize="18" FontWeight="Bold"/>
-                    <TextBlock Text="{Binding Loc[wiz.data.info]}" TextWrapping="Wrap" Foreground="Gray"/>
-                    <StackPanel Spacing="4">
-                        <TextBlock Text="{Binding Loc[wiz.data.default]}" FontSize="11" Foreground="Gray"/>
-                        <SelectableTextBlock Text="{Binding DefaultDataPath}"
-                                             FontFamily="monospace" FontSize="13" TextWrapping="Wrap"/>
-                    </StackPanel>
-                    <Button Content="{Binding Loc[wiz.data.usedefault]}" FontSize="16" Classes="accent"
-                            HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
-                            Command="{Binding UseDefaultDataLocationCommand}"/>
-                    <Button Content="{Binding Loc[wiz.data.choose]}" FontSize="16"
-                            HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
-                            Click="OnChooseDataFolderClick"/>
-                </StackPanel>
-
-                <!-- Passo 1: scelta iniziale -->
-                <StackPanel IsVisible="{Binding IsStepStart}" Spacing="12">
-                    <StackPanel Orientation="Horizontal" Spacing="10" HorizontalAlignment="Center">
-                        <TextBlock Text="{Binding Loc[wiz.net]}" VerticalAlignment="Center"/>
-                        <ComboBox ItemsSource="{Binding Networks}"
-                                  SelectedItem="{Binding SelectedNetwork}" MinWidth="140"/>
-                    </StackPanel>
-                    <Button Content="{Binding Loc[wiz.open.btn]}" FontSize="16"
-                            HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
-                            IsVisible="{Binding WalletFileExists}"
-                            Command="{Binding WizardStartOpenCommand}"/>
-                    <Button Content="{Binding Loc[wiz.new.btn]}" FontSize="16"
-                            HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
-                            Command="{Binding WizardStartNewCommand}"/>
-                    <Button Content="{Binding Loc[wiz.restore.btn]}" FontSize="16"
-                            HorizontalAlignment="Stretch" HorizontalContentAlignment="Center"
-                            Command="{Binding WizardStartRestoreCommand}"/>
-                </StackPanel>
-
-                <!-- Passo: scelta del wallet (più file presenti) -->
-                <StackPanel IsVisible="{Binding IsStepChooseWallet}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.choose.title]}" FontSize="18" FontWeight="Bold"/>
-                    <ItemsControl ItemsSource="{Binding WalletList}">
-                        <ItemsControl.ItemTemplate>
-                            <DataTemplate x:DataType="vm:WalletFileEntry">
-                                <Button Content="{Binding Name}" FontFamily="monospace"
-                                        HorizontalAlignment="Stretch" HorizontalContentAlignment="Left"
-                                        Margin="0,0,0,6"
-                                        Command="{Binding $parent[ItemsControl].((vm:MainWindowViewModel)DataContext).ChooseWalletCommand}"
-                                        CommandParameter="{Binding}"/>
-                            </DataTemplate>
-                        </ItemsControl.ItemTemplate>
-                    </ItemsControl>
-                    <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                </StackPanel>
-
-                <!-- Passo: password del wallet esistente -->
-                <StackPanel IsVisible="{Binding IsStepOpen}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.open.title]}" FontSize="18" FontWeight="Bold"/>
-                    <TextBox PlaceholderText="{Binding Loc[wiz.open.placeholder]}"
-                             PasswordChar="●" Text="{Binding PasswordInput}"/>
-                    <StackPanel Orientation="Horizontal" Spacing="10">
-                        <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                        <Button Content="{Binding Loc[wiz.open.ok]}" Classes="accent"
-                                Command="{Binding OpenExistingCommand}"/>
-                    </StackPanel>
-                </StackPanel>
-
-                <!-- Passo: mostra il nuovo seed -->
-                <StackPanel IsVisible="{Binding IsStepShowSeed}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.seed.title]}" FontSize="18" FontWeight="Bold"/>
-                    <Border BorderBrush="{DynamicResource SystemAccentColor}" BorderThickness="1"
-                            CornerRadius="6" Padding="14">
-                        <SelectableTextBlock Text="{Binding MnemonicInput}"
-                                             FontFamily="monospace" FontSize="16" TextWrapping="Wrap"/>
-                    </Border>
-                    <TextBlock Foreground="Orange" TextWrapping="Wrap"
-                               Text="{Binding Loc[wiz.seed.warning]}"/>
-                    <StackPanel Orientation="Horizontal" Spacing="10">
-                        <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                        <Button Content="{Binding Loc[wiz.seed.next]}" Classes="accent"
-                                Command="{Binding WizardNextFromShowSeedCommand}"/>
-                    </StackPanel>
-                </StackPanel>
-
-                <!-- Passo: conferma del seed -->
-                <StackPanel IsVisible="{Binding IsStepConfirmSeed}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.confirm.title]}" FontSize="18" FontWeight="Bold"/>
-                    <TextBox PlaceholderText="{Binding Loc[wiz.confirm.placeholder]}"
-                             AcceptsReturn="False" Text="{Binding ConfirmMnemonicInput}"/>
-                    <StackPanel Orientation="Horizontal" Spacing="10">
-                        <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                        <Button Content="{Binding Loc[wiz.next]}" Classes="accent"
-                                Command="{Binding WizardNextFromConfirmSeedCommand}"/>
-                    </StackPanel>
-                </StackPanel>
-
-                <!-- Passo: inserimento seed (ripristino) -->
-                <StackPanel IsVisible="{Binding IsStepWords}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.words.title]}" FontSize="18" FontWeight="Bold"/>
-                    <TextBox PlaceholderText="{Binding Loc[wiz.words.placeholder]}"
-                             AcceptsReturn="False" Text="{Binding MnemonicInput}"/>
-                    <StackPanel Orientation="Horizontal" Spacing="10">
-                        <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                        <Button Content="{Binding Loc[wiz.next]}" Classes="accent"
-                                Command="{Binding WizardNextFromWordsCommand}"/>
-                    </StackPanel>
-                </StackPanel>
-
-                <!-- Passo: passphrase opzionale -->
-                <StackPanel IsVisible="{Binding IsStepPassphrase}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.passphrase.title]}" FontSize="18" FontWeight="Bold"/>
-                    <TextBox PlaceholderText="{Binding Loc[wiz.passphrase.placeholder]}"
-                             Text="{Binding PassphraseInput}"/>
-                    <StackPanel Orientation="Horizontal" Spacing="10">
-                        <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                        <Button Content="{Binding Loc[wiz.next]}" Classes="accent"
-                                Command="{Binding WizardNextFromPassphraseCommand}"/>
-                    </StackPanel>
-                </StackPanel>
-
-                <!-- Passo finale: password del file (cifratura, stile Electrum) -->
-                <StackPanel IsVisible="{Binding IsStepPassword}" Spacing="12">
-                    <TextBlock Text="{Binding Loc[wiz.password.title]}" FontSize="18" FontWeight="Bold"/>
-                    <TextBox PlaceholderText="{Binding Loc[wiz.password.placeholder]}"
-                             PasswordChar="●" Text="{Binding PasswordInput}"/>
-                    <TextBox PlaceholderText="{Binding Loc[wiz.password.confirm]}"
-                             PasswordChar="●" Text="{Binding ConfirmPasswordInput}"/>
-                    <CheckBox Content="{Binding Loc[wiz.password.encrypt]}"
-                              IsChecked="{Binding EncryptWallet}"/>
-                    <TextBlock Text="{Binding Loc[wiz.password.encrypt.hint]}"
-                               Foreground="Gray" FontSize="12" TextWrapping="Wrap"
-                               IsVisible="{Binding !EncryptWallet}"/>
-                    <StackPanel Orientation="Horizontal" Spacing="10">
-                        <Button Content="{Binding Loc[wiz.back]}" Command="{Binding WizardBackCommand}"/>
-                        <Button Content="{Binding Loc[wiz.password.create]}" Classes="accent"
-                                Command="{Binding CreateOrRestoreCommand}"/>
-                    </StackPanel>
-                </StackPanel>
-            </StackPanel>
-        </ScrollViewer>
-
-        <!-- ============ PANNELLO WALLET ============ -->
-        <Grid Grid.Row="1" RowDefinitions="Auto,*" IsVisible="{Binding IsWalletOpen}" Margin="16">
-
-            <!-- Testata: saldo + rete. Connetti/sincronizza è automatico; chiudi
-                 wallet è in File. Lo stato connessione è nella barra in basso. -->
-            <StackPanel Grid.Row="0" Spacing="2" Margin="0,0,0,12">
-                <TextBlock Text="{Binding BalanceText}" FontSize="30" FontWeight="Bold"/>
-                <TextBlock Text="{Binding UnconfirmedText}" Foreground="Orange"/>
-                <TextBlock Text="{Binding NetworkInfo}" FontSize="12" Foreground="Gray"/>
-            </StackPanel>
-
-            <!-- Tab: Storico / Invia / Ricevi / Indirizzi / Contatti -->
-            <TabControl Grid.Row="1">
-
-                <!-- 1. Storico -->
-                <TabItem Header="{Binding Loc[tab.history]}">
-                    <Grid RowDefinitions="Auto,*" Margin="4">
-                        <TextBlock Grid.Row="0" Text="{Binding Loc[history.hint]}"
-                                   Foreground="Gray" FontSize="11" Margin="6,2"/>
-                        <ListBox Grid.Row="1" ItemsSource="{Binding History}"
-                                 DoubleTapped="OnHistoryRowDoubleTapped">
-                            <ListBox.ItemTemplate>
-                                <DataTemplate x:DataType="vm:HistoryRow">
-                                    <Grid ColumnDefinitions="90,160,*,70" Cursor="Hand">
-                                        <TextBlock Grid.Column="0" Text="{Binding Conferma}" Foreground="Gray"/>
-                                        <TextBlock Grid.Column="1" Text="{Binding Importo}" FontFamily="monospace"/>
-                                        <TextBlock Grid.Column="2" Text="{Binding Txid}"
-                                                   FontFamily="monospace" FontSize="12"
-                                                   TextTrimming="CharacterEllipsis"/>
-                                        <TextBlock Grid.Column="3" Text="{Binding Verificata}" Foreground="Green"/>
-                                    </Grid>
-                                </DataTemplate>
-                            </ListBox.ItemTemplate>
-                        </ListBox>
-                    </Grid>
-                </TabItem>
-
-                <!-- 2. Invia -->
-                <TabItem Header="{Binding Loc[tab.send]}">
-                    <StackPanel Spacing="10" Margin="8" MaxWidth="640" HorizontalAlignment="Left">
-                        <!-- Contatto rapido -->
-                        <StackPanel Orientation="Horizontal" Spacing="8">
-                            <TextBlock Text="{Binding Loc[send.from.contact]}" VerticalAlignment="Center"/>
-                            <ComboBox ItemsSource="{Binding Contacts}"
-                                      SelectedItem="{Binding SendToContact}"
-                                      PlaceholderText="{Binding Loc[send.contact.hint]}"
-                                      MinWidth="220">
-                                <ComboBox.ItemTemplate>
-                                    <DataTemplate x:DataType="vm:ContactEntry">
-                                        <TextBlock Text="{Binding Name}"/>
-                                    </DataTemplate>
-                                </ComboBox.ItemTemplate>
-                            </ComboBox>
-                        </StackPanel>
-                        <TextBox PlaceholderText="{Binding Loc[send.to]}" Text="{Binding SendTo}"
-                                 FontFamily="monospace"/>
-                        <Grid ColumnDefinitions="*,Auto,Auto,Auto">
-                            <TextBox Grid.Column="0" PlaceholderText="{Binding Loc[send.amount]}"
-                                     Text="{Binding SendAmount}" IsEnabled="{Binding !SendAll}"/>
-                            <TextBlock Grid.Column="1" Text="{Binding UnitLabel}"
-                                       VerticalAlignment="Center" Margin="6,0" Foreground="Gray"/>
-                            <CheckBox Grid.Column="2" Content="{Binding Loc[send.all]}" Margin="10,0"
-                                      IsChecked="{Binding SendAll}"/>
-                            <StackPanel Grid.Column="3" Orientation="Horizontal" Spacing="6">
-                                <TextBlock Text="{Binding Loc[send.feerate]}" VerticalAlignment="Center"/>
-                                <TextBox Text="{Binding SendFeeRate}" MinWidth="60"/>
-                            </StackPanel>
-                        </Grid>
-                        <StackPanel Orientation="Horizontal" Spacing="10">
-                            <Button Content="{Binding Loc[send.prepare]}" Command="{Binding PrepareSendCommand}"/>
-                            <Button Content="{Binding Loc[send.confirm]}" Classes="accent"
-                                    Command="{Binding ConfirmSendCommand}"
-                                    IsEnabled="{Binding HasPendingSend}"/>
-                        </StackPanel>
-                        <SelectableTextBlock Text="{Binding SendPreview}" TextWrapping="Wrap"
-                                             FontSize="13"/>
-                    </StackPanel>
-                </TabItem>
-
-                <!-- 3. Ricevi -->
-                <TabItem Header="{Binding Loc[tab.receive]}">
-                    <StackPanel Spacing="10" Margin="8">
-                        <TextBlock Text="{Binding Loc[receive.next]}"/>
-                        <StackPanel Orientation="Horizontal" Spacing="8">
-                            <SelectableTextBlock Text="{Binding ReceiveAddress}"
-                                                 FontFamily="monospace" FontSize="16"
-                                                 VerticalAlignment="Center"/>
-                            <Button Content="{Binding Loc[receive.copy]}"
-                                    Click="OnCopyReceiveAddressClick"
-                                    VerticalAlignment="Center"/>
-                        </StackPanel>
-                        <Border Background="White" Padding="12" CornerRadius="6"
-                                HorizontalAlignment="Left"
-                                IsVisible="{Binding ReceiveQr, Converter={x:Static ObjectConverters.IsNotNull}}">
-                            <Image Source="{Binding ReceiveQr}" Width="220" Height="220"
-                                   RenderOptions.BitmapInterpolationMode="None"/>
-                        </Border>
-                        <TextBlock Text="{Binding Loc[receive.hint]}"
-                                   Foreground="Gray" FontSize="12" TextWrapping="Wrap"/>
-                    </StackPanel>
-                </TabItem>
-
-                <!-- 4. Indirizzi -->
-                <TabItem Header="{Binding Loc[tab.addresses]}">
-                    <Grid RowDefinitions="Auto,*" Margin="4">
-                        <Grid Grid.Row="0" ColumnDefinitions="90,60,*,140,60" Margin="12,4">
-                            <TextBlock Grid.Column="0" Text="{Binding Loc[addr.type]}" FontWeight="Bold"/>
-                            <TextBlock Grid.Column="1" Text="{Binding Loc[addr.index]}" FontWeight="Bold"/>
-                            <TextBlock Grid.Column="2" Text="{Binding Loc[addr.address]}" FontWeight="Bold"/>
-                            <TextBlock Grid.Column="3" Text="{Binding Loc[addr.balance]}" FontWeight="Bold"/>
-                            <TextBlock Grid.Column="4" Text="Tx" FontWeight="Bold"/>
-                        </Grid>
-                        <ListBox Grid.Row="1" ItemsSource="{Binding Addresses}"
-                                 SelectedItem="{Binding SelectedAddressRow}"
-                                 x:Name="AddressesListBox"
-                                 Tapped="OnAddressListTapped"
-                                 PointerPressed="OnAddressListPointerPressed">
-                            <ListBox.ItemTemplate>
-                                <DataTemplate x:DataType="vm:AddressRow">
-                                    <Grid ColumnDefinitions="90,60,*,140,60">
-                                        <TextBlock Grid.Column="0" Text="{Binding Tipo}" Foreground="Gray"/>
-                                        <TextBlock Grid.Column="1" Text="{Binding Indice}" Foreground="Gray"/>
-                                        <TextBlock Grid.Column="2" Text="{Binding Indirizzo}"
-                                                   FontFamily="monospace" FontSize="13"/>
-                                        <TextBlock Grid.Column="3" Text="{Binding Saldo}" FontFamily="monospace"/>
-                                        <TextBlock Grid.Column="4" Text="{Binding NumTx}" Foreground="Gray"/>
-                                    </Grid>
-                                </DataTemplate>
-                            </ListBox.ItemTemplate>
-                        </ListBox>
-                    </Grid>
-                </TabItem>
-
-                <!-- 5. Contatti -->
-                <TabItem Header="{Binding Loc[tab.contacts]}">
-                    <Grid RowDefinitions="Auto,*,Auto,Auto" Margin="4">
-                        <!-- Intestazioni colonne -->
-                        <Grid Grid.Row="0" ColumnDefinitions="180,*" Margin="12,4">
-                            <TextBlock Grid.Column="0" Text="{Binding Loc[contacts.name]}" FontWeight="Bold"/>
-                            <TextBlock Grid.Column="1" Text="{Binding Loc[contacts.address]}" FontWeight="Bold"/>
-                        </Grid>
-                        <!-- Lista contatti -->
-                        <ListBox Grid.Row="1" ItemsSource="{Binding Contacts}"
-                                 SelectedItem="{Binding SelectedContactInList}">
-                            <ListBox.ItemTemplate>
-                                <DataTemplate x:DataType="vm:ContactEntry">
-                                    <Grid ColumnDefinitions="180,*">
-                                        <TextBlock Grid.Column="0" Text="{Binding Name}"
-                                                   VerticalAlignment="Center"/>
-                                        <SelectableTextBlock Grid.Column="1" Text="{Binding Address}"
-                                                             FontFamily="monospace" FontSize="12"
-                                                             VerticalAlignment="Center"/>
-                                    </Grid>
-                                </DataTemplate>
-                            </ListBox.ItemTemplate>
-                        </ListBox>
-                        <!-- Pulsante rimuovi selezionato -->
-                        <Button Grid.Row="2" Content="{Binding Loc[contacts.remove]}"
-                                Command="{Binding RemoveSelectedContactCommand}"
-                                IsEnabled="{Binding SelectedContactInList, Converter={x:Static ObjectConverters.IsNotNull}}"
-                                Margin="0,6,0,0"/>
-                        <!-- Form aggiungi contatto -->
-                        <Grid Grid.Row="3" ColumnDefinitions="180,*,Auto" Margin="0,8,0,0">
-                            <TextBox Grid.Column="0" PlaceholderText="{Binding Loc[contacts.name.ph]}"
-                                     Text="{Binding NewContactName}" Margin="0,0,6,0"/>
-                            <TextBox Grid.Column="1" PlaceholderText="{Binding Loc[contacts.address.ph]}"
-                                     Text="{Binding NewContactAddress}" FontFamily="monospace"
-                                     Margin="0,0,6,0"/>
-                            <Button Grid.Column="2" Content="{Binding Loc[contacts.add]}"
-                                    Command="{Binding AddContactCommand}"/>
-                        </Grid>
-                    </Grid>
-                </TabItem>
-
-            </TabControl>
-        </Grid>
-
-        <!-- Barra di stato: messaggio a sinistra, stato connessione a destra.
-             Lo stato connessione è cliccabile e apre le impostazioni del server. -->
-        <Border Grid.Row="2" Background="{DynamicResource SystemControlBackgroundChromeMediumBrush}"
-                Padding="10,6">
-            <Grid ColumnDefinitions="*,Auto">
-                <TextBlock Grid.Column="0" Text="{Binding StatusMessage}" FontSize="12"
-                           TextWrapping="Wrap" VerticalAlignment="Center"/>
-                <StackPanel Grid.Column="1" Orientation="Horizontal" Spacing="6"
-                            Margin="12,0,0,0" VerticalAlignment="Center"
-                            Cursor="Hand" Background="Transparent"
-                            ToolTip.Tip="{Binding Loc[server.title]}"
-                            Tapped="OnConnectionStatusTapped">
-                    <Ellipse Width="10" Height="10" Fill="LimeGreen" VerticalAlignment="Center"
-                             IsVisible="{Binding IsConnected}"/>
-                    <Ellipse Width="10" Height="10" Fill="IndianRed" VerticalAlignment="Center"
-                             IsVisible="{Binding !IsConnected}"/>
-                    <TextBlock Text="{Binding ConnectionStatus}" FontSize="12"
-                               Foreground="{DynamicResource SystemAccentColor}"
-                               VerticalAlignment="Center"/>
-                </StackPanel>
-            </Grid>
-        </Border>
-
-        <!-- ============ OVERLAY DETTAGLIO INDIRIZZO ============ -->
-        <!-- Overlay in-app invece di una Window separata: apertura/chiusura
-             istantanee (niente create/destroy di una top-level window). -->
-        <Border Grid.Row="0" Grid.RowSpan="3"
-                Background="#99000000"
-                Tapped="OnAddressOverlayBackdropTapped"
-                IsVisible="{Binding AddressInfo, Converter={x:Static ObjectConverters.IsNotNull}}">
-            <Border Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
-                    BorderBrush="Gray" BorderThickness="1" CornerRadius="8"
-                    Width="560" Padding="0"
-                    HorizontalAlignment="Center" VerticalAlignment="Center"
-                    DataContext="{Binding AddressInfo}">
-                <StackPanel Margin="24" Spacing="16">
-                    <TextBlock Text="{Binding Loc[addr.info.title]}"
-                               FontSize="18" FontWeight="Bold"/>
-
-                    <!-- Indirizzo -->
-                    <StackPanel Spacing="4">
-                        <TextBlock Text="{Binding Loc[addr.address]}" FontSize="11" Foreground="Gray"/>
-                        <SelectableTextBlock Text="{Binding Address}"
-                                             FontFamily="monospace" FontSize="13"
-                                             TextWrapping="Wrap"/>
-                    </StackPanel>
-
-                    <!-- Derivation path -->
-                    <StackPanel Spacing="4">
-                        <TextBlock Text="{Binding Loc[addr.derivpath]}" FontSize="11" Foreground="Gray"/>
-                        <SelectableTextBlock Text="{Binding DerivPath}"
-                                             FontFamily="monospace" FontSize="13"/>
-                    </StackPanel>
-
-                    <!-- Chiave pubblica -->
-                    <StackPanel Spacing="4">
-                        <TextBlock Text="{Binding Loc[addr.pubkey]}" FontSize="11" Foreground="Gray"/>
-                        <SelectableTextBlock Text="{Binding PubKey}"
-                                             FontFamily="monospace" FontSize="12"
-                                             TextWrapping="Wrap"/>
-                    </StackPanel>
-
-                    <!-- Chiave privata (solo se disponibile) -->
-                    <StackPanel Spacing="4" IsVisible="{Binding HasPrivKey}">
-                        <TextBlock Text="{Binding Loc[addr.privkey]}" FontSize="11" Foreground="OrangeRed"/>
-                        <SelectableTextBlock Text="{Binding PrivKey}"
-                                             FontFamily="monospace" FontSize="12"
-                                             Foreground="OrangeRed"
-                                             TextWrapping="Wrap"/>
-                    </StackPanel>
-
-                    <Button Content="{Binding Loc[addr.close]}"
-                            HorizontalAlignment="Right"
-                            Command="{Binding $parent[Window].((vm:MainWindowViewModel)DataContext).CloseAddressInfoCommand}"/>
-                </StackPanel>
-            </Border>
-        </Border>
-
-        <!-- ============ OVERLAY DETTAGLIO TRANSAZIONE ============ -->
-        <!-- Overlay in-app (come indirizzo): appare subito con lo spinner, i dati
-             arrivano dal server in background; chiusura istantanea. -->
-        <Border Grid.Row="0" Grid.RowSpan="3"
-                Background="#99000000"
-                Tapped="OnTxDetailsOverlayBackdropTapped"
-                IsVisible="{Binding IsTxDetailsOpen}">
-            <Border Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
-                    BorderBrush="Gray" BorderThickness="1" CornerRadius="8"
-                    Width="640" MaxHeight="600" Padding="0"
-                    HorizontalAlignment="Center" VerticalAlignment="Center">
-                <Panel Margin="24">
-
-                    <!-- Caricamento -->
-                    <StackPanel IsVisible="{Binding IsTxDetailsLoading}"
-                                HorizontalAlignment="Center" VerticalAlignment="Center" Spacing="14">
-                        <ProgressBar IsIndeterminate="True" Width="220"/>
-                        <TextBlock Text="{Binding Loc[tx.loading]}" Foreground="Gray"
-                                   HorizontalAlignment="Center"/>
-                    </StackPanel>
-
-                    <!-- Contenuto (IsVisible sul contenitore esterno, così resta
-                         legato al VM principale; il DataContext interno è TxDetails) -->
-                    <Grid IsVisible="{Binding !IsTxDetailsLoading}">
-                    <DockPanel DataContext="{Binding TxDetails}">
-                        <TextBlock DockPanel.Dock="Top" Text="{Binding Loc[tx.title]}"
-                                   FontSize="18" FontWeight="Bold" Margin="0,0,0,12"/>
-
-                        <Button DockPanel.Dock="Bottom" Content="{Binding Loc[tx.close]}"
-                                HorizontalAlignment="Right" Margin="0,12,0,0"
-                                Command="{Binding $parent[Window].((vm:MainWindowViewModel)DataContext).CloseTransactionDetailsCommand}"/>
-
-                        <ScrollViewer>
-                            <StackPanel Spacing="14">
-
-                                <Grid ColumnDefinitions="170,*" RowSpacing="8">
-                                    <Grid.RowDefinitions>
-                                        <RowDefinition Height="Auto"/><RowDefinition Height="Auto"/>
-                                        <RowDefinition Height="Auto"/><RowDefinition Height="Auto"/>
-                                        <RowDefinition Height="Auto"/><RowDefinition Height="Auto"/>
-                                        <RowDefinition Height="Auto"/><RowDefinition Height="Auto"/>
-                                        <RowDefinition Height="Auto"/><RowDefinition Height="Auto"/>
-                                        <RowDefinition Height="Auto"/><RowDefinition Height="Auto"/>
-                                    </Grid.RowDefinitions>
-
-                                    <TextBlock Grid.Row="0" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.status]}"/>
-                                    <SelectableTextBlock Grid.Row="0" Grid.Column="1" FontSize="13" TextWrapping="Wrap" Text="{Binding StatusText}"/>
-
-                                    <TextBlock Grid.Row="1" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.date]}"/>
-                                    <SelectableTextBlock Grid.Row="1" Grid.Column="1" FontSize="13" Text="{Binding DateText}"/>
-
-                                    <TextBlock Grid.Row="2" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding CounterpartyHeader}"/>
-                                    <SelectableTextBlock Grid.Row="2" Grid.Column="1" FontSize="13" FontFamily="monospace" TextWrapping="Wrap" Text="{Binding CounterpartyText}"/>
-
-                                    <TextBlock Grid.Row="3" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding AmountHeader}"/>
-                                    <SelectableTextBlock Grid.Row="3" Grid.Column="1" FontSize="13" FontFamily="monospace" Text="{Binding AmountText}"/>
-
-                                    <TextBlock Grid.Row="4" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.fee]}"/>
-                                    <SelectableTextBlock Grid.Row="4" Grid.Column="1" FontSize="13" FontFamily="monospace" Text="{Binding FeeText}"/>
-
-                                    <TextBlock Grid.Row="5" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.feerate]}"/>
-                                    <SelectableTextBlock Grid.Row="5" Grid.Column="1" FontSize="13" FontFamily="monospace" Text="{Binding FeeRateText}"/>
-
-                                    <TextBlock Grid.Row="6" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.net]}"/>
-                                    <SelectableTextBlock Grid.Row="6" Grid.Column="1" FontSize="13" FontFamily="monospace" FontWeight="Bold" Text="{Binding NetText}"/>
-
-                                    <TextBlock Grid.Row="7" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.id]}"/>
-                                    <SelectableTextBlock Grid.Row="7" Grid.Column="1" FontSize="12" FontFamily="monospace" TextWrapping="Wrap" Text="{Binding Txid}"/>
-
-                                    <TextBlock Grid.Row="8" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.size.total]}"/>
-                                    <SelectableTextBlock Grid.Row="8" Grid.Column="1" FontSize="13" Text="{Binding TotalSizeText}"/>
-
-                                    <TextBlock Grid.Row="9" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.size.virtual]}"/>
-                                    <SelectableTextBlock Grid.Row="9" Grid.Column="1" FontSize="13" Text="{Binding VirtualSizeText}"/>
-
-                                    <TextBlock Grid.Row="10" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.rbf]}"/>
-                                    <SelectableTextBlock Grid.Row="10" Grid.Column="1" FontSize="13" Text="{Binding RbfText}"/>
-
-                                    <TextBlock Grid.Row="11" Grid.Column="0" Foreground="Gray" FontSize="12" Text="{Binding Loc[tx.verified]}"/>
-                                    <SelectableTextBlock Grid.Row="11" Grid.Column="1" FontSize="13" Foreground="Green" Text="{Binding VerifiedText}"/>
-                                </Grid>
-
-                                <TextBlock Text="{Binding Loc[tx.inputs]}" FontWeight="Bold" Margin="0,4,0,0"/>
-                                <ItemsControl ItemsSource="{Binding Inputs}">
-                                    <ItemsControl.ItemTemplate>
-                                        <DataTemplate x:DataType="vm:TxIoRow">
-                                            <Grid ColumnDefinitions="170,*,Auto" Margin="0,2">
-                                                <TextBlock Grid.Column="0" Text="{Binding Position}"
-                                                           FontFamily="monospace" FontSize="11" Foreground="Gray"/>
-                                                <TextBlock Grid.Column="1" Text="{Binding Address}"
-                                                           FontFamily="monospace" FontSize="11" TextTrimming="CharacterEllipsis"
-                                                           Foreground="{Binding IsMine, Converter={x:Static vm:MineColorConverter.Instance}}"/>
-                                                <TextBlock Grid.Column="2" Text="{Binding Amount}"
-                                                           FontFamily="monospace" FontSize="11" Margin="8,0,0,0"/>
-                                            </Grid>
-                                        </DataTemplate>
-                                    </ItemsControl.ItemTemplate>
-                                </ItemsControl>
-
-                                <TextBlock Text="{Binding Loc[tx.outputs]}" FontWeight="Bold" Margin="0,4,0,0"/>
-                                <ItemsControl ItemsSource="{Binding Outputs}">
-                                    <ItemsControl.ItemTemplate>
-                                        <DataTemplate x:DataType="vm:TxIoRow">
-                                            <Grid ColumnDefinitions="60,*,Auto" Margin="0,2">
-                                                <TextBlock Grid.Column="0" Text="{Binding Position}"
-                                                           FontFamily="monospace" FontSize="11" Foreground="Gray"/>
-                                                <TextBlock Grid.Column="1" Text="{Binding Address}"
-                                                           FontFamily="monospace" FontSize="11" TextTrimming="CharacterEllipsis"
-                                                           Foreground="{Binding IsMine, Converter={x:Static vm:MineColorConverter.Instance}}"/>
-                                                <TextBlock Grid.Column="2" Text="{Binding Amount}"
-                                                           FontFamily="monospace" FontSize="11" Margin="8,0,0,0"/>
-                                            </Grid>
-                                        </DataTemplate>
-                                    </ItemsControl.ItemTemplate>
-                                </ItemsControl>
-
-                            </StackPanel>
-                        </ScrollViewer>
-                    </DockPanel>
-                    </Grid>
-                </Panel>
-            </Border>
-        </Border>
-
-        <!-- ============ OVERLAY IMPOSTAZIONI SERVER ============ -->
-        <!-- Stesso pattern dell'overlay indirizzo: apertura/chiusura istantanee.
-             Accessibile da Impostazioni → Server. -->
-        <Border Grid.Row="0" Grid.RowSpan="3"
-                Background="#99000000"
-                Tapped="OnServerOverlayBackdropTapped"
-                IsVisible="{Binding IsServerSettingsOpen}">
-            <Border Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
-                    BorderBrush="Gray" BorderThickness="1" CornerRadius="8"
-                    Width="560" MaxHeight="540"
-                    HorizontalAlignment="Center" VerticalAlignment="Center">
-                <StackPanel Margin="24" Spacing="14">
-                    <TextBlock Text="{Binding Loc[server.title]}"
-                               FontSize="18" FontWeight="Bold"/>
-
-                    <!-- Host + porta separati -->
-                    <Grid ColumnDefinitions="*,Auto,Auto" RowDefinitions="Auto,Auto">
-                        <TextBlock Grid.Row="0" Grid.Column="0" Text="{Binding Loc[server.host]}"
-                                   FontSize="11" Foreground="Gray"/>
-                        <TextBlock Grid.Row="0" Grid.Column="1" Text="{Binding Loc[server.port]}"
-                                   FontSize="11" Foreground="Gray" Margin="10,0,0,0" Width="90"/>
-                        <TextBlock Grid.Row="0" Grid.Column="2" Text="TLS"
-                                   FontSize="11" Foreground="Gray" Margin="10,0,0,0"/>
-                        <TextBox Grid.Row="1" Grid.Column="0" Text="{Binding ServerHost}"
-                                 FontFamily="monospace" Margin="0,2,0,0"/>
-                        <TextBox Grid.Row="1" Grid.Column="1" Text="{Binding ServerPort}"
-                                 FontFamily="monospace" Width="90" Margin="10,2,0,0"/>
-                        <CheckBox Grid.Row="1" Grid.Column="2" IsChecked="{Binding UseSsl}"
-                                  Margin="10,2,0,0" VerticalAlignment="Center"/>
-                    </Grid>
-
-                    <!-- Azioni -->
-                    <StackPanel Orientation="Horizontal" Spacing="8">
-                        <Button Content="{Binding Loc[wallet.connect]}" Classes="accent"
-                                Command="{Binding ConnectAndSyncCommand}" IsEnabled="{Binding !IsSyncing}"/>
-                        <Button Content="{Binding Loc[wallet.discover]}"
-                                Command="{Binding DiscoverServersCommand}"/>
-                        <Button Content="{Binding Loc[wallet.resetcert]}"
-                                Command="{Binding ResetCertificatesCommand}"/>
-                    </StackPanel>
-
-                    <!-- Stato connessione -->
-                    <StackPanel Orientation="Horizontal" Spacing="6">
-                        <Ellipse Width="10" Height="10" Fill="LimeGreen" VerticalAlignment="Center"
-                                 IsVisible="{Binding IsConnected}"/>
-                        <Ellipse Width="10" Height="10" Fill="IndianRed" VerticalAlignment="Center"
-                                 IsVisible="{Binding !IsConnected}"/>
-                        <TextBlock Text="{Binding ConnectionStatus}" Foreground="Gray"
-                                   VerticalAlignment="Center"/>
-                    </StackPanel>
-
-                    <!-- Server conosciuti: clicca per riempire host/porta -->
-                    <TextBlock Text="{Binding Loc[server.known]}" FontSize="11" Foreground="Gray"/>
-                    <ListBox ItemsSource="{Binding KnownServers}"
-                             SelectedItem="{Binding SelectedKnownServer}"
-                             MaxHeight="200">
-                        <ListBox.Styles>
-                            <Style Selector="ListBox:empty">
-                                <Setter Property="Template">
-                                    <ControlTemplate>
-                                        <TextBlock Text="{Binding Loc[server.empty]}"
-                                                   Foreground="Gray" FontSize="12"
-                                                   TextWrapping="Wrap" Margin="8"/>
-                                    </ControlTemplate>
-                                </Setter>
-                            </Style>
-                        </ListBox.Styles>
-                        <ListBox.ItemTemplate>
-                            <DataTemplate x:DataType="net:KnownServer">
-                                <Grid ColumnDefinitions="*,Auto">
-                                    <TextBlock Grid.Column="0" Text="{Binding Host}"
-                                               FontFamily="monospace" FontSize="13"
-                                               VerticalAlignment="Center"/>
-                                    <TextBlock Grid.Column="1" FontSize="11" Foreground="Gray"
-                                               VerticalAlignment="Center">
-                                        <Run Text="tcp"/><Run Text="{Binding TcpPort}"/>
-                                        <Run Text=" / ssl"/><Run Text="{Binding SslPort}"/>
-                                    </TextBlock>
-                                </Grid>
-                            </DataTemplate>
-                        </ListBox.ItemTemplate>
-                    </ListBox>
-
-                    <Button Content="{Binding Loc[addr.close]}"
-                            HorizontalAlignment="Right"
-                            Command="{Binding CloseServerSettingsCommand}"/>
-                </StackPanel>
-            </Border>
-        </Border>
-
-        <!-- ============ OVERLAY IMPOSTAZIONI ============ -->
-        <!-- In-app invece dei sottomenu annidati: niente popup OS lenti su WSLg. -->
-        <Border Grid.Row="0" Grid.RowSpan="3"
-                Background="#99000000"
-                Tapped="OnSettingsOverlayBackdropTapped"
-                IsVisible="{Binding IsSettingsOpen}">
-            <Border Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
-                    BorderBrush="Gray" BorderThickness="1" CornerRadius="8"
-                    Width="460"
-                    HorizontalAlignment="Center" VerticalAlignment="Center">
-                <StackPanel Margin="24" Spacing="16">
-                    <TextBlock Text="{Binding Loc[settings.title]}"
-                               FontSize="18" FontWeight="Bold"/>
-
-                    <!-- Lingua -->
-                    <StackPanel Spacing="6">
-                        <TextBlock Text="{Binding Loc[settings.language]}" FontSize="11" Foreground="Gray"/>
-                        <WrapPanel>
-                            <RadioButton GroupName="lang" Content="Italiano" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsLangIt, Mode=OneWay}"
-                                         Command="{Binding SetLanguageCommand}" CommandParameter="it"/>
-                            <RadioButton GroupName="lang" Content="English" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsLangEn, Mode=OneWay}"
-                                         Command="{Binding SetLanguageCommand}" CommandParameter="en"/>
-                            <RadioButton GroupName="lang" Content="Español" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsLangEs, Mode=OneWay}"
-                                         Command="{Binding SetLanguageCommand}" CommandParameter="es"/>
-                            <RadioButton GroupName="lang" Content="Français" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsLangFr, Mode=OneWay}"
-                                         Command="{Binding SetLanguageCommand}" CommandParameter="fr"/>
-                            <RadioButton GroupName="lang" Content="Português" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsLangPt, Mode=OneWay}"
-                                         Command="{Binding SetLanguageCommand}" CommandParameter="pt"/>
-                            <RadioButton GroupName="lang" Content="Deutsch" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsLangDe, Mode=OneWay}"
-                                         Command="{Binding SetLanguageCommand}" CommandParameter="de"/>
-                        </WrapPanel>
-                    </StackPanel>
-
-                    <!-- Unità -->
-                    <StackPanel Spacing="6">
-                        <TextBlock Text="{Binding Loc[settings.unit]}" FontSize="11" Foreground="Gray"/>
-                        <WrapPanel>
-                            <RadioButton GroupName="unit" Content="PLM" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsUnitPlm, Mode=OneWay}"
-                                         Command="{Binding SetUnitCommand}" CommandParameter="PLM"/>
-                            <RadioButton GroupName="unit" Content="mPLM" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsUnitMilli, Mode=OneWay}"
-                                         Command="{Binding SetUnitCommand}" CommandParameter="mPLM"/>
-                            <RadioButton GroupName="unit" Content="µPLM" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsUnitMicro, Mode=OneWay}"
-                                         Command="{Binding SetUnitCommand}" CommandParameter="µPLM"/>
-                            <RadioButton GroupName="unit" Content="sat" Margin="0,0,14,4"
-                                         IsChecked="{Binding IsUnitSat, Mode=OneWay}"
-                                         Command="{Binding SetUnitCommand}" CommandParameter="sat"/>
-                        </WrapPanel>
-                    </StackPanel>
-
-                    <!-- Server di indicizzazione (configurabile anche prima di aprire un wallet) -->
-                    <Button Content="{Binding Loc[settings.server]}"
-                            HorizontalAlignment="Left"
-                            Command="{Binding OpenServerSettingsCommand}"/>
-
-                    <Button Content="{Binding Loc[addr.close]}"
-                            HorizontalAlignment="Right"
-                            Command="{Binding CloseSettingsCommand}"/>
-                </StackPanel>
-            </Border>
-        </Border>
-
-        <!-- ============ OVERLAY HELP / INFORMAZIONI ============ -->
-        <!-- Stesso pattern dell'overlay impostazioni: apertura/chiusura istantanee. -->
-        <Border Grid.Row="0" Grid.RowSpan="3"
-                Background="#99000000"
-                Tapped="OnHelpOverlayBackdropTapped"
-                IsVisible="{Binding IsHelpOpen}">
-            <Border Background="{DynamicResource SystemControlBackgroundChromeMediumLowBrush}"
-                    BorderBrush="Gray" BorderThickness="1" CornerRadius="8"
-                    Width="460"
-                    HorizontalAlignment="Center" VerticalAlignment="Center">
-                <StackPanel Margin="24" Spacing="16">
-                    <TextBlock Text="{Binding Loc[help.title]}"
-                               FontSize="18" FontWeight="Bold"/>
-
-                    <StackPanel Spacing="4">
-                        <TextBlock Text="Palladium Wallet" FontSize="16" FontWeight="Bold"/>
-                        <TextBlock Text="{Binding WindowTitle}" FontSize="12" Foreground="Gray"/>
-                    </StackPanel>
-
-                    <TextBlock Text="{Binding Loc[help.info]}" TextWrapping="Wrap"/>
-
-                    <Button Content="{Binding Loc[addr.close]}"
-                            HorizontalAlignment="Right"
-                            Command="{Binding CloseHelpCommand}"/>
-                </StackPanel>
-            </Border>
-        </Border>
-    </Grid>
+    <views:MainView/>
 </Window>

src/App/Views/MainWindow.axaml.cs

@@ -1,150 +1,12 @@
-using System.Linq;
-using System.Threading.Tasks;
-using Avalonia;
 using Avalonia.Controls;
-using Avalonia.Input;
-using Avalonia.Input.Platform;
-using Avalonia.Interactivity;
-using Avalonia.Platform.Storage;
-using Avalonia.VisualTree;
-using PalladiumWallet.App.ViewModels;
 
 namespace PalladiumWallet.App.Views;
 
+/// <summary>Finestra desktop: ospita <see cref="MainView"/> (la UI condivisa con mobile).</summary>
 public partial class MainWindow : Window
 {
     public MainWindow()
     {
         InitializeComponent();
     }
-
-    private async void OnOpenWalletFileClick(object? sender, RoutedEventArgs e)
-    {
-        if (DataContext is not MainWindowViewModel vm)
-            return;
-
-        var files = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
-        {
-            Title = "Apri file wallet",
-            AllowMultiple = false,
-            FileTypeFilter =
-            [
-                new FilePickerFileType("Wallet Palladium") { Patterns = ["*.wallet.json", "*.json"] },
-            ],
-        });
-
-        if (files.FirstOrDefault()?.TryGetLocalPath() is { } path)
-            vm.OpenFromPath(path);
-    }
-
-    private void OnHistoryRowDoubleTapped(object? sender, TappedEventArgs e)
-    {
-        if (sender is not ListBox lb || DataContext is not MainWindowViewModel vm) return;
-        if (lb.SelectedItem is not HistoryRow row) return;
-
-        // Overlay in-app: appare subito con lo spinner, i dati arrivano dal
-        // server in background. Niente top-level window (lenta da aprire/chiudere).
-        _ = vm.ShowTransactionDetailsAsync(row.Txid);
-    }
-
-    private void OnTxDetailsOverlayBackdropTapped(object? sender, TappedEventArgs e)
-    {
-        if (!ReferenceEquals(e.Source, sender)) return;
-        if (DataContext is MainWindowViewModel vm)
-            vm.CloseTransactionDetailsCommand.Execute(null);
-    }
-
-    private void OnAddressListTapped(object? sender, TappedEventArgs e)
-    {
-        if (DataContext is not MainWindowViewModel vm || vm.SelectedAddressRow is not { } row)
-            return;
-        vm.ShowAddressInfo(row);
-    }
-
-    private void OnAddressListPointerPressed(object? sender, PointerPressedEventArgs e)
-    {
-        if (!e.GetCurrentPoint(null).Properties.IsRightButtonPressed) return;
-        if (sender is not ListBox lb || DataContext is not MainWindowViewModel vm) return;
-
-        var item = (e.Source as Visual)?.FindAncestorOfType<ListBoxItem>();
-        if (item is not { DataContext: AddressRow row }) return;
-
-        lb.SelectedItem = row;
-        vm.ShowAddressInfo(row);
-    }
-
-    // Chiusura dell'overlay dettaglio indirizzo: click sullo sfondo scuro
-    // (solo sullo sfondo, non sulla scheda) o tasto Esc.
-    private void OnAddressOverlayBackdropTapped(object? sender, TappedEventArgs e)
-    {
-        if (!ReferenceEquals(e.Source, sender)) return;
-        if (DataContext is MainWindowViewModel vm)
-            vm.AddressInfo = null;
-    }
-
-    private void OnServerOverlayBackdropTapped(object? sender, TappedEventArgs e)
-    {
-        if (!ReferenceEquals(e.Source, sender)) return;
-        if (DataContext is MainWindowViewModel vm)
-            vm.IsServerSettingsOpen = false;
-    }
-
-    private async void OnChooseDataFolderClick(object? sender, RoutedEventArgs e)
-    {
-        if (DataContext is not MainWindowViewModel vm)
-            return;
-
-        var folders = await StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
-        {
-            Title = "Cartella dati Palladium Wallet",
-            AllowMultiple = false,
-        });
-
-        if (folders.FirstOrDefault()?.TryGetLocalPath() is { } path)
-            vm.ApplyDataLocation(path);
-    }
-
-    private async void OnCopyReceiveAddressClick(object? sender, RoutedEventArgs e)
-    {
-        if (DataContext is not MainWindowViewModel vm || string.IsNullOrEmpty(vm.ReceiveAddress))
-            return;
-        if (Clipboard is { } clipboard)
-        {
-            await clipboard.SetTextAsync(vm.ReceiveAddress);
-            vm.NotifyAddressCopied();
-        }
-    }
-
-    private void OnConnectionStatusTapped(object? sender, TappedEventArgs e)
-    {
-        if (DataContext is MainWindowViewModel vm)
-            vm.IsServerSettingsOpen = true;
-    }
-
-    private void OnSettingsOverlayBackdropTapped(object? sender, TappedEventArgs e)
-    {
-        if (!ReferenceEquals(e.Source, sender)) return;
-        if (DataContext is MainWindowViewModel vm)
-            vm.IsSettingsOpen = false;
-    }
-
-    private void OnHelpOverlayBackdropTapped(object? sender, TappedEventArgs e)
-    {
-        if (!ReferenceEquals(e.Source, sender)) return;
-        if (DataContext is MainWindowViewModel vm)
-            vm.IsHelpOpen = false;
-    }
-
-    protected override void OnKeyDown(KeyEventArgs e)
-    {
-        if (e.Key == Key.Escape && DataContext is MainWindowViewModel vm)
-        {
-            if (vm.IsTxDetailsOpen) { vm.CloseTransactionDetailsCommand.Execute(null); e.Handled = true; return; }
-            if (vm.AddressInfo is not null) { vm.AddressInfo = null; e.Handled = true; return; }
-            if (vm.IsServerSettingsOpen) { vm.IsServerSettingsOpen = false; e.Handled = true; return; }
-            if (vm.IsSettingsOpen) { vm.IsSettingsOpen = false; e.Handled = true; return; }
-            if (vm.IsHelpOpen) { vm.IsHelpOpen = false; e.Handled = true; return; }
-        }
-        base.OnKeyDown(e);
-    }
 }

src/Cli/PalladiumWallet.Cli.csproj

@@ -6,7 +6,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

src/Cli/Program.cs

@@ -104,8 +104,9 @@ static int Info(string[] o)
     Console.WriteLine($"xpub:     {doc.AccountXpub}");
     if (doc.Cache is { } cache)
     {
-        Console.WriteLine($"saldo:    {CoinAmount.Format(cache.ConfirmedSats, account.Profile.CoinUnit)} confermato"
-            + (cache.UnconfirmedSats != 0 ? $" + {CoinAmount.Format(cache.UnconfirmedSats)} in attesa (non spendibile)." : ""));
+        Console.WriteLine($"saldo:    {CoinAmount.Format(cache.ConfirmedSats - cache.ImmatureSats, account.Profile.CoinUnit)} spendibile"
+            + (cache.ImmatureSats != 0 ? $" + {CoinAmount.Format(cache.ImmatureSats)} in maturazione (non spendibile)" : "")
+            + (cache.UnconfirmedSats != 0 ? $" + {CoinAmount.Format(cache.UnconfirmedSats)} in attesa di conferma (non spendibile)." : ""));
         Console.WriteLine($"sync:     altezza {cache.TipHeight}, {cache.History.Count} transazioni");
         Console.WriteLine($"ricezione: {account.GetReceiveAddress(cache.NextReceiveIndex)}");
     }
@@ -131,22 +132,36 @@ static async Task<int> Sync(string[] o)
 
     var sync = new WalletSynchronizer(account, client, doc.GapLimit);
     sync.Progress += msg => Console.WriteLine($"  {msg}");
+    var net = PalladiumNetworks.For(account.Profile.Kind);
+    sync.PreloadCaches(
+        doc.Cache?.RawTxHex ?? [],
+        doc.Cache?.VerifiedAt ?? [],
+        doc.Cache?.BlockHeaders,
+        doc.Cache?.NextReceiveIndex ?? 0,
+        doc.Cache?.NextChangeIndex ?? 0,
+        net);
     var result = await sync.SyncOnceAsync();
 
+    var (rawHex, verifiedAt, blockHeaders) = sync.ExportCaches(net);
     doc.Cache = new SyncCache
     {
         TipHeight = result.TipHeight,
         ConfirmedSats = result.ConfirmedSats,
         UnconfirmedSats = result.UnconfirmedSats,
+        ImmatureSats = result.ImmatureSats,
         NextReceiveIndex = result.NextReceiveIndex,
         NextChangeIndex = result.NextChangeIndex,
         History = [.. result.History],
         Utxos = [.. result.Utxos],
         Addresses = [.. result.AddressRows],
+        RawTxHex = rawHex,
+        VerifiedAt = verifiedAt,
+        BlockHeaders = blockHeaders,
     };
     WalletStore.Save(doc, path, Opt(o, "--password"));
 
-    Console.WriteLine($"Saldo: {CoinAmount.Format(result.ConfirmedSats, account.Profile.CoinUnit)} confermato"
+    Console.WriteLine($"Saldo: {CoinAmount.Format(result.ConfirmedSats - result.ImmatureSats, account.Profile.CoinUnit)} spendibile"
+        + (result.ImmatureSats != 0 ? $" + {CoinAmount.Format(result.ImmatureSats)} in maturazione (non spendibile)" : "")
         + (result.UnconfirmedSats != 0 ? $" + {CoinAmount.Format(result.UnconfirmedSats)} in attesa di conferma (non spendibile)" : ""));
     Console.WriteLine($"Storico ({result.History.Count}):");
     foreach (var tx in result.History)
@@ -181,7 +196,7 @@ static async Task<int> Send(string[] o)
 
     var built = new TransactionFactory(account).Build(
         doc.Cache.Utxos, transactions, destination, amount, feeRate,
-        doc.Cache.NextChangeIndex, sendAll);
+        doc.Cache.NextChangeIndex, doc.Cache.TipHeight, sendAll);
 
     Console.WriteLine($"txid:  {built.Txid}");
     Console.WriteLine($"fee:   {CoinAmount.Format(built.Fee.Satoshi, account.Profile.CoinUnit)} " +
@@ -282,7 +297,7 @@ static int SaveWallet(string words, string[] o)
     return 0;
 }
 
-static (WalletDocument, HdAccount, string) OpenWallet(string[] o)
+static (WalletDocument, IWalletAccount, string) OpenWallet(string[] o)
 {
     var path = WalletPath(o, Profile(o));
     if (!WalletStore.Exists(path))

src/Core/Chain/ChainProfile.cs

@@ -1,7 +1,7 @@
 namespace PalladiumWallet.Core.Chain;
 
 /// <summary>
-/// Tipo di rete supportato (selettore unico per tutto il wallet, blueprint §3).
+/// Supported network type (single selector for the whole wallet, blueprint §3).
 /// </summary>
 public enum NetKind
 {
@@ -11,7 +11,7 @@ public enum NetKind
 }
 
 /// <summary>
-/// Tipo di script/indirizzo supportato (blueprint §4.3).
+/// Supported script/address type (blueprint §4.3).
 /// </summary>
 public enum ScriptKind
 {
@@ -21,7 +21,7 @@ public enum ScriptKind
     /// <summary>P2SH-P2WPKH (segwit wrapped).</summary>
     WrappedSegwit,
 
-    /// <summary>P2WPKH (native segwit) — default consigliato.</summary>
+    /// <summary>P2WPKH (native segwit) — recommended default.</summary>
     NativeSegwit,
 
     /// <summary>P2SH-P2WSH (multisig wrapped).</summary>
@@ -29,18 +29,21 @@ public enum ScriptKind
 
     /// <summary>P2WSH (multisig native).</summary>
     NativeSegwitMultisig,
+
+    /// <summary>P2TR key-path only (Taproot, BIP86) — witness v1, bech32m.</summary>
+    Taproot,
 }
 
 /// <summary>
-/// Coppia di header di versione BIP32 (4 byte big-endian) per serializzare
-/// xprv/xpub e varianti SLIP-132 (y/z/Y/Z) — blueprint §3.
+/// Pair of BIP32 version headers (4-byte big-endian) to serialize
+/// xprv/xpub and SLIP-132 variants (y/z/Y/Z) — blueprint §3.
 /// </summary>
 public readonly record struct ExtKeyHeaders(uint Private, uint Public)
 {
-    /// <summary>Header privato come 4 byte big-endian (da anteporre al payload BIP32).</summary>
+    /// <summary>Private header as 4 big-endian bytes (to prepend to the BIP32 payload).</summary>
     public byte[] PrivateBytes() => ToBytes(Private);
 
-    /// <summary>Header pubblico come 4 byte big-endian.</summary>
+    /// <summary>Public header as 4 big-endian bytes.</summary>
     public byte[] PublicBytes() => ToBytes(Public);
 
     internal static byte[] ToBytes(uint header) =>
@@ -53,82 +56,88 @@ public readonly record struct ExtKeyHeaders(uint Private, uint Public)
 }
 
 /// <summary>
-/// Server di indicizzazione di bootstrap: host + porta TCP + porta SSL (blueprint §3/§9).
+/// Bootstrap indexing server: host + TCP port + SSL port (blueprint §3/§9).
 /// </summary>
 public readonly record struct ServerEndpoint(string Host, int TcpPort, int SslPort);
 
 /// <summary>
-/// Checkpoint di catena: ancora la fiducia quando la verifica PoW è disattivata
-/// (blueprint §7.3). Target serializzato come "bits" compatti.
+/// Chain checkpoint: anchors trust when PoW validation is disabled
+/// (blueprint §7.3). Target serialized as compact "bits".
 /// </summary>
 public readonly record struct Checkpoint(int Height, string BlockHash, uint Bits);
 
 /// <summary>
-/// Profilo di rete/catena (blueprint §3): tutte le costanti specifiche della catena,
-/// centralizzate in un solo punto. Nessun magic number altrove nel codice.
+/// Network/chain profile (blueprint §3): all chain-specific constants,
+/// centralized in one place. No magic numbers elsewhere in the code.
 /// </summary>
 public sealed record ChainProfile
 {
     public required NetKind Kind { get; init; }
 
-    /// <summary>Nome rete, usato anche come sottocartella dati.</summary>
+    /// <summary>Network name, also used as the data subfolder.</summary>
     public required string NetName { get; init; }
 
-    /// <summary>Simbolo dell'unità (es. PLM).</summary>
+    /// <summary>Unit symbol (e.g. PLM).</summary>
     public required string CoinUnit { get; init; }
 
-    /// <summary>Prefisso WIF delle chiavi private.</summary>
+    /// <summary>WIF prefix for private keys.</summary>
     public required byte WifPrefix { get; init; }
 
-    /// <summary>Byte di versione indirizzi P2PKH.</summary>
+    /// <summary>Version byte for P2PKH addresses.</summary>
     public required byte AddrP2pkh { get; init; }
 
-    /// <summary>Byte di versione indirizzi P2SH.</summary>
+    /// <summary>Version byte for P2SH addresses.</summary>
     public required byte AddrP2sh { get; init; }
 
     /// <summary>Human-readable part bech32/bech32m.</summary>
     public required string SegwitHrp { get; init; }
 
-    /// <summary>HRP fatture BOLT11 (Lightning, fase successiva — §11).</summary>
+    /// <summary>HRP for BOLT11 invoices (Lightning, later phase — §11).</summary>
     public required string Bolt11Hrp { get; init; }
 
-    /// <summary>Hash del blocco genesi (hex, byte order da explorer).</summary>
+    /// <summary>Genesis block hash (hex, explorer byte order).</summary>
     public required string GenesisHash { get; init; }
 
-    /// <summary>Porta TCP del server di indicizzazione (non è la porta P2P del nodo).</summary>
+    /// <summary>TCP port of the indexing server (not the node's P2P port).</summary>
     public required int DefaultTcpPort { get; init; }
 
-    /// <summary>Porta SSL del server di indicizzazione.</summary>
+    /// <summary>SSL port of the indexing server.</summary>
     public required int DefaultSslPort { get; init; }
 
-    /// <summary>Porta P2P del nodo — solo informativa: il wallet SPV non la usa.</summary>
+    /// <summary>Node's P2P port — informational only: the SPV wallet does not use it.</summary>
     public required int NodeP2pPort { get; init; }
 
-    /// <summary>Coin type SLIP-0044 nei derivation path (convenzione wallet).</summary>
+    /// <summary>SLIP-0044 coin type in derivation paths (wallet convention).</summary>
     public required int Bip44CoinType { get; init; }
 
-    /// <summary>Schema URI pagamenti BIP21 (senza i due punti).</summary>
+    /// <summary>BIP21 payment URI scheme (without the colon).</summary>
     public required string UriScheme { get; init; }
 
-    /// <summary>Block explorer di default.</summary>
+    /// <summary>Default block explorer.</summary>
     public required string ExplorerUrl { get; init; }
 
     /// <summary>
-    /// La catena usa LWMA (retargeting per-blocco, 2 minuti): un client SPV non può
-    /// ricalcolarla, quindi la verifica bits/target va saltata e la fiducia ancorata
-    /// ai checkpoint (§3/§7). Per la catena di riferimento è sempre true.
+    /// The chain uses LWMA (per-block retargeting, 2 minutes): an SPV client cannot
+    /// recompute it, so bits/target validation must be skipped and trust anchored
+    /// to checkpoints (§3/§7). For the reference chain it is always true.
     /// </summary>
     public required bool SkipPowValidation { get; init; }
 
-    /// <summary>Tempo di blocco target in secondi (LWMA v2: 120s).</summary>
+    /// <summary>Target block time in seconds (LWMA v2: 120s).</summary>
     public required int BlockTimeSeconds { get; init; }
 
-    /// <summary>Header BIP32/SLIP-132 per ciascun tipo di script.</summary>
+    /// <summary>Blocks a coinbase output must wait before it can be spent.</summary>
+    public required int CoinbaseMaturity { get; init; }
+
+    /// <summary>Minimum confirmations required for a regular UTXO to be spendable.</summary>
+    public required int MinConfirmations { get; init; }
+
+    /// <summary>BIP32/SLIP-132 headers for each script type.</summary>
     public required IReadOnlyDictionary<ScriptKind, ExtKeyHeaders> ExtKeyHeaders { get; init; }
 
-    /// <summary>Server di indicizzazione per il primo contatto (bootstrap).</summary>
+    /// <summary>Indexing servers for first contact (bootstrap).</summary>
     public required IReadOnlyList<ServerEndpoint> BootstrapServers { get; init; }
 
-    /// <summary>Checkpoint hardcoded, aggiornati a ogni release (§7.3).</summary>
+    /// <summary>Hardcoded checkpoints, updated at every release (§7.3).</summary>
     public required IReadOnlyList<Checkpoint> Checkpoints { get; init; }
 }

src/Core/Chain/ChainProfiles.cs

@@ -1,8 +1,8 @@
 namespace PalladiumWallet.Core.Chain;
 
 /// <summary>
-/// I tre profili di rete del wallet (blueprint §3). Valori mainnet verificati
-/// contro il sorgente del nodo (chainparams.cpp / pow.cpp) secondo il blueprint.
+/// The wallet's three network profiles (blueprint §3). Mainnet values verified
+/// against the node source (chainparams.cpp / pow.cpp) per the blueprint.
 /// </summary>
 public static class ChainProfiles
 {
@@ -12,11 +12,11 @@ public static class ChainProfiles
         NetName = "mainnet",
         CoinUnit = "PLM",
         WifPrefix = 0x80,
-        AddrP2pkh = 55,   // indirizzi che iniziano con 'P'
-        AddrP2sh = 5,     // indirizzi che iniziano con '3'
+        AddrP2pkh = 55,   // addresses starting with 'P'
+        AddrP2sh = 5,     // addresses starting with '3'
         SegwitHrp = "plm",
         Bolt11Hrp = "plm",
-        // La mainnet riusa la genesi di Bitcoin (blueprint §3).
+        // Mainnet reuses Bitcoin's genesis (blueprint §3).
         GenesisHash = "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",
         DefaultTcpPort = 50001,
         DefaultSslPort = 50002,
@@ -26,6 +26,8 @@ public static class ChainProfiles
         ExplorerUrl = "https://explorer.palladium-coin.com/",
         SkipPowValidation = true,
         BlockTimeSeconds = 120,
+        CoinbaseMaturity = 120,
+        MinConfirmations = 6,
         ExtKeyHeaders = new Dictionary<ScriptKind, ExtKeyHeaders>
         {
             [ScriptKind.Legacy] = new(0x0488ade4, 0x0488b21e),                // xprv / xpub
@@ -33,9 +35,11 @@ public static class ChainProfiles
             [ScriptKind.WrappedSegwitMultisig] = new(0x0295b005, 0x0295b43f), // Yprv / Ypub
             [ScriptKind.NativeSegwit] = new(0x04b2430c, 0x04b24746),          // zprv / zpub
             [ScriptKind.NativeSegwitMultisig] = new(0x02aa7a99, 0x02aa7ed3),  // Zprv / Zpub
+            // No SLIP-132 for P2TR: the context is given by the m/86'/… path
+            [ScriptKind.Taproot] = new(0x0488ade4, 0x0488b21e),               // xprv / xpub (BIP32 standard)
         },
-        // Server di indicizzazione noti per il primo contatto (§3/§9); altri
-        // peer vengono scoperti via server.peers.subscribe.
+        // Known indexing servers for first contact (§3/§9); other
+        // peers are discovered via server.peers.subscribe.
         BootstrapServers =
         [
             new ServerEndpoint("173.212.224.67", 50001, 50002),
@@ -43,7 +47,7 @@ public static class ChainProfiles
             new ServerEndpoint("66.94.115.80", 50001, 50002),
             new ServerEndpoint("89.117.149.130", 50001, 50002),
         ],
-        // TODO: popolare con [hash, bits] reali della catena (§7.3) prima della release.
+        // TODO: populate with the chain's real [hash, bits] (§7.3) before release.
         Checkpoints = [],
     };
 
@@ -51,25 +55,27 @@ public static class ChainProfiles
     {
         Kind = NetKind.Testnet,
         NetName = "testnet",
+        MinConfirmations = 1,
         WifPrefix = 0xff,
         AddrP2pkh = 127,
         AddrP2sh = 115,
         SegwitHrp = "tplm",
         Bolt11Hrp = "tplm",
-        // TODO: verificare contro chainparams.cpp del nodo (il blueprint non la riporta;
-        // qui si assume la genesi di Bitcoin testnet3, da confermare).
+        // TODO: verify against the node's chainparams.cpp (the blueprint does not report it;
+        // here Bitcoin testnet3 genesis is assumed, to be confirmed).
         GenesisHash = "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943",
         NodeP2pPort = 12333,
         Bip44CoinType = 1,
         ExtKeyHeaders = new Dictionary<ScriptKind, ExtKeyHeaders>
         {
-            // tprv/tpub dal blueprint; le varianti SLIP-132 testnet (u/v/U/V) sono
-            // i valori standard Electrum.
+            // tprv/tpub from the blueprint; the testnet SLIP-132 variants (u/v/U/V) are
+            // the standard Electrum values.
             [ScriptKind.Legacy] = new(0x04358394, 0x043587cf),                // tprv / tpub
             [ScriptKind.WrappedSegwit] = new(0x044a4e28, 0x044a5262),         // uprv / upub
             [ScriptKind.WrappedSegwitMultisig] = new(0x024285b5, 0x024289ef), // Uprv / Upub
             [ScriptKind.NativeSegwit] = new(0x045f18bc, 0x045f1cf6),          // vprv / vpub
             [ScriptKind.NativeSegwitMultisig] = new(0x02575048, 0x02575483),  // Vprv / Vpub
+            [ScriptKind.Taproot] = new(0x04358394, 0x043587cf),               // tprv / tpub (BIP32 standard)
         },
         BootstrapServers = [],
         Checkpoints = [],
@@ -81,7 +87,7 @@ public static class ChainProfiles
         NetName = "regtest",
         SegwitHrp = "rplm",
         Bolt11Hrp = "rplm",
-        // TODO: verificare contro chainparams.cpp del nodo (assunta genesi regtest Bitcoin).
+        // TODO: verify against the node's chainparams.cpp (Bitcoin regtest genesis assumed).
         GenesisHash = "0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206",
         NodeP2pPort = 28444,
         Checkpoints = [],

src/Core/Chain/PalladiumNetworks.cs

@@ -4,13 +4,13 @@ using NBitcoin.DataEncoders;
 namespace PalladiumWallet.Core.Chain;
 
 /// <summary>
-/// Costruisce e registra le <see cref="Network"/> NBitcoin di Palladium a partire dai
-/// <see cref="ChainProfiles"/> (blueprint §19.3). Tutto il resto del codice ottiene la
-/// rete da qui, mai da costanti sparse.
+/// Builds and registers the Palladium NBitcoin <see cref="Network"/> instances from the
+/// <see cref="ChainProfiles"/> (blueprint §19.3). All other code obtains the network
+/// from here — never from scattered constants.
 /// </summary>
 /// <summary>
-/// Identità della moneta per NBitcoin: raggruppa le tre reti sotto il codice PLM.
-/// I getter sono lazy, quindi nessuna ricorsione durante la costruzione.
+/// Coin identity for NBitcoin: groups the three networks under the PLM code.
+/// Getters are lazy, so no recursion occurs during construction.
 /// </summary>
 public sealed class PalladiumNetworkSet : INetworkSet
 {
@@ -34,13 +34,13 @@ public sealed class PalladiumNetworkSet : INetworkSet
 
 public static class PalladiumNetworks
 {
-    // Blocco genesi di Bitcoin (la mainnet Palladium lo riusa, blueprint §3).
+    // Bitcoin genesis block (Palladium mainnet reuses it, blueprint §3).
     private const string MainGenesisHex =
         "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4a29ab5f49ffff001d1dac2b7c" +
         Coinbase;
 
-    // Genesi testnet3/regtest di Bitcoin: stessa coinbase, cambiano time/bits/nonce.
-    // TODO: confermare contro chainparams.cpp del nodo (vedi ChainProfiles).
+    // Bitcoin testnet3/regtest genesis: same coinbase, different time/bits/nonce.
+    // TODO: confirm against the node's chainparams.cpp (see ChainProfiles).
     private const string TestGenesisHex =
         "0100000000000000000000000000000000000000000000000000000000000000000000003ba3edfd7a7b12b27ac72c3e67768f617fc81bc3888a51323a9fb8aa4b1e5e4adae5494dffff001d1aa4ae18" +
         Coinbase;
@@ -81,9 +81,9 @@ public static class PalladiumNetworks
                 NetKind.Testnet => ChainName.Testnet,
                 _ => ChainName.Regtest,
             })
-            // Magic P2P solo segnaposto: il wallet SPV non apre mai connessioni P2P
-            // (parla solo col server di indicizzazione, §3). Serve a NBitcoin per
-            // distinguere le reti registrate.
+            // P2P magic is a placeholder only: the SPV wallet never opens P2P connections
+            // (it only talks to the indexing server, §3). Required by NBitcoin to
+            // distinguish registered networks.
             .SetMagic(magic)
             .SetPort(p.NodeP2pPort)
             .SetRPCPort(p.NodeP2pPort + 1)
@@ -91,9 +91,9 @@ public static class PalladiumNetworks
             .SetBase58Bytes(Base58Type.PUBKEY_ADDRESS, [p.AddrP2pkh])
             .SetBase58Bytes(Base58Type.SCRIPT_ADDRESS, [p.AddrP2sh])
             .SetBase58Bytes(Base58Type.SECRET_KEY, [p.WifPrefix])
-            // NBitcoin gestisce una sola coppia di header BIP32 per rete: quella
-            // standard xprv/xpub. Le varianti SLIP-132 (y/z/Y/Z) si serializzano
-            // a mano con ChainProfile.ExtKeyHeaders quando servono.
+            // NBitcoin handles only one BIP32 header pair per network: the standard
+            // xprv/xpub. SLIP-132 variants (y/z/Y/Z) are serialised manually via
+            // ChainProfile.ExtKeyHeaders when needed.
             .SetBase58Bytes(Base58Type.EXT_SECRET_KEY, legacy.PrivateBytes())
             .SetBase58Bytes(Base58Type.EXT_PUBLIC_KEY, legacy.PublicBytes())
             .SetBech32(Bech32Type.WITNESS_PUBKEY_ADDRESS, Encoders.Bech32(p.SegwitHrp))
@@ -102,8 +102,8 @@ public static class PalladiumNetworks
             .SetUriScheme(p.UriScheme)
             .SetConsensus(new Consensus
             {
-                // Valori usati solo dalle API NBitcoin che li richiedono: la validazione
-                // header reale è custom (Core/Spv) con skip PoW + checkpoint (§7).
+                // Values used only by NBitcoin APIs that require them: real header
+                // validation is custom (Core/Spv) with PoW skip + checkpoints (§7).
                 PowLimit = new Target(new uint256("00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")),
                 PowTargetSpacing = TimeSpan.FromSeconds(p.BlockTimeSeconds),
                 PowTargetTimespan = TimeSpan.FromDays(14),
@@ -114,7 +114,7 @@ public static class PalladiumNetworks
                 MajorityRejectBlockOutdated = 950,
                 MajorityWindow = 1000,
                 MinimumChainWork = uint256.Zero,
-                CoinbaseMaturity = 100,
+                CoinbaseMaturity = 120,
                 SupportSegwit = true,
                 SupportTaproot = true,
                 ConsensusFactory = new ConsensusFactory(),

src/Core/Crypto/Bip39.cs

@@ -3,8 +3,8 @@ using NBitcoin;
 namespace PalladiumWallet.Core.Crypto;
 
 /// <summary>
-/// Lingue wordlist BIP39 supportate (blueprint §4.1). Le liste sono incorporate
-/// in NBitcoin: nessun accesso a rete o filesystem.
+/// Supported BIP39 wordlist languages (blueprint §4.1). The lists are embedded
+/// in NBitcoin: no network or filesystem access required.
 /// </summary>
 public enum MnemonicLanguage
 {
@@ -18,7 +18,7 @@ public enum MnemonicLanguage
     Czech,
 }
 
-/// <summary>Numero di parole supportato in creazione (blueprint §4.1: 12 o 24).</summary>
+/// <summary>Supported word counts for mnemonic creation (blueprint §4.1: 12 or 24).</summary>
 public enum MnemonicLength
 {
     Twelve = 12,
@@ -26,16 +26,16 @@ public enum MnemonicLength
 }
 
 /// <summary>
-/// Facciata BIP39 su NBitcoin.Mnemonic (blueprint §4.1). NBitcoin copre già
-/// entropia→parole, checksum, normalizzazione NFKD e PBKDF2-HMAC-SHA512 a 2048
-/// round con salt "mnemonic"+passphrase: qui si restringe l'API ai casi del
-/// blueprint e si centralizza la mappa delle lingue. Quando arriverà il seed
-/// nativo versionato (§4.1 punto 1), il riconoscimento multi-schema sarà una
-/// catena di TryParse per schema.
+/// BIP39 facade over NBitcoin.Mnemonic (blueprint §4.1). NBitcoin already handles
+/// entropy→words, checksum, NFKD normalisation, and PBKDF2-HMAC-SHA512 with 2048
+/// rounds using salt "mnemonic"+passphrase. This class narrows the API to the
+/// blueprint use-cases and centralises the language map. When the native versioned
+/// seed arrives (§4.1 point 1), multi-scheme recognition will be a chain of
+/// TryParse calls per scheme.
 /// </summary>
 public static class Bip39
 {
-    /// <summary>Genera una nuova mnemonica con entropia dal CSPRNG di sistema.</summary>
+    /// <summary>Generates a new mnemonic using entropy from the system CSPRNG.</summary>
     public static Mnemonic Generate(MnemonicLength length, MnemonicLanguage language = MnemonicLanguage.English)
     {
         var wordCount = length == MnemonicLength.Twelve ? WordCount.Twelve : WordCount.TwentyFour;
@@ -43,10 +43,10 @@ public static class Bip39
     }
 
     /// <summary>
-    /// Riconosce e valida una mnemonica BIP39: numero di parole, appartenenza alla
-    /// wordlist e checksum. Se <paramref name="language"/> è indicata viene provata
-    /// per prima; altrimenti la lingua è auto-rilevata (parole condivise tra liste
-    /// possono rendere ambiguo l'autodetect: in import l'utente può forzarla).
+    /// Recognises and validates a BIP39 mnemonic: word count, wordlist membership,
+    /// and checksum. If <paramref name="language"/> is specified it is tried first;
+    /// otherwise the language is auto-detected (words shared between lists can make
+    /// autodetect ambiguous — the user can override it on import).
     /// </summary>
     public static bool TryParse(string text, out Mnemonic? mnemonic, MnemonicLanguage? language = null)
     {
@@ -54,8 +54,8 @@ public static class Bip39
         if (string.IsNullOrWhiteSpace(text))
             return false;
 
-        // Solo trim esterno: la normalizzazione NFKD e lo spazio ideografico
-        // giapponese li gestisce NBitcoin, il testo non va alterato (§4.1).
+        // Outer trim only: NBitcoin handles NFKD normalisation and Japanese
+        // ideographic spaces — the text must not be altered further (§4.1).
         text = text.Trim();
 
         IEnumerable<Wordlist> candidates = language is not null
@@ -67,7 +67,7 @@ public static class Bip39
             try
             {
                 var parsed = new Mnemonic(text, wordlist);
-                // Il costruttore NON verifica il checksum: controllo esplicito obbligatorio.
+                // The constructor does NOT verify the checksum — explicit check is mandatory.
                 if (parsed.IsValidChecksum && parsed.Words.Length is 12 or 15 or 18 or 21 or 24)
                 {
                     mnemonic = parsed;
@@ -76,7 +76,7 @@ public static class Bip39
             }
             catch (FormatException)
             {
-                // Parole fuori wordlist o conteggio non valido: si prova oltre.
+                // Words outside the wordlist or invalid count — try the next candidate.
             }
         }
 
@@ -84,9 +84,9 @@ public static class Bip39
     }
 
     /// <summary>
-    /// Mnemonica → seed di 64 byte (PBKDF2-HMAC-SHA512, 2048 round, salt
-    /// "mnemonic"+passphrase). La passphrase cambia completamente il wallet
-    /// derivato: avvisi UI obbligatori (§4.1).
+    /// Mnemonic → 64-byte seed (PBKDF2-HMAC-SHA512, 2048 rounds, salt
+    /// "mnemonic"+passphrase). The passphrase completely changes the derived
+    /// wallet — mandatory UI warnings required (§4.1).
     /// </summary>
     public static byte[] ToSeed(Mnemonic mnemonic, string? passphrase = null) =>
         mnemonic.DeriveSeed(passphrase);

src/Core/Crypto/DerivationPaths.cs

@@ -4,52 +4,57 @@ using PalladiumWallet.Core.Chain;
 namespace PalladiumWallet.Core.Crypto;
 
 /// <summary>
-/// Costruzione dei derivation path BIP44/49/84 (blueprint §4.2) e mappatura
-/// ScriptKind → purpose / ScriptPubKeyType. I purpose sono costanti di protocollo
-/// BIP (chain-independent); il coin_type viene sempre dal ChainProfile.
+/// BIP44/49/84 derivation path construction (blueprint §4.2) and mapping of
+/// ScriptKind → purpose / ScriptPubKeyType. Purposes are BIP protocol constants
+/// (chain-independent); coin_type always comes from the ChainProfile.
 /// </summary>
 public static class DerivationPaths
 {
-    /// <summary>Purpose BIP44 (P2PKH legacy).</summary>
+    /// <summary>BIP44 purpose (P2PKH legacy).</summary>
     public const int PurposeLegacy = 44;
 
-    /// <summary>Purpose BIP49 (P2SH-P2WPKH).</summary>
+    /// <summary>BIP49 purpose (P2SH-P2WPKH).</summary>
     public const int PurposeWrappedSegwit = 49;
 
-    /// <summary>Purpose BIP84 (P2WPKH nativo).</summary>
+    /// <summary>BIP84 purpose (native P2WPKH).</summary>
     public const int PurposeNativeSegwit = 84;
 
-    /// <summary>Purpose BIP48 (multisig — fase successiva, §16 passo 8).</summary>
+    /// <summary>BIP48 purpose (multisig — next phase, §16 step 8).</summary>
     public const int PurposeMultisig = 48;
 
+    /// <summary>BIP86 purpose (P2TR key-path, Taproot).</summary>
+    public const int PurposeTaproot = 86;
+
     public static int PurposeFor(ScriptKind kind) => kind switch
     {
         ScriptKind.Legacy => PurposeLegacy,
         ScriptKind.WrappedSegwit => PurposeWrappedSegwit,
         ScriptKind.NativeSegwit => PurposeNativeSegwit,
         ScriptKind.WrappedSegwitMultisig or ScriptKind.NativeSegwitMultisig => PurposeMultisig,
+        ScriptKind.Taproot => PurposeTaproot,
         _ => throw new ArgumentOutOfRangeException(nameof(kind)),
     };
 
     /// <summary>
-    /// Tipo di scriptPubKey NBitcoin per la derivazione da pubkey singola.
-    /// I tipi multisig derivano da redeem script, non da una pubkey: arriveranno
-    /// con i wallet M-di-N (§4.5).
+    /// NBitcoin scriptPubKey type for single-pubkey derivation.
+    /// Multisig types are derived from a redeem script, not a pubkey — they will
+    /// arrive with M-of-N wallet support (§4.5).
     /// </summary>
     public static ScriptPubKeyType ScriptPubKeyTypeFor(ScriptKind kind) => kind switch
     {
         ScriptKind.Legacy => ScriptPubKeyType.Legacy,
         ScriptKind.WrappedSegwit => ScriptPubKeyType.SegwitP2SH,
         ScriptKind.NativeSegwit => ScriptPubKeyType.Segwit,
+        ScriptKind.Taproot => ScriptPubKeyType.TaprootBIP86,
         ScriptKind.WrappedSegwitMultisig or ScriptKind.NativeSegwitMultisig =>
             throw new NotSupportedException(
-                "I tipi multisig derivano da redeem script: supporto previsto con i wallet M-di-N (§4.5)."),
+                "Multisig types are derived from a redeem script: support planned with M-of-N wallets (§4.5)."),
         _ => throw new ArgumentOutOfRangeException(nameof(kind)),
     };
 
     /// <summary>
-    /// Path di account relativo alla root: purpose'/coin'/account' (§4.2).
-    /// Il coin_type è quello del profilo (746 mainnet, 1 testnet).
+    /// Account path relative to the root: purpose'/coin'/account' (§4.2).
+    /// coin_type is taken from the profile (746 mainnet, 1 testnet).
     /// </summary>
     public static KeyPath AccountPath(ScriptKind kind, ChainProfile profile, int account = 0)
     {
@@ -59,7 +64,7 @@ public static class DerivationPaths
             $"{PurposeFor(kind)}'/{profile.Bip44CoinType}'/{account}'");
     }
 
-    /// <summary>Sottopath non-hardened change/index sotto l'account (change=0 receiving, change=1 change).</summary>
+    /// <summary>Non-hardened change/index sub-path under the account (change=0 receiving, change=1 change).</summary>
     public static KeyPath AddressSubPath(bool isChange, int index)
     {
         if (index < 0)
@@ -68,8 +73,8 @@ public static class DerivationPaths
     }
 
     /// <summary>
-    /// Parsing di derivation path personalizzati in import (Sparrow-like, §4.2):
-    /// accetta il prefisso "m/" opzionale e gli hardened marker ' oppure h.
+    /// Parsing of custom derivation paths on import (Sparrow-like, §4.2):
+    /// accepts the optional "m/" prefix and hardened markers ' or h.
     /// </summary>
     public static bool TryParse(string path, out KeyPath? keyPath)
     {

src/Core/Crypto/HdAccount.cs

@@ -4,39 +4,39 @@ using PalladiumWallet.Core.Chain;
 namespace PalladiumWallet.Core.Crypto;
 
 /// <summary>
-/// Account HD single-sig (blueprint §4.2/§4.4): chiave estesa di account (xprv,
-/// oppure solo xpub = watch-only) + tipo di script + profilo di rete. Deriva
-/// indirizzi receiving (change=0) e change (change=1) on-demand per indice.
-/// Gli indirizzi si derivano sempre dall'xpub di account (sottopath non-hardened),
-/// quindi il watch-only funziona per costruzione. Il keystore completo
-/// (cifratura, factory dal file wallet, §4.5) arriva con la persistenza (§8).
+/// Single-sig HD account (blueprint §4.2/§4.4): extended account key (xprv,
+/// or xpub-only = watch-only) + script type + network profile. Derives receiving
+/// (change=0) and change (change=1) addresses on-demand by index.
+/// Addresses are always derived from the account xpub (non-hardened sub-path),
+/// so watch-only works by construction. The full keystore
+/// (encryption, factory from wallet file, §4.5) arrives with persistence (§8).
 /// </summary>
-public sealed class HdAccount
+public sealed class HdAccount : IWalletAccount
 {
     private readonly ExtKey? _accountXprv;
 
     public ScriptKind Kind { get; }
     public ChainProfile Profile { get; }
 
-    /// <summary>Path dell'account relativo alla root (es. 84'/746'/0', o personalizzato).</summary>
+    /// <summary>Account path relative to the root (e.g. 84'/746'/0', or custom).</summary>
     public KeyPath AccountPath { get; }
 
     /// <summary>
-    /// Fingerprint della chiave master: con <see cref="AccountPath"/> forma le
-    /// origin info richieste dalle PSBT (§6.5). Zero se ignota (xpub importata
-    /// senza metadati).
+    /// Master key fingerprint: together with <see cref="AccountPath"/> forms the
+    /// origin info required by PSBTs (§6.5). Zero if unknown (imported xpub
+    /// without metadata).
     /// </summary>
     public HDFingerprint MasterFingerprint { get; }
 
     public ExtPubKey AccountXpub { get; }
 
-    /// <summary>True se l'account conosce solo la xpub: costruisce ma non firma (§4.5).</summary>
+    /// <summary>True if the account only knows the xpub: can build but not sign (§4.5).</summary>
     public bool IsWatchOnly => _accountXprv is null;
 
     private HdAccount(ExtKey? accountXprv, ExtPubKey accountXpub, ScriptKind kind,
         ChainProfile profile, KeyPath accountPath, HDFingerprint masterFingerprint)
     {
-        // Valida subito la mappatura (i tipi multisig non sono supportati qui).
+        // Validate the mapping immediately (multisig types are not supported here).
         DerivationPaths.ScriptPubKeyTypeFor(kind);
         _accountXprv = accountXprv;
         AccountXpub = accountXpub;
@@ -46,7 +46,7 @@ public sealed class HdAccount
         MasterFingerprint = masterFingerprint;
     }
 
-    /// <summary>Caso principale: mnemonica BIP39 (+ passphrase opzionale) → account standard.</summary>
+    /// <summary>Main case: BIP39 mnemonic (+ optional passphrase) → standard account.</summary>
     public static HdAccount FromMnemonic(Mnemonic mnemonic, string? passphrase,
         ScriptKind kind, ChainProfile profile, int account = 0) =>
         FromSeed(Bip39.ToSeed(mnemonic, passphrase), kind, profile, account);
@@ -55,22 +55,22 @@ public sealed class HdAccount
         FromSeed(seed, kind, profile, DerivationPaths.AccountPath(kind, profile, account));
 
     /// <summary>
-    /// Import con derivation path personalizzato (§4.2, Sparrow-like):
-    /// <paramref name="kind"/> determina solo il tipo di indirizzo generato.
+    /// Import with a custom derivation path (§4.2, Sparrow-like):
+    /// <paramref name="kind"/> only determines the generated address type.
     /// </summary>
     public static HdAccount FromSeed(byte[] seed, ScriptKind kind, ChainProfile profile, KeyPath accountPath)
     {
         var root = ExtKey.CreateFromSeed(seed);
-        // L'account si deriva sempre dalla xprv: i livelli hardened del path
-        // non sono derivabili da una xpub.
+        // The account is always derived from the xprv: hardened path levels
+        // cannot be derived from an xpub alone.
         var accountXprv = root.Derive(accountPath);
         return new HdAccount(accountXprv, accountXprv.Neuter(), kind, profile,
             accountPath, root.Neuter().PubKey.GetHDFingerPrint());
     }
 
     /// <summary>
-    /// Watch-only da xpub di account (§4.4): fingerprint e path sono noti solo
-    /// se forniti da chi importa (servono per le origin info PSBT).
+    /// Watch-only from account xpub (§4.4): fingerprint and path are known only
+    /// if supplied by the importer (required for PSBT origin info).
     /// </summary>
     public static HdAccount FromAccountXpub(ExtPubKey accountXpub, ScriptKind kind,
         ChainProfile profile, KeyPath? accountPath = null, HDFingerprint? masterFingerprint = null) =>
@@ -78,7 +78,7 @@ public sealed class HdAccount
             accountPath ?? DerivationPaths.AccountPath(kind, profile),
             masterFingerprint ?? default);
 
-    /// <summary>Import spendibile da xprv di account.</summary>
+    /// <summary>Spendable import from account xprv.</summary>
     public static HdAccount FromAccountXprv(ExtKey accountXprv, ScriptKind kind,
         ChainProfile profile, KeyPath? accountPath = null, HDFingerprint? masterFingerprint = null) =>
         new(accountXprv, accountXprv.Neuter(), kind, profile,
@@ -86,7 +86,7 @@ public sealed class HdAccount
             masterFingerprint ?? default);
 
     public BitcoinAddress GetAddress(bool isChange, int index) =>
-        GetPublicKey(isChange, index).GetAddress(
+        GetPublicKey(isChange, index)!.GetAddress(
             DerivationPaths.ScriptPubKeyTypeFor(Kind),
             PalladiumNetworks.For(Profile.Kind));
 
@@ -94,23 +94,30 @@ public sealed class HdAccount
 
     public BitcoinAddress GetChangeAddress(int index) => GetAddress(isChange: true, index);
 
-    public PubKey GetPublicKey(bool isChange, int index) =>
+    public PubKey? GetPublicKey(bool isChange, int index) =>
         AccountXpub.Derive(DerivationPaths.AddressSubPath(isChange, index)).PubKey;
 
+    /// <summary>Private key for an address; null if watch-only (§17).</summary>
+    public Key? GetPrivateKey(bool isChange, int index) =>
+        IsWatchOnly ? null : GetExtPrivateKey(isChange, index).PrivateKey;
+
+    /// <summary>HD accounts use the gap limit: no fixed address list.</summary>
+    public IReadOnlyList<(BitcoinAddress Address, bool IsChange, int Index)>? FixedAddresses => null;
+
     /// <summary>
-    /// Chiave privata estesa di un indirizzo. Lancia se watch-only: nessuna
-    /// chiave privata è derivabile dalle sole pubbliche (§17).
+    /// Extended private key for an address. Throws if watch-only: no private key
+    /// can be derived from public keys alone (§17).
     /// </summary>
     public ExtKey GetExtPrivateKey(bool isChange, int index) =>
-        (_accountXprv ?? throw new InvalidOperationException("Account watch-only: non può firmare."))
+        (_accountXprv ?? throw new InvalidOperationException("Watch-only account: cannot sign."))
             .Derive(DerivationPaths.AddressSubPath(isChange, index));
 
-    /// <summary>Xpub di account in formato SLIP-132 (xpub/ypub/zpub secondo Kind).</summary>
+    /// <summary>Account xpub in SLIP-132 format (xpub/ypub/zpub according to Kind).</summary>
     public string ToSlip132() => Slip132.Encode(AccountXpub, Kind, Profile);
 
-    /// <summary>Xprv di account in formato SLIP-132. Lancia se watch-only.</summary>
+    /// <summary>Account xprv in SLIP-132 format. Throws if watch-only.</summary>
     public string ToSlip132Private() =>
         Slip132.Encode(
-            _accountXprv ?? throw new InvalidOperationException("Account watch-only: nessuna chiave privata."),
+            _accountXprv ?? throw new InvalidOperationException("Watch-only account: no private key."),
             Kind, Profile);
 }

src/Core/Crypto/IWalletAccount.cs

@@ -0,0 +1,34 @@
+using NBitcoin;
+using PalladiumWallet.Core.Chain;
+
+namespace PalladiumWallet.Core.Crypto;
+
+/// <summary>
+/// Abstraction over all wallet account types (HD from seed, HD from imported xpub/xprv,
+/// imported WIF keys). Allows WalletSynchronizer and TransactionFactory to operate
+/// independently of the underlying keystore type (blueprint §4.4–§4.5).
+/// </summary>
+public interface IWalletAccount
+{
+    ScriptKind Kind { get; }
+    ChainProfile Profile { get; }
+
+    /// <summary>True if the account cannot sign (no private keys present).</summary>
+    bool IsWatchOnly { get; }
+
+    BitcoinAddress GetAddress(bool isChange, int index);
+    BitcoinAddress GetReceiveAddress(int index);
+    BitcoinAddress GetChangeAddress(int index);
+
+    /// <summary>Null if the public key cannot be derived from the account (pure watch-only addresses).</summary>
+    PubKey? GetPublicKey(bool isChange, int index);
+
+    /// <summary>Null if the account is watch-only or the index is out of range.</summary>
+    Key? GetPrivateKey(bool isChange, int index);
+
+    /// <summary>
+    /// For accounts with fixed addresses (imported WIF keys) returns the full list
+    /// to scan; null for HD accounts that use the gap limit.
+    /// </summary>
+    IReadOnlyList<(BitcoinAddress Address, bool IsChange, int Index)>? FixedAddresses { get; }
+}

src/Core/Crypto/ImportedKeyAccount.cs

@@ -0,0 +1,58 @@
+using NBitcoin;
+using PalladiumWallet.Core.Chain;
+
+namespace PalladiumWallet.Core.Crypto;
+
+/// <summary>
+/// Account built from individually imported WIF keys (blueprint §4.4 — "Imported"):
+/// fixed list of addresses, no HD derivation, no change chain.
+/// Change always goes back to the first imported address.
+/// </summary>
+public sealed class ImportedKeyAccount : IWalletAccount
+{
+    private readonly (BitcoinAddress Address, Key? PrivateKey)[] _entries;
+
+    public ScriptKind Kind { get; }
+    public ChainProfile Profile { get; }
+    public bool IsWatchOnly => _entries.All(e => e.PrivateKey is null);
+
+    public IReadOnlyList<(BitcoinAddress Address, bool IsChange, int Index)>? FixedAddresses =>
+        _entries.Select((e, i) => (e.Address, false, i)).ToList();
+
+    public ImportedKeyAccount(
+        IReadOnlyList<(BitcoinAddress Address, Key? PrivateKey)> entries,
+        ScriptKind kind, ChainProfile profile)
+    {
+        if (entries.Count == 0)
+            throw new ArgumentException("At least one address is required.", nameof(entries));
+        _entries = [.. entries];
+        Kind = kind;
+        Profile = profile;
+    }
+
+    public BitcoinAddress GetAddress(bool isChange, int index)
+    {
+        if (isChange || index < 0 || index >= _entries.Length)
+            return _entries[0].Address;
+        return _entries[index].Address;
+    }
+
+    public BitcoinAddress GetReceiveAddress(int index) => GetAddress(false, index);
+
+    /// <summary>Change always returns to the first imported address.</summary>
+    public BitcoinAddress GetChangeAddress(int index) => _entries[0].Address;
+
+    public PubKey? GetPublicKey(bool isChange, int index)
+    {
+        if (isChange || index < 0 || index >= _entries.Length)
+            return null;
+        return _entries[index].PrivateKey?.PubKey;
+    }
+
+    public Key? GetPrivateKey(bool isChange, int index)
+    {
+        if (isChange || index < 0 || index >= _entries.Length)
+            return null;
+        return _entries[index].PrivateKey;
+    }
+}

src/Core/Crypto/Slip132.cs

@@ -20,8 +20,8 @@ public static class Slip132
         Encoders.Base58Check.EncodeData([.. profile.ExtKeyHeaders[kind].PrivateBytes(), .. key.ToBytes()]);
 
     /// <summary>
-    /// Riconosce l'header (→ ScriptKind) e decodifica una chiave pubblica estesa:
-    /// è la via dell'import watch-only (§4.4).
+    /// Recognises the header (→ ScriptKind) and decodes an extended public key:
+    /// this is the watch-only import path (§4.4).
     /// </summary>
     public static bool TryDecodePublic(string encoded, ChainProfile profile,
         out ExtPubKey? key, out ScriptKind kind)

src/Core/Net/CertificatePinStore.cs

@@ -5,10 +5,10 @@ using System.Text.Json;
 namespace PalladiumWallet.Core.Net;
 
 /// <summary>
-/// Pinning TLS "trust on first use" (blueprint §9): al primo contatto la
-/// fingerprint SHA-256 del certificato del server viene salvata; ai successivi
-/// viene confrontata. Se cambia, la connessione va rifiutata e l'utente può
-/// sbloccare con un reset esplicito (caso tipico: server self-signed rinnovato).
+/// TLS "trust on first use" pinning (blueprint §9): on the first contact the
+/// server certificate's SHA-256 fingerprint is saved; on subsequent ones it is
+/// compared. If it changes, the connection must be rejected and the user can
+/// unlock with an explicit reset (typical case: renewed self-signed server).
 /// </summary>
 public sealed class CertificatePinStore(string filePath)
 {
@@ -18,8 +18,8 @@ public sealed class CertificatePinStore(string filePath)
         Convert.ToHexString(SHA256.HashData(certificate.GetRawCertData())).ToLowerInvariant();
 
     /// <summary>
-    /// Verifica TOFU: true se il certificato è quello già visto (o se è il primo
-    /// contatto, nel qual caso viene salvato). False = certificato cambiato.
+    /// TOFU check: true if the certificate is the one already seen (or if it is the
+    /// first contact, in which case it is saved). False = certificate changed.
     /// </summary>
     public bool VerifyOrPin(string host, int port, X509Certificate certificate)
     {
@@ -36,7 +36,7 @@ public sealed class CertificatePinStore(string filePath)
         }
     }
 
-    /// <summary>Reset del certificato salvato per un server ("reset certificati SSL", §9).</summary>
+    /// <summary>Reset the saved certificate for a server ("reset SSL certificates", §9).</summary>
     public bool Reset(string host, int port)
     {
         lock (_lock)

src/Core/Net/ElectrumApi.cs

@@ -2,24 +2,24 @@ using System.Text.Json;
 
 namespace PalladiumWallet.Core.Net;
 
-/// <summary>Voce di storico di uno scripthash (blockchain.scripthash.get_history).</summary>
+/// <summary>History entry for a scripthash (blockchain.scripthash.get_history).</summary>
 public readonly record struct HistoryItem(string TxHash, int Height, long FeeSats);
 
-/// <summary>UTXO riportato dal server (blockchain.scripthash.listunspent).</summary>
+/// <summary>UTXO reported by the server (blockchain.scripthash.listunspent).</summary>
 public readonly record struct UnspentItem(string TxHash, int TxPos, long ValueSats, int Height);
 
-/// <summary>Prova di Merkle (blockchain.transaction.get_merkle).</summary>
+/// <summary>Merkle proof (blockchain.transaction.get_merkle).</summary>
 public sealed record MerkleProofResponse(int BlockHeight, int Pos, IReadOnlyList<string> Merkle);
 
-/// <summary>Tip della catena notificato da blockchain.headers.subscribe.</summary>
+/// <summary>Chain tip notified by blockchain.headers.subscribe.</summary>
 public readonly record struct ChainTip(int Height, string HeaderHex);
 
-/// <summary>Peer annunciato da server.peers.subscribe (porte null = non offerte).</summary>
+/// <summary>Peer announced by server.peers.subscribe (null ports = not offered).</summary>
 public sealed record PeerInfo(string Host, int? TcpPort, int? SslPort, string? Version);
 
 /// <summary>
-/// Helper tipizzati sui metodi del protocollo (blueprint §10), sopra il
-/// trasporto JSON-RPC generico di <see cref="ElectrumClient"/>.
+/// Typed helpers over the protocol methods (blueprint §10), on top of the
+/// generic JSON-RPC transport of <see cref="ElectrumClient"/>.
 /// </summary>
 public static class ElectrumApi
 {
@@ -29,7 +29,7 @@ public static class ElectrumApi
         return new ChainTip(r.GetProperty("height").GetInt32(), r.GetProperty("hex").GetString()!);
     }
 
-    /// <summary>Status corrente dello scripthash (null = mai usato).</summary>
+    /// <summary>Current status of the scripthash (null = never used).</summary>
     public static async Task<string?> SubscribeScripthashAsync(this ElectrumClient c, string scripthash,
         CancellationToken ct = default)
     {
@@ -89,7 +89,7 @@ public static class ElectrumApi
         return r.GetString()!;
     }
 
-    /// <summary>Fee stimata in coin/kB per il target dato; -1 se il server non sa stimare.</summary>
+    /// <summary>Estimated fee in coin/kB for the given target; -1 if the server cannot estimate.</summary>
     public static async Task<decimal> EstimateFeeAsync(this ElectrumClient c, int targetBlocks,
         CancellationToken ct = default)
     {
@@ -112,7 +112,7 @@ public static class ElectrumApi
     public static Task PingAsync(this ElectrumClient c, CancellationToken ct = default) =>
         c.RequestAsync("server.ping", ct);
 
-    /// <summary>Peer annunciati dal server (scoperta di altri server, §9).</summary>
+    /// <summary>Peers announced by the server (discovery of other servers, §9).</summary>
     public static async Task<IReadOnlyList<PeerInfo>> GetPeersAsync(this ElectrumClient c,
         CancellationToken ct = default)
     {
@@ -121,9 +121,9 @@ public static class ElectrumApi
     }
 
     /// <summary>
-    /// Parsa la risposta di server.peers.subscribe: lista di
-    /// [ip, hostname, ["v1.4.2", "pN", "tPORTA", "sPORTA", ...]];
-    /// "t"/"s" senza numero = porta di default della rete (risolta dal chiamante).
+    /// Parses the server.peers.subscribe response: a list of
+    /// [ip, hostname, ["v1.4.2", "pN", "tPORT", "sPORT", ...]];
+    /// "t"/"s" without a number = network default port (resolved by the caller).
     /// </summary>
     public static IReadOnlyList<PeerInfo> ParsePeers(JsonElement response)
     {

src/Core/Net/ElectrumClient.cs

@@ -1,15 +1,17 @@
+using System.Buffers;
 using System.Collections.Concurrent;
+using System.IO.Pipelines;
 using System.Net.Security;
 using System.Net.Sockets;
-using System.Text;
 using System.Text.Json;
+using System.Threading.Channels;
 
 namespace PalladiumWallet.Core.Net;
 
 /// <summary>
-/// Client del protocollo del server di indicizzazione (blueprint §10):
-/// JSON-RPC 2.0 newline-delimited su TCP, opzionalmente TLS con pinning TOFU.
-/// Le notifiche (subscription) arrivano sull'evento <see cref="NotificationReceived"/>.
+/// Client for the indexing server protocol (blueprint §10):
+/// newline-delimited JSON-RPC 2.0 over TCP, optionally TLS with TOFU pinning.
+/// Notifications (subscriptions) arrive on the <see cref="NotificationReceived"/> event.
 /// </summary>
 public sealed class ElectrumClient : IAsyncDisposable
 {
@@ -18,10 +20,25 @@ public sealed class ElectrumClient : IAsyncDisposable
 
     private readonly TcpClient _tcp;
     private readonly Stream _stream;
-    private readonly SemaphoreSlim _writeLock = new(1, 1);
     private readonly ConcurrentDictionary<long, TaskCompletionSource<JsonElement>> _pending = new();
     private readonly CancellationTokenSource _cts = new();
     private readonly Task _readLoop;
+    private readonly Task _writeLoop;
+
+    // Single-reader channel: tasks write the payloads without a lock;
+    // the write loop drains everything in a single WriteAsync+FlushAsync —
+    // identical to Electrum's asyncio buffered writer.
+    private readonly Channel<byte[]> _outgoing = Channel.CreateUnbounded<byte[]>(
+        new UnboundedChannelOptions { SingleReader = true, AllowSynchronousContinuations = false });
+
+    // Cap on in-flight requests (not in the write queue, but awaiting a
+    // response from the server). The write loop already batches the send into a
+    // single segment; this gate avoids flooding the server with thousands of
+    // simultaneous requests on large wallets → no bursts of -101/-102 nor
+    // connection drops. Writes still stay pipelined up to this degree.
+    private const int MaxInFlight = 32;
+    private readonly SemaphoreSlim _inFlight = new(MaxInFlight, MaxInFlight);
+
     private long _nextId;
 
     public string Host { get; }
@@ -29,10 +46,7 @@ public sealed class ElectrumClient : IAsyncDisposable
     public bool UseSsl { get; }
     public bool IsConnected => _tcp.Connected && !_cts.IsCancellationRequested;
 
-    /// <summary>(metodo, parametri) per le notifiche di subscription.</summary>
     public event Action<string, JsonElement>? NotificationReceived;
-
-    /// <summary>Scatta quando la connessione cade (errore di lettura o chiusura remota).</summary>
     public event Action<Exception?>? Disconnected;
 
     private ElectrumClient(TcpClient tcp, Stream stream, string host, int port, bool useSsl)
@@ -42,18 +56,14 @@ public sealed class ElectrumClient : IAsyncDisposable
         Host = host;
         Port = port;
         UseSsl = useSsl;
-        _readLoop = Task.Run(ReadLoopAsync);
+        _readLoop  = Task.Run(ReadLoopAsync);
+        _writeLoop = Task.Run(WriteLoopAsync);
     }
 
-    /// <summary>
-    /// Connette al server. Con <paramref name="useSsl"/> la validazione del
-    /// certificato è TOFU tramite <paramref name="pins"/> (§9): primo contatto
-    /// salva, contatti successivi confrontano; mismatch ⇒ <see cref="CertificatePinMismatchException"/>.
-    /// </summary>
     public static async Task<ElectrumClient> ConnectAsync(string host, int port, bool useSsl,
         CertificatePinStore? pins = null, CancellationToken ct = default)
     {
-        var tcp = new TcpClient();
+        var tcp = new TcpClient { NoDelay = true };
         try
         {
             await tcp.ConnectAsync(host, port, ct);
@@ -64,10 +74,7 @@ public sealed class ElectrumClient : IAsyncDisposable
                 var ssl = new SslStream(stream, leaveInnerStreamOpen: false,
                     (_, cert, _, _) =>
                     {
-                        // I server Electrum sono tipicamente self-signed: la
-                        // fiducia è il pin TOFU, non la catena CA (§9).
-                        if (cert is null)
-                            return false;
+                        if (cert is null) return false;
                         pinOk = pins is null || pins.VerifyOrPin(host, port, cert);
                         return pinOk;
                     });
@@ -84,7 +91,6 @@ public sealed class ElectrumClient : IAsyncDisposable
             }
 
             var client = new ElectrumClient(tcp, stream, host, port, useSsl);
-            // Negoziazione obbligatoria prima di ogni altra richiesta.
             await client.RequestAsync("server.version", ct, ClientName, ProtocolVersion);
             return client;
         }
@@ -98,98 +104,184 @@ public sealed class ElectrumClient : IAsyncDisposable
     public async Task<JsonElement> RequestAsync(string method, CancellationToken ct = default,
         params object?[] parameters)
     {
-        var id = Interlocked.Increment(ref _nextId);
-        var tcs = new TaskCompletionSource<JsonElement>(TaskCreationOptions.RunContinuationsAsynchronously);
-        _pending[id] = tcs;
-
-        var payload = JsonSerializer.SerializeToUtf8Bytes(new
-        {
-            jsonrpc = "2.0",
-            id,
-            method,
-            @params = parameters,
-        });
-
-        await _writeLock.WaitAsync(ct);
+        // Gate before going in-flight: beyond MaxInFlight pending requests
+        // we wait for a response to free a slot, instead of flooding the server.
+        await _inFlight.WaitAsync(ct);
         try
         {
-            await _stream.WriteAsync(payload, ct);
-            await _stream.WriteAsync("\n"u8.ToArray(), ct);
-            await _stream.FlushAsync(ct);
+            var id = Interlocked.Increment(ref _nextId);
+            var tcs = new TaskCompletionSource<JsonElement>(TaskCreationOptions.RunContinuationsAsynchronously);
+            _pending[id] = tcs;
+
+            var payload = JsonSerializer.SerializeToUtf8Bytes(new
+            {
+                jsonrpc = "2.0",
+                id,
+                method,
+                @params = parameters,
+            });
+
+            _outgoing.Writer.TryWrite(payload);
+
+            await using var registration = ct.Register(() =>
+            {
+                _pending.TryRemove(id, out _);
+                tcs.TrySetCanceled(ct);
+            });
+            return await tcs.Task;
         }
         finally
         {
-            _writeLock.Release();
+            _inFlight.Release();
         }
-
-        await using var registration = ct.Register(() => tcs.TrySetCanceled(ct));
-        return await tcs.Task;
     }
 
-    private async Task ReadLoopAsync()
+    /// <summary>
+    /// Drain loop: empties the channel into a single buffer → one WriteAsync+FlushAsync
+    /// for all queued messages. When N requests are queued, they are
+    /// transmitted in a single TCP segment instead of N serial flushes.
+    /// </summary>
+    private async Task WriteLoopAsync()
     {
-        Exception? failure = null;
         try
         {
-            using var reader = new StreamReader(_stream, Encoding.UTF8, leaveOpen: true);
-            while (!_cts.IsCancellationRequested)
+            while (await _outgoing.Reader.WaitToReadAsync(_cts.Token))
             {
-                var line = await reader.ReadLineAsync(_cts.Token);
-                if (line is null)
-                    break; // chiusura remota
-                if (string.IsNullOrWhiteSpace(line))
-                    continue;
-
-                using var doc = JsonDocument.Parse(line);
-                var root = doc.RootElement;
-
-                if (root.TryGetProperty("id", out var idEl) && idEl.ValueKind == JsonValueKind.Number)
+                using var ms = new MemoryStream(512);
+                while (_outgoing.Reader.TryRead(out var data))
                 {
-                    if (!_pending.TryRemove(idEl.GetInt64(), out var tcs))
-                        continue;
-                    if (root.TryGetProperty("error", out var error) && error.ValueKind != JsonValueKind.Null)
-                        tcs.TrySetException(new ElectrumServerException(error.ToString()));
-                    else
-                        tcs.TrySetResult(root.GetProperty("result").Clone());
-                }
-                else if (root.TryGetProperty("method", out var methodEl))
-                {
-                    NotificationReceived?.Invoke(
-                        methodEl.GetString()!,
-                        root.GetProperty("params").Clone());
+                    ms.Write(data);
+                    ms.WriteByte((byte)'\n');
                 }
+                await _stream.WriteAsync(ms.GetBuffer().AsMemory(0, (int)ms.Length), _cts.Token);
+                await _stream.FlushAsync(_cts.Token);
             }
         }
         catch (OperationCanceledException) { }
         catch (Exception ex)
+        {
+            foreach (var (_, pending) in _pending)
+                pending.TrySetException(ex);
+        }
+    }
+
+    /// <summary>
+    /// Read loop with PipeReader: pooled buffers, zero per-response allocations
+    /// (no intermediate string), JSON parsing directly from a byte span.
+    /// </summary>
+    private async Task ReadLoopAsync()
+    {
+        Exception? failure = null;
+        var pipe = PipeReader.Create(_stream, new StreamPipeReaderOptions(leaveOpen: true));
+        try
+        {
+            while (true)
+            {
+                ReadResult result;
+                try { result = await pipe.ReadAsync(_cts.Token); }
+                catch (OperationCanceledException) { break; }
+
+                var buffer = result.Buffer;
+                try
+                {
+                    while (TrySliceLine(ref buffer, out var line))
+                        if (!line.IsEmpty)
+                            DispatchLine(line);
+                }
+                finally
+                {
+                    // consumed = everything we have consumed (up to the last \n)
+                    // examined = everything we have looked at (up to the end of the buffer)
+                    pipe.AdvanceTo(buffer.Start, buffer.End);
+                }
+
+                if (result.IsCompleted) break;
+            }
+        }
+        catch (Exception ex)
         {
             failure = ex;
         }
         finally
         {
+            await pipe.CompleteAsync();
             foreach (var (_, tcs) in _pending)
-                tcs.TrySetException(failure ?? new IOException("Connessione al server chiusa."));
+                tcs.TrySetException(failure ?? new IOException("Connection to the server closed."));
             _pending.Clear();
             Disconnected?.Invoke(failure);
         }
     }
 
+    private static bool TrySliceLine(ref ReadOnlySequence<byte> buffer,
+        out ReadOnlySequence<byte> line)
+    {
+        var pos = buffer.PositionOf((byte)'\n');
+        if (pos is null) { line = default; return false; }
+        line   = buffer.Slice(0, pos.Value);
+        buffer = buffer.Slice(buffer.GetPosition(1, pos.Value));
+        return true;
+    }
+
+    private void DispatchLine(ReadOnlySequence<byte> line)
+    {
+        if (line.IsSingleSegment)
+        {
+            DispatchSpan(line.FirstSpan);
+            return;
+        }
+        // Multi-segment (very long response): copy to ArrayPool then parse.
+        var len = (int)line.Length;
+        var buf = ArrayPool<byte>.Shared.Rent(len);
+        try
+        {
+            line.CopyTo(buf);
+            DispatchSpan(buf.AsSpan(0, len));
+        }
+        finally { ArrayPool<byte>.Shared.Return(buf); }
+    }
+
+    private void DispatchSpan(ReadOnlySpan<byte> utf8)
+    {
+        // JsonDocument.Parse via Utf8JsonReader: no intermediate string,
+        // parsing directly from the pooled span.
+        var reader = new Utf8JsonReader(utf8);
+        using var doc = JsonDocument.ParseValue(ref reader);
+        var root = doc.RootElement;
+
+        if (root.TryGetProperty("id", out var idEl) && idEl.ValueKind == JsonValueKind.Number)
+        {
+            if (!_pending.TryRemove(idEl.GetInt64(), out var tcs)) return;
+            if (root.TryGetProperty("error", out var err) && err.ValueKind != JsonValueKind.Null)
+                tcs.TrySetException(new ElectrumServerException(err.ToString()));
+            else
+                tcs.TrySetResult(root.GetProperty("result").Clone());
+        }
+        else if (root.TryGetProperty("method", out var methodEl))
+        {
+            NotificationReceived?.Invoke(
+                methodEl.GetString()!,
+                root.GetProperty("params").Clone());
+        }
+    }
+
     public async ValueTask DisposeAsync()
     {
         await _cts.CancelAsync();
+        _outgoing.Writer.Complete();
         _tcp.Close();
-        try { await _readLoop; } catch { /* in chiusura */ }
+        try { await _readLoop;  } catch { }
+        try { await _writeLoop; } catch { }
         _cts.Dispose();
-        _writeLock.Dispose();
+        _inFlight.Dispose();
     }
 }
 
-/// <summary>Errore restituito dal server (campo "error" della risposta JSON-RPC).</summary>
+/// <summary>Error returned by the server ("error" field of the JSON-RPC response).</summary>
 public sealed class ElectrumServerException(string error) : Exception(error);
 
 /// <summary>
-/// Il certificato del server è cambiato rispetto a quello salvato (TOFU, §9).
-/// Si sblocca con il reset esplicito dei certificati.
+/// The server certificate changed with respect to the saved one (TOFU, §9).
+/// It is unlocked with an explicit reset of the certificates.
 /// </summary>
 public sealed class CertificatePinMismatchException(string host, int port) : Exception(
     $"Il certificato TLS di {host}:{port} è cambiato rispetto a quello salvato. " +

src/Core/Net/ServerRegistry.cs

@@ -3,7 +3,7 @@ using PalladiumWallet.Core.Chain;
 
 namespace PalladiumWallet.Core.Net;
 
-/// <summary>Server di indicizzazione noto (bootstrap o scoperto dai peer).</summary>
+/// <summary>Known indexing server (bootstrap or discovered from peers).</summary>
 public sealed record KnownServer(string Host, int TcpPort, int SslPort, string? Version = null)
 {
     public int PortFor(bool useSsl) => useSsl ? SslPort : TcpPort;
@@ -13,9 +13,9 @@ public sealed record KnownServer(string Host, int TcpPort, int SslPort, string?
 }
 
 /// <summary>
-/// Registro dei server (blueprint §9): parte dai bootstrap del profilo (§3),
-/// si arricchisce con i peer annunciati via server.peers.subscribe e persiste
-/// le scoperte su file per le sessioni successive.
+/// Server registry (blueprint §9): starts from the profile bootstrap list (§3),
+/// is enriched with peers announced via server.peers.subscribe, and persists
+/// discovered servers to file for subsequent sessions.
 /// </summary>
 public sealed class ServerRegistry
 {
@@ -42,7 +42,7 @@ public sealed class ServerRegistry
             }
             catch (JsonException)
             {
-                // File corrotto: si riparte dai soli bootstrap.
+                // Corrupted file: fall back to bootstrap servers only.
             }
         }
     }
@@ -52,15 +52,15 @@ public sealed class ServerRegistry
         get { lock (_lock) return [.. _servers]; }
     }
 
-    /// <summary>Primo server noto: default quando l'utente non ne indica uno.</summary>
+    /// <summary>First known server: default when the user does not specify one.</summary>
     public KnownServer? Default
     {
         get { lock (_lock) return _servers.FirstOrDefault(); }
     }
 
     /// <summary>
-    /// Chiede al server connesso i peer che annuncia e integra i nuovi nel
-    /// registro (porte mancanti → default del profilo). Ritorna quanti sono nuovi.
+    /// Queries the connected server for its announced peers and adds new ones to the
+    /// registry (missing ports fall back to the profile defaults). Returns the count of new entries.
     /// </summary>
     public async Task<int> DiscoverAsync(ElectrumClient client, CancellationToken ct = default)
     {
@@ -95,7 +95,7 @@ public sealed class ServerRegistry
     private void Save()
     {
         Directory.CreateDirectory(Path.GetDirectoryName(_filePath)!);
-        // Si salvano solo gli scoperti: i bootstrap vengono dal profilo.
+        // Only discovered servers are saved; bootstrap servers come from the profile.
         var discovered = _servers
             .Where(s => !_profile.BootstrapServers.Any(b =>
                 string.Equals(b.Host, s.Host, StringComparison.OrdinalIgnoreCase)))

src/Core/Net/UpdateChecker.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace PalladiumWallet.Core.Net;
+
+/// <summary>A GitHub release newer than the running app.</summary>
+public sealed record LatestRelease(string Tag, string HtmlUrl);
+
+/// <summary>
+/// Checks the latest GitHub release for the project against the running app version.
+/// Best-effort only: any network/parse failure or an up-to-date app both resolve to null,
+/// so callers never need to distinguish "no update" from "couldn't check".
+/// </summary>
+public static class UpdateChecker
+{
+    private const string ReleasesApiUrl = "https://api.github.com/repos/davide3011/PalladiumWallet/releases/latest";
+
+    private sealed class GitHubReleaseResponse
+    {
+        [JsonPropertyName("tag_name")]
+        public string? TagName { get; set; }
+
+        [JsonPropertyName("html_url")]
+        public string? HtmlUrl { get; set; }
+    }
+
+    public static async Task<LatestRelease?> CheckAsync(string currentVersion, CancellationToken ct = default)
+    {
+        try
+        {
+            using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
+            http.DefaultRequestHeaders.UserAgent.ParseAdd("PalladiumWallet");
+            using var response = await http.GetAsync(ReleasesApiUrl, ct).ConfigureAwait(false);
+            if (!response.IsSuccessStatusCode) return null;
+
+            var release = await response.Content
+                .ReadFromJsonAsync<GitHubReleaseResponse>(ct)
+                .ConfigureAwait(false);
+            if (release?.TagName is not { Length: > 0 } tag) return null;
+
+            if (!TryParse(tag, out var remote) || !TryParse(currentVersion, out var local))
+                return null;
+            if (remote <= local) return null;
+
+            return new LatestRelease(tag, release.HtmlUrl ?? $"https://github.com/davide3011/PalladiumWallet/releases/tag/{tag}");
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    /// <summary>Parses "v1.2.3" / "1.2.3-beta" style tags into a comparable <see cref="Version"/>.</summary>
+    private static bool TryParse(string raw, out Version version)
+    {
+        var s = raw.Trim();
+        if (s.StartsWith('v') || s.StartsWith('V')) s = s[1..];
+        var dash = s.IndexOf('-');
+        if (dash >= 0) s = s[..dash];
+        return Version.TryParse(s, out version!);
+    }
+}

src/Core/PalladiumWallet.Core.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
   </PropertyGroup>

src/Core/Spv/BlockHeaderInfo.cs

@@ -5,8 +5,8 @@ using PalladiumWallet.Core.Chain;
 namespace PalladiumWallet.Core.Spv;
 
 /// <summary>
-/// Header di blocco parsato dagli 80 byte canonici (blueprint §7.2):
-/// versione, prev_hash, merkle_root, timestamp, bits, nonce.
+/// Block header parsed from the canonical 80 bytes (blueprint §7.2):
+/// version, prev_hash, merkle_root, timestamp, bits, nonce.
 /// </summary>
 public sealed record BlockHeaderInfo(
     int Version, uint256 PrevHash, uint256 MerkleRoot, uint Timestamp, uint Bits, uint Nonce, uint256 Hash)
@@ -18,7 +18,7 @@ public sealed record BlockHeaderInfo(
     public static BlockHeaderInfo Parse(byte[] raw)
     {
         if (raw.Length != Size)
-            throw new ArgumentException($"Header di {raw.Length} byte (attesi {Size}).", nameof(raw));
+            throw new ArgumentException($"Header is {raw.Length} bytes (expected {Size}).", nameof(raw));
 
         return new BlockHeaderInfo(
             Version: BitConverter.ToInt32(raw, 0),
@@ -31,11 +31,10 @@ public sealed record BlockHeaderInfo(
     }
 
     /// <summary>
-    /// Validazione SPV dell'header (§7.2): collegamento al precedente e,
-    /// se il profilo non impone lo skip (catena LWMA), verifica PoW
-    /// hash &lt;= target dai bits. Il controllo di coerenza dei bits col
-    /// retargeting completo richiede la storia: per la catena di riferimento
-    /// è sostituito dai checkpoint (§7.3).
+    /// SPV header validation (§7.2): linkage to the previous header and,
+    /// if the profile does not mandate skip (LWMA chain), PoW verification
+    /// hash &lt;= target from bits. Full bits/retargeting consistency requires
+    /// history — for this chain it is replaced by checkpoints (§7.3).
     /// </summary>
     public bool IsValidChild(uint256 expectedPrevHash, ChainProfile profile)
     {
@@ -47,7 +46,7 @@ public sealed record BlockHeaderInfo(
         return Hash <= target;
     }
 
-    /// <summary>Confronto con un checkpoint hardcoded (§7.3).</summary>
+    /// <summary>Comparison against a hardcoded checkpoint (§7.3).</summary>
     public bool MatchesCheckpoint(Checkpoint checkpoint) =>
         Hash == uint256.Parse(checkpoint.BlockHash);
 }

src/Core/Spv/Scripthash.cs

@@ -4,8 +4,8 @@ using NBitcoin;
 namespace PalladiumWallet.Core.Spv;
 
 /// <summary>
-/// Scripthash del protocollo di indicizzazione (blueprint §0/§10): SHA-256
-/// dello scriptPubKey con i byte in ordine inverso, esadecimale.
+/// Script hash for the indexing protocol (blueprint §0/§10): SHA-256 of the
+/// scriptPubKey with bytes reversed, encoded as lowercase hex.
 /// </summary>
 public static class Scripthash
 {

src/Core/Spv/WalletSynchronizer.cs

@@ -1,24 +1,34 @@
+using System.Collections.Concurrent;
+using System.Threading;
 using NBitcoin;
 using PalladiumWallet.Core.Chain;
 using PalladiumWallet.Core.Crypto;
 using PalladiumWallet.Core.Net;
 using PalladiumWallet.Core.Storage;
+using PalladiumWallet.Core.Wallet;
 
 namespace PalladiumWallet.Core.Spv;
 
-/// <summary>Indirizzo derivato e tracciato durante la sincronizzazione.</summary>
+/// <summary>Address derived and tracked during synchronisation.</summary>
 public sealed record TrackedAddress(
     BitcoinAddress Address, string ScriptHash, bool IsChange, int Index)
 {
     public Script ScriptPubKey => Address.ScriptPubKey;
 }
 
-/// <summary>Esito di una passata di sincronizzazione.</summary>
+/// <summary>Result of a synchronisation pass.</summary>
 public sealed class SyncResult
 {
     public required int TipHeight { get; init; }
     public required long ConfirmedSats { get; init; }
     public required long UnconfirmedSats { get; init; }
+
+    /// <summary>
+    /// Confirmed but not yet spendable: coinbase outputs below maturity or regular
+    /// outputs below <see cref="Chain.ChainProfile.MinConfirmations"/>. Subset of
+    /// <see cref="ConfirmedSats"/>.
+    /// </summary>
+    public required long ImmatureSats { get; init; }
     public required int NextReceiveIndex { get; init; }
     public required int NextChangeIndex { get; init; }
     public required IReadOnlyList<CachedTx> History { get; init; }
@@ -29,82 +39,175 @@ public sealed class SyncResult
 }
 
 /// <summary>
-/// Sincronizzazione del wallet (blueprint §7.4): per ogni indirizzo calcola lo
-/// scripthash e si sottoscrive; scarica storico e transazioni; verifica ogni tx
-/// confermata con la prova di Merkle contro l'header del suo blocco (le risposte
-/// del server non sono fidate, §17); ricostruisce localmente UTXO e saldo;
-/// estende la scansione fino al gap limit (§5).
+/// Wallet synchronisation (blueprint §7.4).
 /// </summary>
-public sealed class WalletSynchronizer(HdAccount account, ElectrumClient client, int gapLimit = 20)
+public sealed class WalletSynchronizer(IWalletAccount account, ElectrumClient client, int gapLimit = 20)
 {
-    /// <summary>Avanzamento leggibile (per CLI e barra di stato GUI).</summary>
+    /// <summary>Human-readable progress (for CLI and GUI status bar).</summary>
     public event Action<string>? Progress;
 
-    // Cache tra le passate (stesso synchronizer per tutta la vita della
-    // connessione): le tx già scaricate e le prove di Merkle già verificate a
-    // una data altezza non si rifanno — le risincronizzazioni da notifica
-    // costano solo ciò che è cambiato (modello Electrum).
-    private readonly Dictionary<string, Transaction> _txCache = [];
+    private readonly ConcurrentDictionary<string, Transaction> _txCache = new();
     private readonly Dictionary<string, int> _verifiedAtHeight = [];
+    private readonly ConcurrentDictionary<int, Task<string>> _headerFetches = new();
+
+    // Indices known from the previous sync: used by ScanChainAsync for incremental
+    // discovery — already-used addresses are fetched in a single burst instead of
+    // sequential batches, reducing round-trips from O(used/gapLimit) to O(1).
+    private int _knownReceiveIndex;
+    private int _knownChangeIndex;
+
+    /// <summary>
+    /// Pre-populates internal caches from data saved on disk.
+    /// Call before SyncOnceAsync to avoid re-downloading already known transactions.
+    /// </summary>
+    public void PreloadCaches(
+        Dictionary<string, string> rawTxHex,
+        Dictionary<string, int> verifiedAt,
+        Dictionary<int, string>? blockHeaders,
+        int knownReceiveIndex,
+        int knownChangeIndex,
+        Network network)
+    {
+        foreach (var (txid, hex) in rawTxHex)
+            _txCache.TryAdd(txid, Transaction.Parse(hex, network));
+        foreach (var (txid, height) in verifiedAt)
+            if (!_verifiedAtHeight.ContainsKey(txid))
+                _verifiedAtHeight[txid] = height;
+        if (blockHeaders is not null)
+            foreach (var (height, hex) in blockHeaders)
+                _headerFetches.TryAdd(height, Task.FromResult(hex));
+        _knownReceiveIndex = knownReceiveIndex;
+        _knownChangeIndex  = knownChangeIndex;
+    }
+
+    /// <summary>
+    /// Exports the current caches in a serialisable form for disk storage.
+    /// Only confirmed transactions (height > 0) are included: unconfirmed ones
+    /// may change (RBF) and must always be re-downloaded.
+    /// </summary>
+    public (Dictionary<string, string> RawTxHex,
+            Dictionary<string, int> VerifiedAt,
+            Dictionary<int, string> BlockHeaders)
+        ExportCaches(Network network)
+    {
+        var rawHex = _verifiedAtHeight.Keys
+            .Where(_txCache.ContainsKey)
+            .ToDictionary(txid => txid, txid => _txCache[txid].ToHex());
+
+        // Only already-completed headers: in-progress Task<string> instances
+        // are not persisted (they will be re-fetched on the next sync if needed).
+        var headers = new Dictionary<int, string>();
+        foreach (var (height, task) in _headerFetches)
+            if (task.IsCompletedSuccessfully)
+                headers[height] = task.Result;
+
+        return (rawHex, new Dictionary<string, int>(_verifiedAtHeight), headers);
+    }
 
     public async Task<SyncResult> SyncOnceAsync(CancellationToken ct = default)
     {
         var tip = await client.SubscribeHeadersAsync(ct);
-        Progress?.Invoke($"tip della catena: {tip.Height}");
+        Progress?.Invoke($"chain tip: {tip.Height}");
 
-        // 1-2. Scansione indirizzi con gap limit, per catena receiving e change.
+        // 1-2. Address scanning.
         var tracked = new List<TrackedAddress>();
         var historyByAddress = new Dictionary<string, IReadOnlyList<HistoryItem>>();
-        var nextReceive = await ScanChainAsync(isChange: false, tracked, historyByAddress, ct);
-        var nextChange = await ScanChainAsync(isChange: true, tracked, historyByAddress, ct);
+        int nextReceive, nextChange;
 
-        // 3. Storico unico (txid → altezza massima riportata).
+        if (account.FixedAddresses is { } fixedAddresses)
+        {
+            foreach (var (addr, isChange, idx) in fixedAddresses)
+                tracked.Add(new TrackedAddress(addr, Scripthash.FromAddress(addr), isChange, idx));
+            nextReceive = tracked.Count(t => !t.IsChange);
+            nextChange  = 0;
+
+            await Task.WhenAll(tracked.Select(t => RetryOnBusyAsync(async () =>
+            {
+                var h = await client.GetHistoryAsync(t.ScriptHash, ct);
+                if (h.Count > 0) historyByAddress[t.ScriptHash] = h;
+            }, ct)).Concat(tracked.Select(t =>
+                RetryOnBusyAsync(() => client.SubscribeScripthashAsync(t.ScriptHash, ct), ct))));
+        }
+        else
+        {
+            // Receive and change chains in parallel (independent by definition).
+            // ScanChainAsync uses _knownReceiveIndex/_knownChangeIndex for incremental
+            // discovery: already-used addresses are fetched in a single burst.
+            var receiveTask = ScanChainAsync(isChange: false, _knownReceiveIndex, ct);
+            var changeTask  = ScanChainAsync(isChange: true,  _knownChangeIndex,  ct);
+            var rxScan = await receiveTask;
+            var chScan = await changeTask;
+
+            tracked.AddRange(rxScan.Tracked);
+            tracked.AddRange(chScan.Tracked);
+            foreach (var (k, v) in rxScan.History) historyByAddress[k] = v;
+            foreach (var (k, v) in chScan.History) historyByAddress[k] = v;
+            nextReceive = rxScan.NextIndex;
+            nextChange  = chScan.NextIndex;
+
+            var gapAddresses = tracked.Where(t =>
+                (!t.IsChange && t.Index >= nextReceive && t.Index < nextReceive + gapLimit) ||
+                ( t.IsChange && t.Index >= nextChange  && t.Index < nextChange  + gapLimit)).ToList();
+            if (gapAddresses.Count > 0)
+                await Task.WhenAll(gapAddresses.Select(t =>
+                    RetryOnBusyAsync(() => client.SubscribeScripthashAsync(t.ScriptHash, ct), ct)));
+        }
+
+        // 3. Merged history (txid → highest reported height).
         var txHeights = new Dictionary<string, int>();
         foreach (var item in historyByAddress.Values.SelectMany(h => h))
             txHeights[item.TxHash] = item.Height;
 
-        // 4. Scarica in parallelo le sole transazioni nuove.
-        var network = PalladiumNetworks.For(account.Profile.Kind);
-        var missing = txHeights.Keys.Where(txid => !_txCache.ContainsKey(txid)).ToList();
-        if (missing.Count > 0)
-        {
-            Progress?.Invoke($"scarico {missing.Count} transazioni…");
-            var downloaded = await Task.WhenAll(missing.Select(async txid =>
-                (txid, Transaction.Parse(await client.GetTransactionAsync(txid, ct), network))));
-            foreach (var (txid, tx) in downloaded)
-                _txCache[txid] = tx;
-        }
-        var transactions = txHeights.Keys.ToDictionary(txid => txid, txid => _txCache[txid]);
-
-        // 5. Verifica Merkle delle confermate (§7.4 punto 4), in parallelo e
-        //    solo per le tx non ancora verificate a quell'altezza.
+        // 4+5. Download missing transactions and verify Merkle proofs in parallel.
+        var network  = PalladiumNetworks.For(account.Profile.Kind);
+        var missing  = txHeights.Keys.Where(txid => !_txCache.ContainsKey(txid)).ToList();
         var toVerify = txHeights
             .Where(kv => kv.Value > 0
                 && (!_verifiedAtHeight.TryGetValue(kv.Key, out var h) || h != kv.Value))
             .ToList();
-        if (toVerify.Count > 0)
+
+        if (missing.Count > 0 || toVerify.Count > 0)
         {
-            Progress?.Invoke($"verifico {toVerify.Count} prove di Merkle…");
-            await Task.WhenAll(toVerify.Select(async kv =>
+            Progress?.Invoke($"downloading {missing.Count} txs, verifying {toVerify.Count} proofs…");
+            var dlDone   = 0;
+            var merkDone = 0;
+
+            var dlTasks = missing.Select(txid => RetryOnBusyAsync(async () =>
+            {
+                var raw = await client.GetTransactionAsync(txid, ct);
+                _txCache[txid] = Transaction.Parse(raw, network);
+                var n = Interlocked.Increment(ref dlDone);
+                if (n % 50 == 0 || n == missing.Count)
+                    Progress?.Invoke($"tx {n}/{missing.Count}, proofs {merkDone}/{toVerify.Count}…");
+            }, ct));
+
+            var merkTasks = toVerify.Select(kv => RetryOnBusyAsync(async () =>
             {
                 var (txid, height) = kv;
-                var proofTask = client.GetMerkleAsync(txid, height, ct);
-                var headerTask = client.GetBlockHeaderAsync(height, ct);
-                var proof = await proofTask;
+                var proofTask  = client.GetMerkleAsync(txid, height, ct);
+                var headerTask = _headerFetches.GetOrAdd(height,
+                    h => client.GetBlockHeaderAsync(h, ct));
+                var proof  = await proofTask;
                 var header = BlockHeaderInfo.Parse(await headerTask);
                 if (!MerkleProof.Verify(
                         uint256.Parse(txid), proof.Pos,
                         proof.Merkle.Select(uint256.Parse), header.MerkleRoot))
                     throw new SpvVerificationException(
-                        $"Prova di Merkle non valida per {txid} (blocco {height}): server non affidabile.");
-            }));
+                        $"Invalid Merkle proof for {txid} (block {height}): server is not trustworthy.");
+                var n = Interlocked.Increment(ref merkDone);
+                if (n % 50 == 0 || n == toVerify.Count)
+                    Progress?.Invoke($"tx {dlDone}/{missing.Count}, proofs {n}/{toVerify.Count}…");
+            }, ct));
+
+            await Task.WhenAll(dlTasks.Concat(merkTasks));
             foreach (var (txid, height) in toVerify)
                 _verifiedAtHeight[txid] = height;
         }
-        var verified = txHeights.ToDictionary(kv => kv.Key, kv => kv.Value > 0);
 
-        // 6. Ricostruzione locale degli UTXO: accrediti = output verso nostri
-        //    script; spesi = outpoint consumati da una qualunque tx del wallet.
+        var transactions = txHeights.Keys.ToDictionary(txid => txid, txid => _txCache[txid]);
+        var verified     = txHeights.ToDictionary(kv => kv.Key, kv => kv.Value > 0);
+
+        // 6. Local UTXO reconstruction.
         var byScript = tracked.ToDictionary(t => t.ScriptPubKey, t => t);
         var spent = transactions.Values
             .SelectMany(tx => tx.Inputs)
@@ -123,18 +226,19 @@ public sealed class WalletSynchronizer(HdAccount account, ElectrumClient client,
                     continue;
                 utxos.Add(new CachedUtxo
                 {
-                    Txid = txid,
-                    Vout = vout,
-                    ValueSats = output.Value.Satoshi,
-                    Address = addr.Address.ToString(),
-                    IsChange = addr.IsChange,
-                    AddressIndex = addr.Index,
-                    Height = txHeights[txid],
+                    Txid          = txid,
+                    Vout          = vout,
+                    ValueSats     = output.Value.Satoshi,
+                    Address       = addr.Address.ToString(),
+                    IsChange      = addr.IsChange,
+                    AddressIndex  = addr.Index,
+                    Height        = txHeights[txid],
+                    IsCoinbase    = tx.IsCoinBase,
                 });
             }
         }
 
-        // 7. Delta per voce di storico (entrate - uscite del wallet).
+        // 7. Delta per history entry.
         var history = new List<CachedTx>();
         foreach (var (txid, tx) in transactions)
         {
@@ -147,21 +251,19 @@ public sealed class WalletSynchronizer(HdAccount account, ElectrumClient client,
                 .Sum(i => transactions[i.PrevOut.Hash.ToString()].Outputs[i.PrevOut.N].Value.Satoshi);
             history.Add(new CachedTx
             {
-                Txid = txid,
-                Height = txHeights[txid],
+                Txid      = txid,
+                Height    = txHeights[txid],
                 DeltaSats = received - sentSats,
-                Verified = verified[txid],
+                Verified  = verified[txid],
             });
         }
         history.Sort((a, b) =>
         {
-            // Non confermate (height<=0) in cima, poi per altezza decrescente.
             var ha = a.Height <= 0 ? int.MaxValue : a.Height;
             var hb = b.Height <= 0 ? int.MaxValue : b.Height;
             return hb.CompareTo(ha);
         });
 
-        // Saldo e numero di transazioni per singolo indirizzo (vista indirizzi).
         var balanceByAddress = utxos
             .GroupBy(u => u.Address)
             .ToDictionary(g => g.Key, g => g.Sum(u => u.ValueSats));
@@ -169,64 +271,90 @@ public sealed class WalletSynchronizer(HdAccount account, ElectrumClient client,
             .OrderBy(t => t.IsChange).ThenBy(t => t.Index)
             .Select(t => new CachedAddress
             {
-                Address = t.Address.ToString(),
-                IsChange = t.IsChange,
-                Index = t.Index,
-                BalanceSats = balanceByAddress.GetValueOrDefault(t.Address.ToString()),
-                TxCount = historyByAddress.TryGetValue(t.ScriptHash, out var h) ? h.Count : 0,
+                Address      = t.Address.ToString(),
+                IsChange     = t.IsChange,
+                Index        = t.Index,
+                BalanceSats  = balanceByAddress.GetValueOrDefault(t.Address.ToString()),
+                TxCount      = historyByAddress.TryGetValue(t.ScriptHash, out var h) ? h.Count : 0,
             })
             .ToList();
 
         return new SyncResult
         {
-            TipHeight = tip.Height,
-            ConfirmedSats = utxos.Where(u => u.Height > 0).Sum(u => u.ValueSats),
-            UnconfirmedSats = utxos.Where(u => u.Height <= 0).Sum(u => u.ValueSats),
+            TipHeight        = tip.Height,
+            ConfirmedSats    = utxos.Where(u => u.Height > 0).Sum(u => u.ValueSats),
+            UnconfirmedSats  = utxos.Where(u => u.Height <= 0).Sum(u => u.ValueSats),
+            ImmatureSats     = utxos.Where(u =>
+                u.Height > 0 && u.Confirmations(tip.Height) < u.RequiredConfirmations(account.Profile))
+                .Sum(u => u.ValueSats),
             NextReceiveIndex = nextReceive,
-            NextChangeIndex = nextChange,
-            History = history,
-            Utxos = utxos,
-            Addresses = tracked,
-            AddressRows = addressRows,
-            Transactions = transactions,
+            NextChangeIndex  = nextChange,
+            History          = history,
+            Utxos            = utxos,
+            Addresses        = tracked,
+            AddressRows      = addressRows,
+            Transactions     = transactions,
         };
     }
 
     /// <summary>
-    /// Scansiona una catena (receiving o change) finché trova gapLimit indirizzi
-    /// vuoti consecutivi (§5), procedendo a batch paralleli di gapLimit
-    /// subscribe per volta (le richieste JSON-RPC sono pipelinabili).
-    /// Ritorna il primo indice non usato.
+    /// Scans one chain (receiving or change).
+    ///
+    /// Phase 1 — known addresses (0..fromIndex-1): all GetHistoryAsync calls are
+    /// fired in a single parallel burst, with no sequential batching. A wallet
+    /// with 100 used addresses costs 1 RTT instead of 5 sequential gap-limit rounds.
+    ///
+    /// Phase 2 — discovery from fromIndex onwards: gap-limit batching as before,
+    /// required to know when to stop.
     /// </summary>
-    private async Task<int> ScanChainAsync(bool isChange, List<TrackedAddress> tracked,
-        Dictionary<string, IReadOnlyList<HistoryItem>> historyByAddress, CancellationToken ct)
+    private async Task<(int NextIndex,
+                         List<TrackedAddress> Tracked,
+                         Dictionary<string, IReadOnlyList<HistoryItem>> History)>
+        ScanChainAsync(bool isChange, int fromIndex, CancellationToken ct)
     {
+        var tracked = new List<TrackedAddress>();
+        var history = new Dictionary<string, IReadOnlyList<HistoryItem>>();
+
+        // Phase 1: single burst for all already-known addresses.
+        if (fromIndex > 0)
+        {
+            var known = Enumerable.Range(0, fromIndex).Select(i =>
+            {
+                var addr = account.GetAddress(isChange, i);
+                return new TrackedAddress(addr, Scripthash.FromAddress(addr), isChange, i);
+            }).ToList();
+            tracked.AddRange(known);
+
+            var knownHistories = await Task.WhenAll(
+                known.Select(t => RetryOnBusyAsync(
+                    () => client.GetHistoryAsync(t.ScriptHash, ct), ct)));
+            for (var i = 0; i < known.Count; i++)
+                if (knownHistories[i].Count > 0)
+                    history[known[i].ScriptHash] = knownHistories[i];
+        }
+
+        // Phase 2: gap-limit discovery from fromIndex onwards.
         var consecutiveEmpty = 0;
-        var index = 0;
-        var firstUnused = 0;
+        var index      = fromIndex;
+        var firstUnused = fromIndex;
+
         while (consecutiveEmpty < gapLimit)
         {
             var batch = Enumerable.Range(index, gapLimit).Select(i =>
             {
-                var address = account.GetAddress(isChange, i);
-                return new TrackedAddress(address, Scripthash.FromAddress(address), isChange, i);
+                var addr = account.GetAddress(isChange, i);
+                return new TrackedAddress(addr, Scripthash.FromAddress(addr), isChange, i);
             }).ToList();
             index += batch.Count;
             tracked.AddRange(batch);
 
-            // La subscribe registra anche la notifica push per i cambi futuri.
-            var statuses = await Task.WhenAll(
-                batch.Select(t => client.SubscribeScripthashAsync(t.ScriptHash, ct)));
-
-            var used = batch.Where((t, i) => statuses[i] is not null).ToList();
             var histories = await Task.WhenAll(
-                used.Select(t => client.GetHistoryAsync(t.ScriptHash, ct)));
-            for (var i = 0; i < used.Count; i++)
-                historyByAddress[used[i].ScriptHash] = histories[i];
+                batch.Select(t => RetryOnBusyAsync(
+                    () => client.GetHistoryAsync(t.ScriptHash, ct), ct)));
 
             for (var i = 0; i < batch.Count && consecutiveEmpty < gapLimit; i++)
             {
-                if (statuses[i] is null)
+                if (histories[i].Count == 0)
                 {
                     consecutiveEmpty++;
                 }
@@ -234,12 +362,50 @@ public sealed class WalletSynchronizer(HdAccount account, ElectrumClient client,
                 {
                     consecutiveEmpty = 0;
                     firstUnused = batch[i].Index + 1;
+                    history[batch[i].ScriptHash] = histories[i];
                 }
             }
         }
-        return firstUnused;
+
+        return (firstUnused, tracked, history);
     }
+
+    private static async Task RetryOnBusyAsync(Func<Task> op, CancellationToken ct)
+    {
+        var delay = 200;
+        for (var attempt = 0; ; attempt++)
+        {
+            try   { await op(); return; }
+            catch (ElectrumServerException ex)
+                when (IsBusy(ex) && attempt < 7)
+            {
+                await Task.Delay(delay, ct);
+                delay = Math.Min(delay * 2, 5_000);
+            }
+        }
+    }
+
+    private static async Task<T> RetryOnBusyAsync<T>(Func<Task<T>> op, CancellationToken ct)
+    {
+        var delay = 200;
+        for (var attempt = 0; ; attempt++)
+        {
+            try   { return await op(); }
+            catch (ElectrumServerException ex)
+                when (IsBusy(ex) && attempt < 7)
+            {
+                await Task.Delay(delay, ct);
+                delay = Math.Min(delay * 2, 5_000);
+            }
+        }
+    }
+
+    private static bool IsBusy(ElectrumServerException ex) =>
+        ex.Message.Contains("-102") ||
+        ex.Message.Contains("-101") ||
+        ex.Message.Contains("server busy", StringComparison.OrdinalIgnoreCase) ||
+        ex.Message.Contains("excessive resource usage", StringComparison.OrdinalIgnoreCase);
 }
 
-/// <summary>La verifica SPV è fallita: i dati del server contraddicono le prove (§17).</summary>
+/// <summary>SPV verification failed: server data contradicts the proofs (§17).</summary>
 public sealed class SpvVerificationException(string message) : Exception(message);

src/Core/Storage/AppConfig.cs

@@ -3,18 +3,23 @@ using System.Text.Json;
 namespace PalladiumWallet.Core.Storage;
 
 /// <summary>
-/// Configurazione globale dell'applicazione (blueprint §8), separata dai file
-/// wallet: lingua, unità di visualizzazione, ecc. Persistita in config.json
-/// nella radice dei dati (vale per tutte le reti).
+/// Global application configuration (blueprint §8), separate from wallet
+/// files: language, display unit, etc. Persisted in config.json
+/// in the data root (applies to all networks).
 /// </summary>
 public sealed class AppConfig
 {
-    /// <summary>Codice lingua UI.</summary>
+    /// <summary>UI language code.</summary>
     public string Language { get; set; } = "en";
 
-    /// <summary>Unità di visualizzazione degli importi (vedi <see cref="Wallet.CoinAmount.Units"/>).</summary>
+    /// <summary>Display unit for amounts (see <see cref="Wallet.CoinAmount.Units"/>).</summary>
     public string Unit { get; set; } = "PLM";
 
+    /// <summary>Last successfully connected server, persisted across sessions.</summary>
+    public string? LastServerHost { get; set; }
+    public int? LastServerPort { get; set; }
+    public bool LastServerUseSsl { get; set; } = true;
+
     private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };
 
     public static AppConfig Load(string? path = null)
@@ -28,7 +33,7 @@ public sealed class AppConfig
         }
         catch (JsonException)
         {
-            // Config corrotta: si riparte dai default senza bloccare l'avvio.
+            // Corrupted config: fall back to defaults without blocking startup.
             return new AppConfig();
         }
     }

src/Core/Storage/AppPaths.cs

@@ -3,29 +3,29 @@ using PalladiumWallet.Core.Chain;
 namespace PalladiumWallet.Core.Storage;
 
 /// <summary>
-/// Percorsi dati per piattaforma (blueprint §8). La radice dati può essere:
-/// 1. <b>portable</b>: cartella "palladium-data" accanto all'eseguibile;
-/// 2. <b>personalizzata</b>: scelta dall'utente al primo avvio e memorizzata in
-///    un piccolo file "puntatore" in una posizione di bootstrap fissa;
-/// 3. <b>legacy</b>: vecchia posizione (%APPDATA%/PalladiumWallet) se contiene già dati;
-/// 4. <b>default</b>: ~/.PalladiumWallet (Linux/macOS) o %ProgramFiles%\PalladiumWallet (Windows).
-/// Sotto la radice c'è una sottocartella per rete (config, wallet, header, certificati).
+/// Per-platform data paths (blueprint §8). The data root can be:
+/// 1. <b>portable</b>: "palladium-data" folder next to the executable;
+/// 2. <b>custom</b>: chosen by the user at first launch and stored in
+///    a small "pointer" file at a fixed bootstrap location;
+/// 3. <b>legacy</b>: old location (%APPDATA%/PalladiumWallet) if it already holds data;
+/// 4. <b>default</b>: ~/.PalladiumWallet (Linux/macOS) or %ProgramFiles%\PalladiumWallet (Windows).
+/// Under the root there is a per-network subfolder (config, wallet, header, certificates).
 /// </summary>
 public static class AppPaths
 {
     public const string PortableDirName = "palladium-data";
 
-    /// <summary>Nome cartella applicazione, usato nei vari percorsi.</summary>
+    /// <summary>Application folder name, used in the various paths.</summary>
     public const string AppDirName = "PalladiumWallet";
 
-    /// <summary>Override esplicito della radice dati (es. CLI --data-dir). Ha priorità su tutto.</summary>
+    /// <summary>Explicit override of the data root (e.g. CLI --data-dir). Takes priority over everything.</summary>
     public static string? OverrideDataRoot { get; set; }
 
     /// <summary>
-    /// Radice dati predefinita, secondo la convenzione di ogni piattaforma:
-    /// Windows → %APPDATA%\PalladiumWallet (PascalCase, come Electrum/Bitcoin);
-    /// Linux/macOS → ~/.palladium-wallet (dotfolder minuscolo, come ~/.bitcoin).
-    /// Per-utente e sempre scrivibile, senza privilegi di amministratore.
+    /// Default data root, following each platform's convention:
+    /// Windows → %APPDATA%\PalladiumWallet (PascalCase, like Electrum/Bitcoin);
+    /// Linux/macOS → ~/.palladium-wallet (lowercase dotfolder, like ~/.bitcoin).
+    /// Per-user and always writable, without administrator privileges.
     /// </summary>
     public static string DefaultDataRoot()
     {
@@ -37,8 +37,8 @@ public static class AppPaths
         return Path.Combine(home, ".palladium-wallet");
     }
 
-    /// <summary>File puntatore alla radice dati scelta dall'utente. Vive in una
-    /// posizione di bootstrap sempre scrivibile e indipendente dalla radice dati.</summary>
+    /// <summary>Pointer file to the user-chosen data root. Lives at a
+    /// bootstrap location that is always writable and independent of the data root.</summary>
     private static string LocationPointerPath() =>
         Path.Combine(
             Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
@@ -50,7 +50,7 @@ public static class AppPaths
     private static bool HasData(string root) =>
         Directory.Exists(root) && Directory.EnumerateFileSystemEntries(root).Any();
 
-    /// <summary>Radice dati effettiva, secondo l'ordine di precedenza documentato in classe.</summary>
+    /// <summary>Effective data root, following the precedence order documented on the class.</summary>
     public static string DataRoot()
     {
         if (!string.IsNullOrEmpty(OverrideDataRoot))
@@ -67,9 +67,9 @@ public static class AppPaths
     }
 
     /// <summary>
-    /// true se la posizione dei dati è già determinata e non serve chiederla
-    /// all'utente: modalità portable, override, puntatore già scritto, oppure
-    /// dati già presenti nella posizione predefinita.
+    /// true if the data location is already determined and need not be asked
+    /// of the user: portable mode, override, pointer already written, or
+    /// data already present at the default location.
     /// </summary>
     public static bool IsDataLocationConfigured() =>
         !string.IsNullOrEmpty(OverrideDataRoot)
@@ -77,7 +77,7 @@ public static class AppPaths
         || ReadPointer() is not null
         || HasData(DefaultDataRoot());
 
-    /// <summary>Memorizza la radice dati scelta dall'utente e la crea su disco.</summary>
+    /// <summary>Stores the user-chosen data root and creates it on disk.</summary>
     public static void ConfigureDataLocation(string root)
     {
         root = Path.GetFullPath(root.Trim());
@@ -96,7 +96,7 @@ public static class AppPaths
         return string.IsNullOrEmpty(path) ? null : path;
     }
 
-    /// <summary>Cartella dati della rete (config, wallet, header, certificati).</summary>
+    /// <summary>Network data folder (config, wallet, header, certificates).</summary>
     public static string ForNetwork(NetKind net)
     {
         var dir = Path.Combine(DataRoot(), ChainProfiles.For(net).NetName);
@@ -114,7 +114,7 @@ public static class AppPaths
     public static string DefaultWalletPath(NetKind net) =>
         Path.Combine(WalletsDir(net), "default.wallet.json");
 
-    /// <summary>Tutti i file wallet della rete, ordinati per nome (multi-wallet §8).</summary>
+    /// <summary>All wallet files for the network, ordered by name (multi-wallet §8).</summary>
     public static IReadOnlyList<string> WalletFiles(NetKind net)
     {
         var dir = WalletsDir(net);

src/Core/Storage/EncryptedFile.cs

@@ -5,9 +5,9 @@ using System.Text.Json;
 namespace PalladiumWallet.Core.Storage;
 
 /// <summary>
-/// Cifratura del file wallet (blueprint §8/§17): AES-256-GCM con chiave derivata
-/// dalla password via PBKDF2-HMAC-SHA512. Il contenitore è JSON autodescrittivo
-/// (kdf, parametri, salt, nonce) per consentire upgrade futuri dei parametri.
+/// Wallet file encryption (blueprint §8/§17): AES-256-GCM with a key derived
+/// from the password via PBKDF2-HMAC-SHA512. The container is self-describing JSON
+/// (kdf, parameters, salt, nonce) to allow future parameter upgrades.
 /// </summary>
 public static class EncryptedFile
 {
@@ -54,7 +54,7 @@ public static class EncryptedFile
             Convert.ToBase64String(tag), Convert.ToBase64String(cipher)));
     }
 
-    /// <summary>Lancia <see cref="WrongPasswordException"/> se la password è errata o il file è manomesso.</summary>
+    /// <summary>Throws <see cref="WrongPasswordException"/> if the password is wrong or the file is tampered with.</summary>
     public static string Decrypt(string fileContent, string password)
     {
         var container = JsonSerializer.Deserialize<Container>(fileContent)
@@ -74,7 +74,7 @@ public static class EncryptedFile
         }
         catch (AuthenticationTagMismatchException)
         {
-            // Il tag GCM autentica: password errata e manomissione sono indistinguibili.
+            // The GCM tag authenticates: a wrong password and tampering are indistinguishable.
             throw new WrongPasswordException();
         }
         finally
@@ -88,7 +88,7 @@ public static class EncryptedFile
         Rfc2898DeriveBytes.Pbkdf2(password, salt, iterations, HashAlgorithmName.SHA512, KeySize);
 }
 
-/// <summary>Password errata (o file wallet manomesso: il tag GCM non distingue i due casi).</summary>
+/// <summary>Wrong password (or tampered wallet file: the GCM tag does not distinguish the two cases).</summary>
 public sealed class WrongPasswordException : Exception
 {
     public WrongPasswordException() : base("Password errata o file wallet danneggiato.") { }

src/Core/Storage/WalletDocument.cs

@@ -4,9 +4,9 @@ using System.Text.Json.Serialization;
 namespace PalladiumWallet.Core.Storage;
 
 /// <summary>
-/// Schema del file wallet (blueprint §8), versionato per consentire migrazioni
-/// automatiche all'apertura. La cifratura (quando c'è una password) avvolge
-/// l'intero documento via <see cref="EncryptedFile"/>.
+/// Wallet file schema (blueprint §8), versioned to allow automatic
+/// migrations on opening. Encryption (when there is a password) wraps
+/// the entire document via <see cref="EncryptedFile"/>.
 /// </summary>
 public sealed class WalletDocument
 {
@@ -14,39 +14,48 @@ public sealed class WalletDocument
 
     public int Version { get; set; } = CurrentVersion;
 
-    /// <summary>Nome rete (mainnet/testnet/regtest), come ChainProfile.NetName.</summary>
+    /// <summary>Network name (mainnet/testnet/regtest), as ChainProfile.NetName.</summary>
     public required string Network { get; set; }
 
-    /// <summary>Tipo di script (nome dell'enum ScriptKind).</summary>
+    /// <summary>Script type (name of the ScriptKind enum).</summary>
     public required string ScriptKind { get; set; }
 
-    /// <summary>Mnemonica BIP39 in chiaro nel documento (il documento va cifrato!); null se watch-only.</summary>
+    /// <summary>BIP39 mnemonic in plaintext in the document (the document must be encrypted!); null if watch-only.</summary>
     public string? Mnemonic { get; set; }
 
-    /// <summary>Extension word BIP39 (§4.1); null se assente.</summary>
+    /// <summary>BIP39 extension word (§4.1); null if absent.</summary>
     public string? Passphrase { get; set; }
 
-    /// <summary>Path di account (es. "84'/746'/0'").</summary>
-    public required string AccountPath { get; set; }
+    /// <summary>Account path (e.g. "84'/746'/0'"); null for imported WIF.</summary>
+    public string? AccountPath { get; set; }
 
-    /// <summary>Xpub di account in SLIP-132: basta da sola per il watch-only.</summary>
-    public required string AccountXpub { get; set; }
+    /// <summary>Account xpub in SLIP-132 for HD wallets; null for imported WIF.</summary>
+    public string? AccountXpub { get; set; }
+
+    /// <summary>Account xprv in SLIP-132; present only for import from xprv without seed.</summary>
+    public string? AccountXprv { get; set; }
 
     public string? MasterFingerprint { get; set; }
 
-    /// <summary>Gap limit per la scansione indirizzi (§5), configurabile.</summary>
+    /// <summary>Imported WIF keys (in plaintext in the document — must be encrypted!).</summary>
+    public List<string>? WifKeys { get; set; }
+
+    /// <summary>Gap limit for address scanning (§5), configurable.</summary>
     public int GapLimit { get; set; } = 20;
 
-    /// <summary>Etichette per indirizzo/txid (§12).</summary>
+    /// <summary>Labels by address/txid (§12).</summary>
     public Dictionary<string, string> Labels { get; set; } = [];
 
-    /// <summary>Rubrica contatti (nome + indirizzo blockchain).</summary>
+    /// <summary>Contact address book (name + blockchain address).</summary>
     public List<StoredContact> Contacts { get; set; } = [];
 
-    /// <summary>Cache dell'ultimo stato sincronizzato (saldo/storico mostrabili offline).</summary>
+    /// <summary>Cache of the last synced state (balance/history viewable offline).</summary>
     public SyncCache? Cache { get; set; }
 
-    public bool IsWatchOnly => Mnemonic is null;
+    public bool IsWatchOnly =>
+        Mnemonic is null &&
+        AccountXprv is null &&
+        (WifKeys is null || WifKeys.Count == 0);
 
     private static readonly JsonSerializerOptions JsonOptions = new()
     {
@@ -60,6 +69,7 @@ public sealed class WalletDocument
     {
         var doc = JsonSerializer.Deserialize<WalletDocument>(json, JsonOptions)
             ?? throw new InvalidDataException("File wallet non valido.");
+        // string literal above intentionally left untranslated
         return Migrate(doc);
     }
 
@@ -85,14 +95,38 @@ public sealed class SyncCache
     public int TipHeight { get; set; }
     public long ConfirmedSats { get; set; }
     public long UnconfirmedSats { get; set; }
+
+    /// <summary>Confirmed but not yet spendable (coinbase immature or under min confirmations). Subset of ConfirmedSats.</summary>
+    public long ImmatureSats { get; set; }
     public int NextReceiveIndex { get; set; }
     public int NextChangeIndex { get; set; }
     public List<CachedTx> History { get; set; } = [];
     public List<CachedUtxo> Utxos { get; set; } = [];
     public List<CachedAddress> Addresses { get; set; } = [];
+
+    /// <summary>
+    /// Raw transaction cache (txid → hex). Avoids re-downloading confirmed
+    /// transactions on every launch: confirmed txs are immutable by definition.
+    /// May be partially populated after an interrupted sync (e.g. -101 error);
+    /// the synchronizer resumes from where it left off.
+    /// </summary>
+    public Dictionary<string, string>? RawTxHex { get; set; }
+
+    /// <summary>
+    /// Already-verified Merkle proofs (txid → block height). Avoids re-verifying
+    /// the same proofs on every launch: confirmations are immutable.
+    /// </summary>
+    public Dictionary<string, int>? VerifiedAt { get; set; }
+
+    /// <summary>
+    /// Raw headers by height (height → hex). Immutable: never re-fetched once saved.
+    /// Eliminates GetBlockHeader calls for Merkle proofs already verified in
+    /// subsequent syncs.
+    /// </summary>
+    public Dictionary<int, string>? BlockHeaders { get; set; }
 }
 
-/// <summary>Indirizzo scansionato con saldo proprio e numero di transazioni (vista indirizzi).</summary>
+/// <summary>Scanned address with its own balance and transaction count (address view).</summary>
 public sealed class CachedAddress
 {
     public required string Address { get; set; }
@@ -119,5 +153,6 @@ public sealed class CachedUtxo
     public bool IsChange { get; set; }
     public int AddressIndex { get; set; }
     public int Height { get; set; }
+    public bool IsCoinbase { get; set; }
     public bool Frozen { get; set; }
 }

src/Core/Storage/WalletLock.cs

@@ -0,0 +1,48 @@
+namespace PalladiumWallet.Core.Storage;
+
+/// <summary>
+/// Exclusive lock on a wallet file held for the lifetime of the session.
+/// The real lock is the open FileStream with FileShare.None — the .lock file
+/// is just its vessel. The OS releases it automatically on process exit or crash.
+/// </summary>
+public sealed class WalletLock : IDisposable
+{
+    private readonly string _lockPath;
+    private FileStream? _stream;
+
+    private WalletLock(string lockPath, FileStream stream)
+    {
+        _lockPath = lockPath;
+        _stream = stream;
+    }
+
+    /// <summary>
+    /// Tries to acquire an exclusive lock for <paramref name="walletPath"/>.
+    /// Returns null if another process already holds the lock (IOException).
+    /// Lets UnauthorizedAccessException propagate so callers can show a distinct message.
+    /// </summary>
+    public static WalletLock? TryAcquire(string walletPath)
+    {
+        var lockPath = walletPath + ".lock";
+        try
+        {
+            var stream = new FileStream(
+                lockPath,
+                FileMode.OpenOrCreate,
+                FileAccess.ReadWrite,
+                FileShare.None);
+            return new WalletLock(lockPath, stream);
+        }
+        catch (IOException)
+        {
+            return null;
+        }
+    }
+
+    public void Dispose()
+    {
+        _stream?.Dispose();
+        _stream = null;
+        try { File.Delete(_lockPath); } catch { }
+    }
+}

src/Core/Storage/WalletStore.cs

@@ -25,6 +25,8 @@ public static class WalletStore
         return WalletDocument.FromJson(content);
     }
 
+    /// <param name="password">Null saves in plaintext. Only omit when the user has
+    /// explicitly opted out of encryption (UI must show a clear warning).</param>
     public static void Save(WalletDocument doc, string path, string? password = null)
     {
         var content = doc.ToJson();

src/Core/Wallet/CoinAmount.cs

@@ -3,30 +3,31 @@ using System.Globalization;
 namespace PalladiumWallet.Core.Wallet;
 
 /// <summary>
-/// Conversione satoshi ↔ unità coin (8 decimali) per visualizzazione e input.
-/// Si lavora sempre in satoshi internamente; la stringa è solo presentazione.
+/// Satoshi ↔ coin unit conversion (8 decimal places) for display and input.
+/// All internal computation uses satoshis; the formatted string is presentation only.
 /// </summary>
 public static class CoinAmount
 {
     public const long SatsPerCoin = 100_000_000;
 
-    /// <summary>Unità di visualizzazione selezionabili (config §8).</summary>
+    /// <summary>Selectable display units (config §8).</summary>
     public static readonly string[] Units = ["PLM", "mPLM", "µPLM", "sat"];
 
-    /// <summary>(satoshi per unità, decimali mostrati) di ciascuna unità.</summary>
+    /// <summary>(satoshis per unit, displayed decimals) for each unit.</summary>
     private static (long Factor, int Decimals) Of(string unit) => unit switch
     {
+        "PLM"  => (SatsPerCoin, 8),
         "mPLM" => (100_000, 5),
         "µPLM" => (100, 2),
-        "sat" => (1, 0),
-        _ => (SatsPerCoin, 8), // PLM
+        "sat"  => (1, 0),
+        _ => throw new ArgumentException($"Unknown coin unit: {unit}", nameof(unit)),
     };
 
     public static string Format(long sats, string unit = "") =>
         (sats / (decimal)SatsPerCoin).ToString("0.00000000", CultureInfo.InvariantCulture)
         + (unit.Length > 0 ? " " + unit : "");
 
-    /// <summary>Formatta nell'unità scelta (es. 150000 sat → "1.50000 mPLM").</summary>
+    /// <summary>Formats in the chosen unit (e.g. 150000 sat → "1.50000 mPLM").</summary>
     public static string FormatIn(long sats, string unit, bool withLabel = true)
     {
         var (factor, decimals) = Of(unit);
@@ -35,7 +36,7 @@ public static class CoinAmount
         return withLabel ? $"{value} {unit}" : value;
     }
 
-    /// <summary>Parsa un importo espresso nell'unità scelta in satoshi.</summary>
+    /// <summary>Parses an amount expressed in the chosen unit into satoshis.</summary>
     public static bool TryParseIn(string text, string unit, out long sats)
     {
         sats = 0;
@@ -46,7 +47,10 @@ public static class CoinAmount
             return false;
         try
         {
-            sats = (long)(value * factor);
+            var satsDecimal = value * factor;
+            if (satsDecimal % 1 != 0)
+                return false;
+            sats = (long)satsDecimal;
         }
         catch (OverflowException)
         {
@@ -55,7 +59,7 @@ public static class CoinAmount
         return true;
     }
 
-    /// <summary>Parsa un importo in coin (punto o virgola decimale) in satoshi.</summary>
+    /// <summary>Parses a coin amount (decimal point or comma) into satoshis.</summary>
     public static bool TryParseCoins(string text, out long sats)
     {
         sats = 0;
@@ -65,7 +69,10 @@ public static class CoinAmount
             return false;
         try
         {
-            sats = (long)(coins * SatsPerCoin);
+            var satsDecimal = coins * SatsPerCoin;
+            if (satsDecimal % 1 != 0)
+                return false;
+            sats = (long)satsDecimal;
         }
         catch (OverflowException)
         {

src/Core/Wallet/TransactionFactory.cs

@@ -6,7 +6,7 @@ using PalladiumWallet.Core.Storage;
 
 namespace PalladiumWallet.Core.Wallet;
 
-/// <summary>Esito della costruzione di una transazione.</summary>
+/// <summary>Result of a transaction build operation.</summary>
 public sealed class BuiltTransaction
 {
     public required Transaction Transaction { get; init; }
@@ -14,7 +14,7 @@ public sealed class BuiltTransaction
     public required FeeRate FeeRate { get; init; }
     public required bool Signed { get; init; }
 
-    /// <summary>PSBT per i flussi watch-only/air-gapped/multisig (§6.5).</summary>
+    /// <summary>PSBT for watch-only/air-gapped/multisig flows (§6.5).</summary>
     public required PSBT Psbt { get; init; }
 
     public string ToHex() => Transaction.ToHex();
@@ -22,25 +22,26 @@ public sealed class BuiltTransaction
 }
 
 /// <summary>
-/// Costruzione e firma delle transazioni (blueprint §6) sopra le primitive
-/// NBitcoin: selezione monete (manuale o automatica), fee a rate fisso,
-/// invia-tutto con fee sottratta, change sulla catena interna, RBF di default.
-/// Con un account watch-only produce la PSBT non firmata (§6.5).
+/// Transaction construction and signing (blueprint §6) on top of NBitcoin primitives:
+/// coin selection (manual or automatic), fixed fee rate, send-all with fee subtracted,
+/// change on the internal chain, RBF on by default.
+/// With a watch-only account produces an unsigned PSBT (§6.5).
 /// </summary>
-public sealed class TransactionFactory(HdAccount account)
+public sealed class TransactionFactory(IWalletAccount account)
 {
     private Network Network => PalladiumNetworks.For(account.Profile.Kind);
 
     /// <summary>
-    /// Costruisce (e se possibile firma) una transazione.
+    /// Builds (and signs if possible) a transaction.
     /// </summary>
-    /// <param name="utxos">UTXO selezionati (coin control §6.2) o tutti quelli spendibili.</param>
-    /// <param name="transactions">Tx di provenienza degli UTXO (txid → tx), dalla sincronizzazione.</param>
-    /// <param name="destination">Indirizzo destinatario.</param>
-    /// <param name="amountSats">Importo; ignorato se <paramref name="sendAll"/>.</param>
-    /// <param name="feeRateSatPerVByte">Fee rate fisso in sat/vByte (§6.4).</param>
-    /// <param name="changeIndex">Indice del prossimo indirizzo di change (catena interna).</param>
-    /// <param name="sendAll">Invia tutto: fee sottratta dall'importo (§6.1).</param>
+    /// <param name="utxos">Selected UTXOs (coin control §6.2) or all spendable ones.</param>
+    /// <param name="transactions">Source transactions for the UTXOs (txid → tx), from sync.</param>
+    /// <param name="destination">Recipient address.</param>
+    /// <param name="amountSats">Amount; ignored when <paramref name="sendAll"/> is true.</param>
+    /// <param name="feeRateSatPerVByte">Fixed fee rate in sat/vByte (§6.4).</param>
+    /// <param name="changeIndex">Index of the next change address (internal chain).</param>
+    /// <param name="tipHeight">Current chain tip height, used to enforce confirmation thresholds.</param>
+    /// <param name="sendAll">Send all: fee subtracted from the amount (§6.1).</param>
     public BuiltTransaction Build(
         IReadOnlyList<CachedUtxo> utxos,
         IReadOnlyDictionary<string, Transaction> transactions,
@@ -48,17 +49,42 @@ public sealed class TransactionFactory(HdAccount account)
         long amountSats,
         decimal feeRateSatPerVByte,
         int changeIndex,
+        int tipHeight,
         bool sendAll = false)
     {
-        // Si spendono solo UTXO confermati: i fondi in mempool si vedono nel
-        // saldo "in attesa" ma non sono spendibili finché non confermano.
-        var spendable = utxos.Where(u => !u.Frozen && u.Height > 0).ToList();
+        var profile = account.Profile;
+        var spendable = utxos.Where(u => u.IsSpendable(profile, tipHeight)).ToList();
+
         if (spendable.Count == 0)
         {
-            var pending = utxos.Where(u => !u.Frozen && u.Height <= 0).Sum(u => u.ValueSats);
-            throw new WalletSpendException(pending > 0
-                ? $"Nessun fondo confermato: {CoinAmount.Format(pending)} in attesa di conferma (non spendibile)."
-                : "Nessun UTXO spendibile selezionato.");
+            var reasons = new System.Text.StringBuilder();
+
+            var mempool = utxos.Where(u => !u.Frozen && u.Height <= 0).ToList();
+            if (mempool.Count > 0)
+                reasons.Append($"{mempool.Count} output(s) unconfirmed ({CoinAmount.Format(mempool.Sum(u => u.ValueSats))} in mempool). ");
+
+            var immature = utxos.Where(u =>
+                !u.Frozen && u.Height > 0 && u.IsCoinbase &&
+                u.Confirmations(tipHeight) < u.RequiredConfirmations(profile)).ToList();
+            if (immature.Count > 0)
+            {
+                var best = immature.Max(u => u.Confirmations(tipHeight));
+                var threshold = profile.CoinbaseMaturity + 1;
+                reasons.Append($"{immature.Count} coinbase output(s) not yet mature ({best}/{threshold} confirmations). ");
+            }
+
+            var underConf = utxos.Where(u =>
+                !u.Frozen && u.Height > 0 && !u.IsCoinbase &&
+                u.Confirmations(tipHeight) < u.RequiredConfirmations(profile)).ToList();
+            if (underConf.Count > 0)
+            {
+                var best = underConf.Max(u => u.Confirmations(tipHeight));
+                reasons.Append($"{underConf.Count} output(s) need {profile.MinConfirmations} confirmations ({best} so far). ");
+            }
+
+            throw new WalletSpendException(reasons.Length > 0
+                ? $"No spendable UTXOs: {reasons.ToString().TrimEnd()}"
+                : "No spendable UTXOs selected.");
         }
 
         var coins = spendable.Select(u => new Coin(
@@ -68,7 +94,7 @@ public sealed class TransactionFactory(HdAccount account)
         var feeRate = new FeeRate(Money.Satoshis(feeRateSatPerVByte * 1000m), 1000);
         var builder = Network.CreateTransactionBuilder();
         builder.SetVersion(2);
-        // Sequence RBF per consentire il bump della fee (§6.6).
+        // RBF sequence to allow fee bumping (§6.6).
         builder.OptInRBF = true;
         builder.AddCoins(coins);
         builder.SetChange(account.GetChangeAddress(changeIndex));
@@ -82,7 +108,8 @@ public sealed class TransactionFactory(HdAccount account)
         if (!account.IsWatchOnly)
         {
             builder.AddKeys(spendable
-                .Select(u => account.GetExtPrivateKey(u.IsChange, u.AddressIndex))
+                .Select(u => account.GetPrivateKey(u.IsChange, u.AddressIndex))
+                .OfType<Key>()
                 .ToArray());
         }
 
@@ -93,14 +120,14 @@ public sealed class TransactionFactory(HdAccount account)
         }
         catch (NotEnoughFundsException ex)
         {
-            throw new WalletSpendException($"Fondi insufficienti: {ex.Message}");
+            throw new WalletSpendException($"Insufficient funds: {ex.Message}");
         }
 
         if (!account.IsWatchOnly)
         {
             if (!builder.Verify(tx, out TransactionPolicyError[] errors))
                 throw new WalletSpendException(
-                    "Transazione non valida: " + string.Join("; ", errors.Select(e => e.ToString())));
+                    "Invalid transaction: " + string.Join("; ", errors.Select(e => e.ToString())));
         }
 
         return new BuiltTransaction
@@ -122,5 +149,5 @@ public sealed class TransactionFactory(HdAccount account)
     }
 }
 
-/// <summary>Errore di costruzione/firma della spesa (fondi, policy, parametri).</summary>
+/// <summary>Error during transaction construction/signing (funds, policy, parameters).</summary>
 public sealed class WalletSpendException(string message) : Exception(message);

src/Core/Wallet/TransactionInspector.cs

@@ -4,36 +4,36 @@ using PalladiumWallet.Core.Spv;
 
 namespace PalladiumWallet.Core.Wallet;
 
-/// <summary>Un input di una transazione, con l'output speso risolto dal server.</summary>
+/// <summary>An input of a transaction, with the spent output resolved from the server.</summary>
 public sealed record TxInputInfo(
     string PrevTxid, uint PrevIndex, long? AmountSats, string? Address, bool IsMine, bool IsCoinbase);
 
-/// <summary>Un output di una transazione.</summary>
+/// <summary>An output of a transaction.</summary>
 public sealed record TxOutputInfo(
     uint Index, long AmountSats, string? Address, string ScriptType, bool IsMine);
 
 /// <summary>
-/// Dati completi di una transazione, assemblati interrogando il server: la tx
-/// grezza più gli output spesi dagli input (per ricavare importi, indirizzi e
-/// fee) e l'header del blocco (per la data). Tutto ciò che il protocollo
-/// ElectrumX-like (§10) permette di sapere su una transazione.
+/// Complete transaction data assembled by querying the server: the raw transaction
+/// plus the outputs spent by each input (to derive amounts, addresses, and fees)
+/// and the block header (for the timestamp). Everything the ElectrumX-like protocol
+/// (§10) can tell us about a transaction.
 /// </summary>
 public sealed class TransactionDetails
 {
     public required string Txid { get; init; }
-    /// <summary>Altezza del blocco; ≤0 = ancora in mempool.</summary>
+    /// <summary>Block height; ≤0 = still in mempool.</summary>
     public required int Height { get; init; }
     public required int Confirmations { get; init; }
-    /// <summary>Effetto netto sul saldo del wallet (delta calcolato in sincronizzazione).</summary>
+    /// <summary>Net effect on the wallet balance (delta computed during sync).</summary>
     public required long NetSats { get; init; }
-    /// <summary>Fee della transazione; null se un input ha importo non risolvibile (es. coinbase).</summary>
+    /// <summary>Transaction fee; null if any input amount cannot be resolved (e.g. coinbase).</summary>
     public required long? FeeSats { get; init; }
     public required int TotalSize { get; init; }
     public required int VirtualSize { get; init; }
     public required uint Version { get; init; }
     public required uint LockTime { get; init; }
     public required bool RbfSignaled { get; init; }
-    /// <summary>Merkle proof verificata in sincronizzazione (§7.4).</summary>
+    /// <summary>Merkle proof verified during sync (§7.4).</summary>
     public required bool Verified { get; init; }
     public required DateTimeOffset? BlockTime { get; init; }
     public required long TotalOutSats { get; init; }
@@ -43,13 +43,13 @@ public sealed class TransactionDetails
 
     public bool IsCoinbase => Inputs.Count > 0 && Inputs[0].IsCoinbase;
     public bool IsIncoming => NetSats >= 0;
-    /// <summary>Importo verso destinatari esterni (output non nostri): l'importo "inviato".</summary>
+    /// <summary>Amount sent to external recipients (outputs not ours): the "sent" amount.</summary>
     public long SentToOthersSats => Outputs.Where(o => !o.IsMine).Sum(o => o.AmountSats);
     public long ReceivedSats => Outputs.Where(o => o.IsMine).Sum(o => o.AmountSats);
     public double? FeeRateSatPerVb => FeeSats is { } f && VirtualSize > 0 ? (double)f / VirtualSize : null;
     /// <summary>
-    /// Indirizzi della controparte: i destinatari esterni per un invio (output non
-    /// nostri), i mittenti esterni per una ricezione (input non nostri).
+    /// Counterparty addresses: external recipients for a send (outputs not ours),
+    /// external senders for a receive (inputs not ours).
     /// </summary>
     public IReadOnlyList<string> CounterpartyAddresses => IsIncoming
         ? [.. Inputs.Where(i => !i.IsMine && i.Address is not null).Select(i => i.Address!).Distinct()]
@@ -57,9 +57,9 @@ public sealed class TransactionDetails
 }
 
 /// <summary>
-/// Recupera dal server tutti i dati di una singola transazione (blueprint §10):
-/// la transazione grezza e gli output spesi dai suoi input, per ricostruire
-/// importi, fee e indirizzi che il server non riassume.
+/// Fetches all data for a single transaction from the server (blueprint §10):
+/// the raw transaction and the outputs spent by its inputs, to reconstruct
+/// amounts, fees, and addresses that the server does not summarise.
 /// </summary>
 public static class TransactionInspector
 {
@@ -112,10 +112,10 @@ public static class TransactionInspector
 
         var rbf = tx.Inputs.Any(i => i.Sequence.IsRBF);
 
-        // Le transazioni degli input servono per importi/indirizzi/fee. Si
-        // scaricano in parallelo (id univoci, richieste concorrenti supportate
-        // da ElectrumClient): in sequenza la finestra impiegava un round-trip
-        // per input. Anche l'header del blocco è recuperato in parallelo.
+        // Input transactions are needed for amounts/addresses/fees. Fetched in
+        // parallel (unique ids, concurrent requests supported by ElectrumClient):
+        // sequential fetching costs one round-trip per input. The block header
+        // is also fetched in parallel.
         var prevTxids = tx.IsCoinBase
             ? []
             : tx.Inputs.Select(i => i.PrevOut.Hash.ToString()).Distinct().ToList();

src/Core/Wallet/UtxoSpendability.cs

@@ -0,0 +1,24 @@
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Storage;
+
+namespace PalladiumWallet.Core.Wallet;
+
+/// <summary>
+/// Confirmation-threshold rules shared between coin selection (<see cref="TransactionFactory"/>)
+/// and balance reporting: a coinbase output needs COINBASE_MATURITY + 1 confirmations
+/// (consensus rule nSpendHeight - nHeight >= 120, plus one block of safety margin, matching
+/// the Qt wallet); a regular output needs <see cref="ChainProfile.MinConfirmations"/> (wallet
+/// policy, no consensus rule).
+/// </summary>
+public static class UtxoSpendability
+{
+    public static int RequiredConfirmations(this CachedUtxo utxo, ChainProfile profile) =>
+        utxo.IsCoinbase ? profile.CoinbaseMaturity + 1 : profile.MinConfirmations;
+
+    public static int Confirmations(this CachedUtxo utxo, int tipHeight) =>
+        utxo.Height <= 0 ? 0 : tipHeight - utxo.Height + 1;
+
+    /// <summary>True when the UTXO has met its confirmation threshold and is not frozen.</summary>
+    public static bool IsSpendable(this CachedUtxo utxo, ChainProfile profile, int tipHeight) =>
+        !utxo.Frozen && utxo.Height > 0 && utxo.Confirmations(tipHeight) >= utxo.RequiredConfirmations(profile);
+}

src/Core/Wallet/WalletLoader.cs

@@ -6,39 +6,66 @@ using PalladiumWallet.Core.Storage;
 namespace PalladiumWallet.Core.Wallet;
 
 /// <summary>
-/// Ponte documento wallet ↔ dominio (blueprint §4.5): dal file ricostruisce
-/// l'HdAccount giusto (da seed o watch-only da xpub). È l'embrione della
-/// factory dei tipi di wallet; crescerà con multisig e importati.
+/// Wallet type factory (blueprint §4.5): reconstructs the correct account type
+/// from a document (HD from seed, HD from imported xprv, imported WIF, watch-only).
 /// </summary>
 public static class WalletLoader
 {
     public static ChainProfile ProfileOf(WalletDocument doc) =>
         ChainProfiles.For(Enum.Parse<NetKind>(doc.Network, ignoreCase: true));
 
-    public static HdAccount ToAccount(WalletDocument doc)
+    public static IWalletAccount ToAccount(WalletDocument doc)
     {
         var profile = ProfileOf(doc);
         var kind = Enum.Parse<ScriptKind>(doc.ScriptKind);
-        var path = KeyPath.Parse(doc.AccountPath);
+        var network = PalladiumNetworks.For(profile.Kind);
 
+        // 1. HD from seed (most common case)
         if (doc.Mnemonic is { } words)
         {
             if (!Bip39.TryParse(words, out var mnemonic))
-                throw new InvalidDataException("Mnemonica del file wallet non valida.");
+                throw new InvalidDataException("Invalid mnemonic in wallet file.");
+            var path = KeyPath.Parse(doc.AccountPath ?? DerivationPaths.AccountPath(kind, profile).ToString());
             return HdAccount.FromSeed(Bip39.ToSeed(mnemonic!, doc.Passphrase), kind, profile, path);
         }
 
+        // 2. HD from imported xprv (spendable, no seed)
+        if (doc.AccountXprv is { } xprvStr)
+        {
+            if (!Slip132.TryDecodePrivate(xprvStr, profile, out var xprv, out _))
+                throw new InvalidDataException("Xprv in wallet file is invalid for this network.");
+            var path = doc.AccountPath is { Length: > 0 } p ? KeyPath.Parse(p) : null;
+            return HdAccount.FromAccountXprv(xprv!, kind, profile, path);
+        }
+
+        // 3. Imported WIF keys
+        if (doc.WifKeys is { Count: > 0 } wifKeys)
+        {
+            var entries = wifKeys.Select(wif =>
+            {
+                var secret = new BitcoinSecret(wif, network);
+                var addr = secret.PrivateKey.PubKey
+                    .GetAddress(DerivationPaths.ScriptPubKeyTypeFor(kind), network);
+                return (addr, (Key?)secret.PrivateKey);
+            }).ToList();
+            return new ImportedKeyAccount(entries, kind, profile);
+        }
+
+        // 4. Watch-only from xpub
+        if (doc.AccountXpub is null)
+            throw new InvalidDataException("Wallet file has no xpub and no seed.");
         if (!Slip132.TryDecodePublic(doc.AccountXpub, profile, out var xpub, out _))
-            throw new InvalidDataException("Xpub del file wallet non valida per questa rete.");
-        return HdAccount.FromAccountXpub(xpub!, kind, profile, path);
+            throw new InvalidDataException("Xpub in wallet file is invalid for this network.");
+        var accountPath = doc.AccountPath is { Length: > 0 } ap ? KeyPath.Parse(ap) : null;
+        return HdAccount.FromAccountXpub(xpub!, kind, profile, accountPath);
     }
 
-    /// <summary>Crea il documento per un nuovo wallet da seed.</summary>
+    /// <summary>Creates the document for a new seed wallet.</summary>
     public static (WalletDocument Doc, HdAccount Account) NewFromMnemonic(
         string words, string? passphrase, ScriptKind kind, ChainProfile profile, KeyPath? customPath = null)
     {
         if (!Bip39.TryParse(words, out var mnemonic))
-            throw new InvalidDataException("Mnemonica non valida (parole o checksum errati).");
+            throw new InvalidDataException("Invalid mnemonic (wrong words or checksum).");
 
         var account = customPath is null
             ? HdAccount.FromMnemonic(mnemonic!, passphrase, kind, profile)
@@ -56,4 +83,91 @@ public static class WalletLoader
         };
         return (doc, account);
     }
+
+    /// <summary>
+    /// Creates the document from an imported SLIP-132 xpub (watch-only).
+    /// Detects the ScriptKind from the SLIP-132 header; <paramref name="kindOverride"/> overrides
+    /// it for ambiguous prefixes (xpub can be Legacy or Taproot).
+    /// </summary>
+    public static (WalletDocument Doc, HdAccount Account) NewFromXpub(
+        string slip132, ChainProfile profile, ScriptKind? kindOverride = null)
+    {
+        if (!Slip132.TryDecodePublic(slip132.Trim(), profile, out var xpub, out var detectedKind))
+            throw new InvalidDataException("Extended public key is invalid or unrecognised for this network.");
+        var kind = kindOverride ?? detectedKind;
+        var account = HdAccount.FromAccountXpub(xpub!, kind, profile);
+
+        var doc = new WalletDocument
+        {
+            Network = profile.NetName,
+            ScriptKind = kind.ToString(),
+            AccountPath = account.AccountPath.ToString(),
+            AccountXpub = slip132.Trim(),
+        };
+        return (doc, account);
+    }
+
+    /// <summary>
+    /// Creates the document from an imported SLIP-132 xprv (spendable without seed).
+    /// The document contains the xprv in plaintext — it must be encrypted.
+    /// </summary>
+    public static (WalletDocument Doc, HdAccount Account) NewFromXprv(
+        string slip132, ChainProfile profile, ScriptKind? kindOverride = null)
+    {
+        if (!Slip132.TryDecodePrivate(slip132.Trim(), profile, out var xprv, out var detectedKind))
+            throw new InvalidDataException("Extended private key is invalid or unrecognised for this network.");
+        var kind = kindOverride ?? detectedKind;
+        var account = HdAccount.FromAccountXprv(xprv!, kind, profile);
+
+        var doc = new WalletDocument
+        {
+            Network = profile.NetName,
+            ScriptKind = kind.ToString(),
+            AccountPath = account.AccountPath.ToString(),
+            AccountXpub = account.ToSlip132(),
+            AccountXprv = slip132.Trim(),
+        };
+        return (doc, account);
+    }
+
+    /// <summary>
+    /// Creates the document from one or more imported WIF keys.
+    /// The document contains the WIF keys in plaintext — it must be encrypted.
+    /// </summary>
+    public static (WalletDocument Doc, ImportedKeyAccount Account) NewFromWif(
+        IReadOnlyList<string> wifKeys, ScriptKind kind, ChainProfile profile)
+    {
+        if (wifKeys.Count == 0)
+            throw new InvalidDataException("At least one WIF key is required.");
+
+        var network = PalladiumNetworks.For(profile.Kind);
+        var entries = new List<(BitcoinAddress, Key?)>();
+        var wifStrings = new List<string>();
+
+        foreach (var raw in wifKeys)
+        {
+            BitcoinSecret secret;
+            try
+            {
+                secret = new BitcoinSecret(raw.Trim(), network);
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidDataException($"Invalid WIF key: {ex.Message}");
+            }
+            var addr = secret.PrivateKey.PubKey
+                .GetAddress(DerivationPaths.ScriptPubKeyTypeFor(kind), network);
+            entries.Add((addr, secret.PrivateKey));
+            wifStrings.Add(raw.Trim());
+        }
+
+        var account = new ImportedKeyAccount(entries, kind, profile);
+        var doc = new WalletDocument
+        {
+            Network = profile.NetName,
+            ScriptKind = kind.ToString(),
+            WifKeys = wifStrings,
+        };
+        return (doc, account);
+    }
 }

tests/PalladiumWallet.Tests/Chain/ChainProfileTests.cs

@@ -21,7 +21,7 @@ public class ChainProfileTests
         Assert.Equal(50002, p.DefaultSslPort);
         Assert.Equal(746, p.Bip44CoinType);
         Assert.Equal("palladium", p.UriScheme);
-        Assert.True(p.SkipPowValidation); // obbligatorio: la catena usa LWMA (§3)
+        Assert.True(p.SkipPowValidation); // mandatory: the chain uses LWMA (§3)
         Assert.Equal(120, p.BlockTimeSeconds);
     }
 
@@ -69,8 +69,44 @@ public class ChainProfileTests
         Assert.StartsWith("tpub", EncodeWithHeader(headers.Public));
     }
 
-    // Serializza header (4 byte BE) + payload BIP32 di 74 byte e codifica Base58Check:
-    // il prefisso testuale risultante dipende solo dall'header.
+    [Fact]
+    public void Rete_sconosciuta_lancia_ArgumentException()
+    {
+        Assert.ThrowsAny<ArgumentException>(() => ChainProfiles.For((NetKind)99));
+    }
+
+    [Fact]
+    public void I_tre_profili_sono_istanze_distinte()
+    {
+        Assert.NotSame(ChainProfiles.Mainnet, ChainProfiles.Testnet);
+        Assert.NotSame(ChainProfiles.Mainnet, ChainProfiles.Regtest);
+        Assert.NotSame(ChainProfiles.Testnet, ChainProfiles.Regtest);
+    }
+
+    [Fact]
+    public void Tutti_i_profili_hanno_gli_stessi_porti_tcp_ssl()
+    {
+        foreach (var profile in new[] { ChainProfiles.Mainnet, ChainProfiles.Testnet, ChainProfiles.Regtest })
+        {
+            Assert.Equal(50001, profile.DefaultTcpPort);
+            Assert.Equal(50002, profile.DefaultSslPort);
+        }
+    }
+
+    [Fact]
+    public void Coin_type_mainnet_e_746()
+    {
+        Assert.Equal(746, ChainProfiles.Mainnet.Bip44CoinType);
+    }
+
+    [Fact]
+    public void Coin_type_testnet_e_1()
+    {
+        Assert.Equal(1, ChainProfiles.Testnet.Bip44CoinType);
+    }
+
+    // Serialize header (4-byte BE) + 74-byte BIP32 payload and encode Base58Check:
+    // the resulting textual prefix depends only on the header.
     private static string EncodeWithHeader(uint header)
     {
         var data = new byte[78];

tests/PalladiumWallet.Tests/Chain/PalladiumNetworksTests.cs

@@ -5,7 +5,7 @@ namespace PalladiumWallet.Tests.Chain;
 
 public class PalladiumNetworksTests
 {
-    // Chiave privata fissa per test deterministici (solo test, mai usarla davvero).
+    // Fixed private key for deterministic tests (test-only, never use it for real).
     private static Key TestKey => new(Convert.FromHexString(
         "0000000000000000000000000000000000000000000000000000000000000001"));
 

tests/PalladiumWallet.Tests/Crypto/AddressDerivationTests.cs

@@ -17,7 +17,7 @@ public class AddressDerivationTests
     [Fact]
     public void Il_vettore_bip44_produce_lo_stesso_hash_su_bitcoin_e_plm()
     {
-        // Indirizzo noto di abandon-about su m/44'/0'/0'/0/0 (riferimento pubblico).
+        // Known abandon-about address at m/44'/0'/0'/0/0 (public reference).
         var account = HdAccount.FromSeed(AbandonAboutSeed(), ScriptKind.Legacy,
             ChainProfiles.Mainnet, new KeyPath("44'/0'/0'"));
         var pubKey = account.GetPublicKey(isChange: false, 0);
@@ -27,8 +27,8 @@ public class AddressDerivationTests
 
         var plmAddr = account.GetReceiveAddress(0);
         Assert.StartsWith("P", plmAddr.ToString());
-        // Stesso hash160 sotto i due prefissi: la derivazione è identica,
-        // cambia solo la veste di rete.
+        // Same hash160 under the two prefixes: the derivation is identical,
+        // only the network dress changes.
         Assert.Equal(pubKey.Hash, ((BitcoinPubKeyAddress)plmAddr).Hash);
     }
 

tests/PalladiumWallet.Tests/Crypto/Bip32Tests.cs

@@ -5,9 +5,9 @@ using PalladiumWallet.Core.Crypto;
 namespace PalladiumWallet.Tests.Crypto;
 
 /// <summary>
-/// Vettore di test 1 della specifica BIP32 (seed 000102...0e0f). Gli header
-/// Legacy della mainnet PLM coincidono con quelli Bitcoin, quindi il confronto
-/// con le stringhe della specifica è diretto sulla rete PLM.
+/// BIP32 specification test vector 1 (seed 000102...0e0f). The Legacy headers
+/// of the PLM mainnet coincide with the Bitcoin ones, so the comparison
+/// with the specification strings is direct on the PLM network.
 /// </summary>
 public class Bip32Tests
 {
@@ -40,7 +40,7 @@ public class Bip32Tests
     [Fact]
     public void I_path_hardened_non_sono_derivabili_da_una_xpub()
     {
-        // Garanzia §17: da sole chiavi pubbliche niente derivazione hardened.
+        // §17 guarantee: from public keys alone, no hardened derivation.
         Assert.ThrowsAny<InvalidOperationException>(() =>
             Root.Neuter().Derive(new KeyPath("0'")));
     }

tests/PalladiumWallet.Tests/Crypto/Bip39Tests.cs

@@ -4,7 +4,7 @@ namespace PalladiumWallet.Tests.Crypto;
 
 public class Bip39Tests
 {
-    // Vettori ufficiali Trezor (python-mnemonic/vectors.json), passphrase "TREZOR".
+    // Official Trezor vectors (python-mnemonic/vectors.json), passphrase "TREZOR".
     [Theory]
     [InlineData(
         "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
@@ -30,8 +30,8 @@ public class Bip39Tests
     [Fact]
     public void Il_vettore_giapponese_copre_la_normalizzazione_nfkd()
     {
-        // Vettore ufficiale bip32JP (test_JP_BIP39.json[0]): mnemonica con spazi
-        // ideografici U+3000 e passphrase con caratteri da normalizzare NFKD.
+        // Official bip32JP vector (test_JP_BIP39.json[0]): mnemonic with U+3000
+        // ideographic spaces and a passphrase with characters to normalize NFKD.
         const string words =
             "あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あいこくしん　あおぞら";
         const string passphrase = "㍍ガバヴァぱばぐゞちぢ十人十色";
@@ -55,8 +55,8 @@ public class Bip39Tests
     [Fact]
     public void Checksum_invalido_viene_rifiutato()
     {
-        // 12 × "abandon": parole valide ma checksum errato — il caso che il
-        // costruttore NBitcoin non controlla da solo.
+        // 12 × "abandon": valid words but wrong checksum — the case that the
+        // NBitcoin constructor does not check on its own.
         var words = string.Join(' ', Enumerable.Repeat("abandon", 12));
         Assert.False(Bip39.TryParse(words, out _));
     }

tests/PalladiumWallet.Tests/Crypto/Bip84Slip132Tests.cs

@@ -5,12 +5,12 @@ using PalladiumWallet.Core.Crypto;
 namespace PalladiumWallet.Tests.Crypto;
 
 /// <summary>
-/// Vettore di test della specifica BIP84 (mnemonica abandon-about, senza
-/// passphrase). Gli header SLIP-132 della mainnet PLM coincidono con quelli
-/// Bitcoin, quindi zprv/zpub si confrontano direttamente; gli indirizzi si
-/// confrontano sul witness program (chain-independent) + prefisso PLM.
-/// Il path m/84'/0'/0' è volutamente "personalizzato" (coin type 0, non 746):
-/// esercita anche l'import con path custom (§4.2).
+/// BIP84 specification test vector (abandon-about mnemonic, without
+/// passphrase). The SLIP-132 headers of the PLM mainnet coincide with the
+/// Bitcoin ones, so zprv/zpub are compared directly; addresses are
+/// compared on the witness program (chain-independent) + PLM prefix.
+/// The path m/84'/0'/0' is deliberately "customized" (coin type 0, not 746):
+/// it also exercises the import with a custom path (§4.2).
 /// </summary>
 public class Bip84Slip132Tests
 {
@@ -64,12 +64,12 @@ public class Bip84Slip132Tests
     [Fact]
     public void Una_xkey_con_header_sconosciuto_viene_rifiutata()
     {
-        // xpub Bitcoin valida ma con header Legacy: non è una zpub.
+        // Valid Bitcoin xpub but with Legacy header: it is not a zpub.
         var account = Account();
         var asXpub = account.AccountXpub.ToString(Network.Main);
 
         Assert.True(Slip132.TryDecodePublic(asXpub, ChainProfiles.Mainnet, out _, out var kind));
-        Assert.Equal(ScriptKind.Legacy, kind); // header xpub → riconosciuto come Legacy
+        Assert.Equal(ScriptKind.Legacy, kind); // xpub header → recognized as Legacy
         Assert.False(Slip132.TryDecodePublic("non-base58!!!", ChainProfiles.Mainnet, out _, out _));
         Assert.False(Slip132.TryDecodePrivate(asXpub, ChainProfiles.Mainnet, out _, out _)); // pub ≠ priv
     }
@@ -88,8 +88,8 @@ public class Bip84Slip132Tests
         if (expectedPubKeyHex is not null)
             Assert.Equal(expectedPubKeyHex, pubKey.ToHex());
 
-        // Il witness program (hash160 della pubkey) è chain-independent: deve
-        // coincidere con quello dell'indirizzo bc1 del vettore ufficiale.
+        // The witness program (hash160 of the pubkey) is chain-independent: it must
+        // coincide with that of the bc1 address from the official vector.
         var bitcoinExpected = (BitcoinWitPubKeyAddress)BitcoinAddress.Create(bitcoinAddress, Network.Main);
         Assert.Equal(bitcoinExpected.Hash, pubKey.WitHash);
 

tests/PalladiumWallet.Tests/Crypto/Bip86TaprootTests.cs

@@ -0,0 +1,89 @@
+using NBitcoin;
+using PalladiumWallet.Core.Chain;
+using PalladiumWallet.Core.Crypto;
+
+namespace PalladiumWallet.Tests.Crypto;
+
+/// <summary>
+/// BIP86 test vectors (abandon-about mnemonic, no passphrase).
+/// The tweaked public key (output key, 32-byte x-only) is chain-independent:
+/// verified against the official Bitcoin vectors, then checked that the PLM
+/// address starts with plm1p (witness v1, bech32m).
+/// The path m/86'/0'/0' uses coin_type=0 (not 746) to match the BIP86 vectors.
+/// </summary>
+public class Bip86TaprootTests
+{
+    private static HdAccount Account()
+    {
+        Assert.True(Bip39.TryParse(
+            "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
+            out var mnemonic));
+        return HdAccount.FromSeed(
+            Bip39.ToSeed(mnemonic!),
+            ScriptKind.Taproot,
+            ChainProfiles.Mainnet,
+            new KeyPath("86'/0'/0'"));
+    }
+
+    [Fact]
+    public void Il_derivation_path_di_un_account_taproot_usa_purpose_86()
+    {
+        var path = DerivationPaths.AccountPath(ScriptKind.Taproot, ChainProfiles.Mainnet, 0);
+        Assert.Equal($"86'/{ChainProfiles.Mainnet.Bip44CoinType}'/0'", path.ToString());
+    }
+
+    [Fact]
+    public void Gli_indirizzi_plm_taproot_iniziano_con_plm1p()
+    {
+        var account = Account();
+        var addr0 = account.GetReceiveAddress(0).ToString();
+        var addr1 = account.GetReceiveAddress(1).ToString();
+        var change0 = account.GetChangeAddress(0).ToString();
+
+        Assert.StartsWith("plm1p", addr0);
+        Assert.StartsWith("plm1p", addr1);
+        Assert.StartsWith("plm1p", change0);
+    }
+
+    /// <summary>
+    /// The output key (tweaked x-only pubkey, 32 bytes) matches the BIP86 vector
+    /// regardless of network: the network changes only HRP and checksum, not the program.
+    /// Bitcoin addresses from https://github.com/bitcoin/bips/blob/master/bip-0086.mediawiki
+    /// </summary>
+    [Theory]
+    [InlineData(false, 0, "bc1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqkedrcr")]
+    [InlineData(false, 1, "bc1p4qhjn9zdvkux4e44uhx8tc55attvtyu358kutcqkudyccelu0was9fqzwh")]
+    [InlineData(true,  0, "bc1p3qkhfews2uk44qtvauqyr2ttdsw7svhkl9nkm9s9c3x4ax5h60wqwruhk7")]
+    public void L_output_key_coincide_col_vettore_bip86(
+        bool isChange, int index, string bitcoinAddress)
+    {
+        var account = Account();
+        var plmAddr = account.GetAddress(isChange, index);
+
+        // The witness program (tweaked output key) is chain-independent.
+        var btcAddr = (TaprootAddress)BitcoinAddress.Create(bitcoinAddress, Network.Main);
+        var plmTaproot = (TaprootAddress)plmAddr;
+        Assert.Equal(btcAddr.PubKey, plmTaproot.PubKey);
+    }
+
+    [Fact]
+    public void Il_wallet_taproot_e_watch_only_se_creato_da_xpub()
+    {
+        var full = Account();
+        var watchOnly = HdAccount.FromAccountXpub(
+            full.AccountXpub, ScriptKind.Taproot, ChainProfiles.Mainnet);
+        Assert.True(watchOnly.IsWatchOnly);
+        Assert.Equal(
+            full.GetReceiveAddress(0).ToString(),
+            watchOnly.GetReceiveAddress(0).ToString());
+    }
+
+    [Fact]
+    public void I_tipi_multisig_lanciano_not_supported()
+    {
+        Assert.Throws<NotSupportedException>(
+            () => DerivationPaths.ScriptPubKeyTypeFor(ScriptKind.WrappedSegwitMultisig));
+        Assert.Throws<NotSupportedException>(
+            () => DerivationPaths.ScriptPubKeyTypeFor(ScriptKind.NativeSegwitMultisig));
+    }
+}

tests/PalladiumWallet.Tests/Net/ServerRegistryTests.cs

@@ -9,7 +9,7 @@ public class PeerParsingTests
     [Fact]
     public void La_risposta_peers_subscribe_si_parsa_nel_formato_electrumx()
     {
-        // Formato reale: [ip, hostname, ["v...", "pN", "tPORTA", "sPORTA"]].
+        // Real format: [ip, hostname, ["v...", "pN", "tPORT", "sPORT"]].
         const string json = """
             [
               ["173.212.224.67", "173.212.224.67", ["v1.4.2", "p10000", "t50001", "s50002"]],
@@ -20,10 +20,10 @@ public class PeerParsingTests
             """;
         var peers = ElectrumApi.ParsePeers(JsonDocument.Parse(json).RootElement);
 
-        Assert.Equal(3, peers.Count); // l'ultimo non offre porte → scartato
+        Assert.Equal(3, peers.Count); // last entry has no ports → discarded
 
         Assert.Equal(new PeerInfo("173.212.224.67", 50001, 50002, "1.4.2"), peers[0]);
-        // "t" senza numero = porta di default (0 segnala "da risolvere col profilo").
+        // "t" without a number = default port (0 signals "resolve from profile").
         Assert.Equal(new PeerInfo("nodo.esempio.org", 0, null, "1.4"), peers[1]);
         Assert.Equal(new PeerInfo("solo-ssl.esempio.org", null, 50002, "1.4"), peers[2]);
     }
@@ -55,8 +55,8 @@ public class ServerRegistryTests
             var registry = new ServerRegistry(ChainProfiles.Mainnet, path);
             var bootstrapCount = registry.All.Count;
 
-            // Merge diretto via DiscoverAsync richiede un client: si testa la
-            // persistenza simulando il file degli scoperti.
+            // Direct merge via DiscoverAsync requires a client: test persistence
+            // by simulating the discovered servers file.
             var discovered = new[] { new KnownServer("nuovo.esempio.org", 50001, 50002, "1.4.2") };
             File.WriteAllText(path, JsonSerializer.Serialize(discovered));
 
@@ -64,7 +64,7 @@ public class ServerRegistryTests
             Assert.Equal(bootstrapCount + 1, reloaded.All.Count);
             Assert.Contains(reloaded.All, s => s.Host == "nuovo.esempio.org");
 
-            // Un bootstrap duplicato nel file non raddoppia.
+            // A bootstrap duplicate in the file must not double-count.
             File.WriteAllText(path, JsonSerializer.Serialize(new[]
             {
                 new KnownServer("173.212.224.67", 50001, 50002),

tests/PalladiumWallet.Tests/PalladiumWallet.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
 
@@ -11,6 +11,7 @@
 
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="CsCheck" Version="4.7.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
     <PackageReference Include="xunit" Version="2.5.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />

tests/PalladiumWallet.Tests/PropertyTests.cs

@@ -0,0 +1,205 @@
+using System;
+using System.Collections.Generic;
+using CsCheck;
+using NBitcoin;
+using PalladiumWallet.Core.Spv;
+using PalladiumWallet.Core.Storage;
+using PalladiumWallet.Core.Wallet;
+
+namespace PalladiumWallet.Tests;
+
+/// <summary>
+/// Property-based tests (CsCheck). Each test generates hundreds of random inputs and
+/// verifies that invariant properties hold — crashes, unexpected exceptions, or
+/// roundtrip violations are failures.
+/// </summary>
+public class PropertyTests
+{
+    // ── reusable generators ───────────────────────────────────────────────────
+
+    private static readonly Gen<string> GenUnit = Gen.OneOf(
+        Gen.Const("PLM"), Gen.Const("mPLM"), Gen.Const("µPLM"), Gen.Const("sat"));
+
+    // random uint256 built from 4 ulongs
+    private static readonly Gen<uint256> GenTxid =
+        Gen.Select(Gen.ULong, Gen.ULong, Gen.ULong, Gen.ULong, (a, b, c, d) =>
+        {
+            var bytes = new byte[32];
+            BitConverter.TryWriteBytes(bytes.AsSpan(0,  8), a);
+            BitConverter.TryWriteBytes(bytes.AsSpan(8,  8), b);
+            BitConverter.TryWriteBytes(bytes.AsSpan(16, 8), c);
+            BitConverter.TryWriteBytes(bytes.AsSpan(24, 8), d);
+            return new uint256(bytes);
+        });
+
+    // ── CoinAmount ───────────────────────────────────────────────────────────
+
+    /// TryParseIn must never throw on arbitrary input with valid units.
+    [Fact]
+    public void CoinAmount_TryParseIn_non_lancia_mai_su_input_arbitrario()
+    {
+        Gen.Select(GenUnit, Gen.String).Sample((unit, text) =>
+        {
+            try
+            {
+                CoinAmount.TryParseIn(text, unit, out _);
+            }
+            catch (ArgumentException)
+            {
+                // unknown unit: impossible here because we only use known units
+                throw;
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"TryParseIn threw {ex.GetType().Name} for unit={unit}");
+            }
+        });
+    }
+
+    /// FormatIn → TryParseIn: any satoshi value in [0, MaxSupply] must roundtrip exactly.
+    [Fact]
+    public void CoinAmount_roundtrip_FormatIn_TryParseIn_per_ogni_unita()
+    {
+        const long MaxSupply = 21_000_000L * 100_000_000L;
+        Gen.Select(Gen.Long[0, MaxSupply], GenUnit).Sample((sats, unit) =>
+        {
+            var formatted = CoinAmount.FormatIn(sats, unit, withLabel: false);
+            Assert.True(
+                CoinAmount.TryParseIn(formatted, unit, out var parsed),
+                $"FormatIn={formatted} unit={unit} failed to re-parse");
+            Assert.Equal(sats, parsed);
+        });
+    }
+
+    /// TryParseCoins must never throw on arbitrary input.
+    [Fact]
+    public void CoinAmount_TryParseCoins_non_lancia_mai_su_input_arbitrario()
+    {
+        Gen.String.Sample(text =>
+        {
+            try
+            {
+                CoinAmount.TryParseCoins(text, out _);
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail($"TryParseCoins threw {ex.GetType().Name}");
+            }
+        });
+    }
+
+    /// Any value accepted by TryParseCoins must be ≥ 0.
+    [Fact]
+    public void CoinAmount_TryParseCoins_accetta_solo_valori_non_negativi()
+    {
+        Gen.String.Sample(text =>
+        {
+            if (CoinAmount.TryParseCoins(text, out var sats))
+                Assert.True(sats >= 0, $"TryParseCoins returned {sats} for '{text}'");
+        });
+    }
+
+    // ── EncryptedFile ─────────────────────────────────────────────────────────
+
+    /// Encrypt → Decrypt with the same password must return the original plaintext.
+    [Fact]
+    public void EncryptedFile_roundtrip_su_contenuto_e_password_arbitrari()
+    {
+        Gen.Select(Gen.String, Gen.String[1, 64]).Sample((plaintext, password) =>
+        {
+            var cipher    = EncryptedFile.Encrypt(plaintext, password);
+            var recovered = EncryptedFile.Decrypt(cipher, password);
+            Assert.Equal(plaintext, recovered);
+        });
+    }
+
+    /// Decrypt with the wrong password must throw WrongPasswordException, never anything else.
+    [Fact]
+    public void EncryptedFile_password_sbagliata_lancia_solo_WrongPasswordException()
+    {
+        Gen.Select(Gen.String, Gen.String[1, 32], Gen.String[1, 32]).Sample((plaintext, pwd1, pwd2) =>
+        {
+            if (pwd1 == pwd2) return; // same password: valid roundtrip, skip
+
+            var cipher = EncryptedFile.Encrypt(plaintext, pwd1);
+            try
+            {
+                EncryptedFile.Decrypt(cipher, pwd2);
+                Assert.Fail("Decrypt with wrong password did not throw");
+            }
+            catch (WrongPasswordException) { /* expected */ }
+            catch (Exception ex)
+            {
+                Assert.Fail($"Decrypt threw {ex.GetType().Name} instead of WrongPasswordException");
+            }
+        });
+    }
+
+    /// IsEncrypted must never throw on arbitrary input.
+    [Fact]
+    public void EncryptedFile_IsEncrypted_non_lancia_mai()
+    {
+        Gen.String.Sample(s =>
+        {
+            try { EncryptedFile.IsEncrypted(s); }
+            catch (Exception ex)
+            {
+                Assert.Fail($"IsEncrypted threw {ex.GetType().Name}");
+            }
+        });
+    }
+
+    // ── MerkleProof ───────────────────────────────────────────────────────────
+
+    /// Every leaf of a randomly generated Merkle tree must verify against the root.
+    [Fact]
+    public void MerkleProof_ogni_foglia_verifica_contro_la_sua_radice()
+    {
+        GenTxid.Array[1, 16].Sample(txids =>
+        {
+            var root = MerkleProof.ComputeRootFromLeaves(txids);
+            for (var pos = 0; pos < txids.Length; pos++)
+            {
+                var branch = BuildBranch(txids, pos);
+                Assert.True(
+                    MerkleProof.Verify(txids[pos], pos, branch, root),
+                    $"Verify failed for pos={pos} over {txids.Length} leaves");
+            }
+        });
+    }
+
+    /// A txid not present in the leaves must not verify (and must not crash).
+    [Fact]
+    public void MerkleProof_txid_estraneo_non_verifica_e_non_crasha()
+    {
+        Gen.Select(GenTxid.Array[2, 8], GenTxid).Sample((txids, extra) =>
+        {
+            if (txids.Contains(extra)) return; // random collision: skip
+
+            var root   = MerkleProof.ComputeRootFromLeaves(txids);
+            var branch = BuildBranch(txids, 0);
+            Assert.False(MerkleProof.Verify(extra, 0, branch, root));
+        });
+    }
+
+    // helper: builds the branch for the given position
+    private static List<uint256> BuildBranch(IReadOnlyList<uint256> leaves, int position)
+    {
+        var branch = new List<uint256>();
+        var level  = leaves.ToList();
+        while (level.Count > 1)
+        {
+            var sibling = (position ^ 1) < level.Count ? level[position ^ 1] : level[position];
+            branch.Add(sibling);
+            var next = new List<uint256>();
+            for (var i = 0; i < level.Count; i += 2)
+            {
+                var pair = new[] { level[i], i + 1 < level.Count ? level[i + 1] : level[i] };
+                next.Add(MerkleProof.ComputeRootFromLeaves(pair));
+            }
+            level = next;
+            position >>= 1;
+        }
+        return branch;
+    }
+}