test: backend E2E test harness with SPV wallet scenario

[lklimek]

Issue being fixed or feature implemented

Refs #672 (partial — establishes the backend E2E test harness; CLI interface is a separate effort)

User Story

Imagine you are a developer working on Dash Evo Tool. You want to verify that
wallet operations, identity management, and DPNS registration actually work
against Dash testnet — not just in unit tests, but end-to-end through the same
AppContext and BackendTask pipeline the real app uses. You run a single
cargo test command and get confidence that the core backend works correctly
before shipping.

Summary

• Backend E2E test framework with shared singleton BackendTestContext (via tokio::sync::OnceCell) that initializes SPV, connects to testnet peers, and restores a pre-funded framework wallet
• Test wallet lifecycle: create_funded_test_wallet() generates fresh wallets, funds them from the framework wallet, and waits for spendable balance
• Reliable spendable balance checking: Wallet::spv_confirmed_balance() returns None when SPV hasn't synced yet (no max_balance() fallback), and wait_for_spendable_balance() uses it to avoid false positives
• Explicit data_dir threading: AppContext::new() takes data_dir: PathBuf instead of relying on unsafe { set_var("DASH_EVO_DATA_DIR") } — eliminates UB and enables parallel test execution
• Type-safe error handling: register_wallet() returns Result<_, TaskError> with dedicated WalletAlreadyImported variant; Wallet::new_from_seed() returns TaskError with WalletKeyDerivationFailed
• Production code improvements: IdentityKeys fields are pub(crate), build_identity_registration() and get_receive_address() moved to production code, Secret type used for wallet passwords
• 6 test scenarios: SPV wallet sync, send/receive funds, fetch contracts, identity creation, DPNS registration, identity withdrawal
• Cleanup subsystem: sweeps orphaned test wallets from previous runs back to the framework wallet

Test plan

• cargo clippy --all-features --all-targets -- -D warnings passes
• cargo +nightly fmt --all passes
• cargo test --all-features --workspace passes (unit + doc tests)
• cargo test --test backend-e2e --all-features -- --ignored --nocapture passes against live testnet
• Verify wait_for_spendable_balance correctly waits (doesn't return early due to max_balance() fallback)

_{🤖 Co-authored by Claudius the Magnificent AI Agent}

[claude]

Claudius the Magnificent's Follow-up Review — PR #673

The Grand Admiral returns for round two. The previous 26 review threads remain unaddressed — I shall not repeat myself. Instead, three NEW findings that slipped past the first wave.

New Findings (MEDIUM)

ID	Title	Location
RUST-002	derive_first_address silently returns empty maps	wallet/mod.rs:470-495
RUST-001	UTXO spendability workaround duplicated	core/mod.rs:745-808
PROJ-009	Fragile string matching for wallet-exists check	harness.rs:146

Previous Review Status

26 existing threads, 0 addressed. The HIGH finding (missing pending_wallet_selection) and both MEDIUM findings from the first review remain open. The coderabbitai threads are similarly untouched.

Verdict

Still requesting changes. The 3 new findings above are in addition to the 26 unresolved threads from prior reviews.

---

_{Review by Claudius the Magnificent — Grand Admiral of Code, Lord of All Compilers}

[coderabbitai]

Actionable comments posted: 7

♻️ Duplicate comments (4)

src/backend_task/core/mod.rs (1)

924-935: ⚠️ Potential issue | 🟠 Major

Don't infer InstantSend from height == 0.

height == 0 only means "unconfirmed". Marking every mempool UTXO as is_instantlocked makes fallback estimation and coin selection treat non-locked outputs as spendable, which can build follow-up spends the network rejects. Leave is_instantlocked unchanged unless you have a real lock signal.

Suggested fix

 fn patch_utxo_spendability_flags(utxo: &mut Utxo) {
     if utxo.height > 0 {
         utxo.is_confirmed = true;
-    } else {
-        utxo.is_instantlocked = true;
     }
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/backend_task/core/mod.rs` around lines 924 - 935, In
patch_utxo_spendability_flags, stop inferring InstantSend from utxo.height == 0;
only set utxo.is_confirmed = true when utxo.height > 0 and otherwise leave
utxo.is_instantlocked untouched so mempool UTXOs are not incorrectly marked
instant-locked. Update the function (patch_utxo_spendability_flags) to remove or
guard the assignment to utxo.is_instantlocked and only modify is_instantlocked
when a real InstantSend lock signal is present elsewhere.

tests/backend-e2e/task_runner.rs (1)

12-22: ⚠️ Potential issue | 🟠 Major

Drain this channel instead of leaving it unread.

This helper is generic over all backend tasks. An unread tokio::mpsc::channel(32) will stall the 33rd TaskResult, so a chatty task can hang the test harness.

Suggested fix

-    let (tx, _rx) = tokio::sync::mpsc::channel::<TaskResult>(32);
+    let (tx, mut rx) = tokio::sync::mpsc::channel::<TaskResult>(32);
+    tokio::spawn(async move {
+        while rx.recv().await.is_some() {}
+    });
     let sender = SenderAsync::new(tx, egui::Context::default());

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/backend-e2e/task_runner.rs` around lines 12 - 22, The test helper
run_task creates a tokio::mpsc channel and drops the receiver, which can block
the sender if >32 TaskResult messages are sent; fix this by spawning a
background task to continuously drain the receiver instead of leaving it unread:
after creating (tx, rx) call tokio::spawn with an async move loop that awaits
rx.recv() and discards each TaskResult until None, then proceed to construct
SenderAsync::new(tx, egui::Context::default()) and call
app_context.run_backend_task(task, sender). Ensure you reference the local
variables tx and rx, the function run_task, SenderAsync::new, and
app_context.run_backend_task when making the change.

tests/backend-e2e/send_funds.rs (1)

148-167: ⚠️ Potential issue | 🟠 Major

This return-leg check can succeed before wallet A receives anything back.

hash_a already has well over send_amount after the first A→B payment, so wait_for_balance(..., send_amount, ...) can pass immediately and the test still won't prove the second transfer arrived. Capture A's balance just before Line 148 and wait for it to increase; with subtract_fee_from_amount = true, send_amount is not the correct threshold anyway.

Suggested change

+    let a_balance_before_return = {
+        let w = wallet_a.read().expect("lock");
+        w.total_balance_duffs()
+    };
+
-    let _result = send_with_retry(
+    let _result = send_with_retry(
         app_context,
         &wallet_b,
         hash_b,
         a_address,
         send_amount,
         true,
         "E2E test B->A return",
     )
     .await;
 
     // Verify A received the return payment
     let a_balance_after_return = wait_for_balance(
         app_context,
         hash_a,
-        send_amount, // A should have at least send_amount back (minus fee from B)
+        a_balance_before_return + 1,
         Duration::from_secs(120),
     )
     .await
     .expect("A should receive return funds from B");
 
+    assert!(
+        a_balance_after_return > a_balance_before_return,
+        "A should receive the return payment"
+    );

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/backend-e2e/send_funds.rs` around lines 148 - 167, Before sending the
return from B, read and store wallet A's current balance (using the same
mechanism as wait_for_balance or the balance query that returns a numeric
value), then after calling send_with_retry(...) wait for A's balance to increase
by the expected net amount (consider the fee because subtract_fee_from_amount =
true) rather than waiting for an absolute threshold of send_amount; replace the
current wait_for_balance(app_context, hash_a, send_amount, ...) check with a
wait that compares new_balance >= old_balance + expected_net_received (or uses
wait_for_balance with expected_net_received and the stored old_balance as a
baseline). Ensure you reference hash_a, a_address, send_amount, and
send_with_retry when locating the code to change.

tests/backend-e2e/wait.rs (1)

19-36: ⚠️ Potential issue | 🟠 Major

Fail fast on reconcile/setup errors instead of turning them into balance timeouts.

Both polling loops just log reconcile_spv_wallets() failures and keep spinning when wallet_hash is absent. That burns the full timeout and reports the wrong problem when SPV startup or wallet registration is already broken.

Also applies to: 61-78

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/backend-e2e/wait.rs` around lines 19 - 36, The polling loop swallows
failures from reconcile_spv_wallets() and missing wallet entries, causing long
timeouts with misleading balance errors; change the loop to fail fast by
returning or bubbling the error when reconcile_spv_wallets().await returns
Err(e) (e.g., return Err(anyhow::Error::new(e)) or propagate with ?), and also
return an explicit error if app_context.wallets().read() can't find wallet_hash
instead of silently continuing; update both occurrences (the
reconcile_spv_wallets() check and the wallet lookup logic that calls
wallets.get(&wallet_hash) / wallet.total_balance_duffs()) to propagate failures
immediately.

🧹 Nitpick comments (2)

src/backend_task/identity/mod.rs (1)

94-102: Extract key-data encoding into one helper.

to_key_storage() now repeats the same HASH160-vs-raw encoding branch that to_public_keys_map() also maintains. Centralizing that logic will keep persisted key data and runtime key generation from drifting again.

Also applies to: 141-149

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/backend_task/identity/mod.rs` around lines 94 - 102, The duplicate branch
that encodes public key bytes based on master_private_key_type
(KeyType::ECDSA_HASH160 vs raw) should be pulled into a single helper function
(e.g., encode_public_key_data(master_private_key, master_private_key_type,
&secp) or similar) and used by both to_key_storage() and to_public_keys_map();
move the HASH160 path
(public_key(&secp).pubkey_hash().to_byte_array().to_vec().into()) and the raw
path (public_key(&secp).to_bytes().into()) into that helper and replace the
duplicated logic at the shown location and the other occurrence around lines
141-149 with calls to the new helper.

tests/backend-e2e/identity_withdraw.rs (1)

92-97: Verify the credited Core funds as well.

This test currently passes on the return variant alone. Add a post-withdraw assertion against the wallet or DB state for withdraw_address so the E2E catches wrong-address or wrong-amount regressions.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/backend-e2e/identity_withdraw.rs` around lines 92 - 97, After matching
BackendTaskSuccessResult::WithdrewFromIdentity, add an assertion that checks the
Core balance credited to withdraw_address (or the corresponding DB row) to
ensure the correct amount was received; e.g., after the existing match arm for
WithdrewFromIdentity(fee_result) call the test helper or client to fetch the
wallet/DB balance for withdraw_address (or use your existing
wallet_client.get_balance(withdraw_address) /
query_db_balance(withdraw_address)), compute the expected credited amount from
fee_result or test fixtures, and assert equality (panic/assert_eq!) so the test
fails if the wrong address or amount was used.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@src/context/wallet_lifecycle.rs`:
- Around line 107-115: The UNIQUE constraint error mapping in the call to
store_wallet_with_addresses currently returns a network-specific message but the
uniqueness is on wallet.seed_hash, so change the mapped message to be
network-agnostic (e.g., "This wallet has already been imported.") in the closure
passed to store_wallet_with_addresses; keep the existing detection of UNIQUE
constraint via e.to_string().contains("UNIQUE constraint failed") and only
replace the returned string, referencing the symbols wallet.seed_hash,
self.network, and store_wallet_with_addresses to locate the code to modify.

In `@src/model/wallet/mod.rs`:
- Around line 407-408: The constructor currently pre-populates known_addresses
and watched_addresses by calling Self::derive_first_address with
master_bip44_ecdsa_extended_public_key, which prevents
AppContext::register_wallet from invoking bootstrap_wallet_addresses (it only
runs when known_addresses.is_empty()), causing imported mnemonics to skip full
BIP44/BIP32/identity/SPV bootstrap. Remove or avoid populating known_addresses
and watched_addresses in the constructor (and the analogous call around
derive_first_address at the other location) so they remain empty on import;
allow register_wallet to call bootstrap_wallet_addresses to perform full address
discovery and SPV watch setup.

In `@src/ui/wallets/add_new_wallet_screen.rs`:
- Around line 162-180: The code currently propagates raw error strings from
Wallet::new_from_seed and app_context.register_wallet directly into self.error;
instead, catch those errors and convert them into a user-friendly MessageBanner
using BannerHandle::with_details(...) to attach the technical error text.
Specifically, wrap calls to Wallet::new_from_seed and
self.app_context.register_wallet in match/if let Err handling, set self.error =
Some(MessageBanner::error("Unable to add wallet").with_details(err.to_string()))
(or equivalent API), and only show the friendly message to the UI while
preserving the original error text in the BannerHandle details; keep the
existing logic that sets receive_address_string/receive_address and
core_wallet_name inside the success branch when Wallet::new_from_seed and
register_wallet succeed.

In `@tests/backend-e2e/harness.rs`:
- Around line 385-389: The call to wait::wait_for_spendable_balance currently
waits for only 1 duff, causing a race with the rest of the funded amount; change
the call to wait for the full funded amount (not 1) so callers can immediately
build transactions. Replace the hardcoded 1 with the actual expected funded
amount variable (e.g. funded_amount or the constant used when funding the test
wallet) in the call to wait::wait_for_spendable_balance(app_context, seed_hash,
<funded_amount>, Duration::from_secs(120)) so the helper blocks until the entire
funded balance is spendable.

In `@tests/backend-e2e/send_funds.rs`:
- Around line 63-66: The retry condition in the Err(e) match in
tests/backend-e2e/send_funds.rs only checks for "Insufficient" or "No UTXOs", so
errors like "No spendable funds available" (occuring when
subtract_fee_from_amount is true) do not trigger the retry/backoff; update the
conditional in that Err(e) arm to also check e.to_string().contains("No
spendable funds available") (or a shorter unique substring like "No spendable")
so the B→A leg will retry when attempt < MAX_RETRIES, keeping the existing
attempt and MAX_RETRIES logic unchanged.

In `@tests/backend-e2e/wait.rs`:
- Around line 66-76: The test is calling Wallet::confirmed_balance_duffs() which
falls back to max_balance() and can report non-spendable local UTXOs as
confirmed; change the wait to read the raw SPV-backed confirmed balance (or add
and call a no-fallback accessor on Wallet such as
confirmed_spv_balance_duffs()/spv_confirmed_balance()) instead of
confirmed_balance_duffs(), so the check uses only the SPV-confirmed fields;
update the code in wait.rs where wallets.get(...).map(|wallet_arc| { let wallet
= wallet_arc.read().expect("wallet lock"); wallet.confirmed_balance_duffs() })
to call the new/no-fallback accessor or directly read the SPV fields and compare
those to min_balance.

---

Duplicate comments:
In `@src/backend_task/core/mod.rs`:
- Around line 924-935: In patch_utxo_spendability_flags, stop inferring
InstantSend from utxo.height == 0; only set utxo.is_confirmed = true when
utxo.height > 0 and otherwise leave utxo.is_instantlocked untouched so mempool
UTXOs are not incorrectly marked instant-locked. Update the function
(patch_utxo_spendability_flags) to remove or guard the assignment to
utxo.is_instantlocked and only modify is_instantlocked when a real InstantSend
lock signal is present elsewhere.

In `@tests/backend-e2e/send_funds.rs`:
- Around line 148-167: Before sending the return from B, read and store wallet
A's current balance (using the same mechanism as wait_for_balance or the balance
query that returns a numeric value), then after calling send_with_retry(...)
wait for A's balance to increase by the expected net amount (consider the fee
because subtract_fee_from_amount = true) rather than waiting for an absolute
threshold of send_amount; replace the current wait_for_balance(app_context,
hash_a, send_amount, ...) check with a wait that compares new_balance >=
old_balance + expected_net_received (or uses wait_for_balance with
expected_net_received and the stored old_balance as a baseline). Ensure you
reference hash_a, a_address, send_amount, and send_with_retry when locating the
code to change.

In `@tests/backend-e2e/task_runner.rs`:
- Around line 12-22: The test helper run_task creates a tokio::mpsc channel and
drops the receiver, which can block the sender if >32 TaskResult messages are
sent; fix this by spawning a background task to continuously drain the receiver
instead of leaving it unread: after creating (tx, rx) call tokio::spawn with an
async move loop that awaits rx.recv() and discards each TaskResult until None,
then proceed to construct SenderAsync::new(tx, egui::Context::default()) and
call app_context.run_backend_task(task, sender). Ensure you reference the local
variables tx and rx, the function run_task, SenderAsync::new, and
app_context.run_backend_task when making the change.

In `@tests/backend-e2e/wait.rs`:
- Around line 19-36: The polling loop swallows failures from
reconcile_spv_wallets() and missing wallet entries, causing long timeouts with
misleading balance errors; change the loop to fail fast by returning or bubbling
the error when reconcile_spv_wallets().await returns Err(e) (e.g., return
Err(anyhow::Error::new(e)) or propagate with ?), and also return an explicit
error if app_context.wallets().read() can't find wallet_hash instead of silently
continuing; update both occurrences (the reconcile_spv_wallets() check and the
wallet lookup logic that calls wallets.get(&wallet_hash) /
wallet.total_balance_duffs()) to propagate failures immediately.

---

Nitpick comments:
In `@src/backend_task/identity/mod.rs`:
- Around line 94-102: The duplicate branch that encodes public key bytes based
on master_private_key_type (KeyType::ECDSA_HASH160 vs raw) should be pulled into
a single helper function (e.g., encode_public_key_data(master_private_key,
master_private_key_type, &secp) or similar) and used by both to_key_storage()
and to_public_keys_map(); move the HASH160 path
(public_key(&secp).pubkey_hash().to_byte_array().to_vec().into()) and the raw
path (public_key(&secp).to_bytes().into()) into that helper and replace the
duplicated logic at the shown location and the other occurrence around lines
141-149 with calls to the new helper.

In `@tests/backend-e2e/identity_withdraw.rs`:
- Around line 92-97: After matching
BackendTaskSuccessResult::WithdrewFromIdentity, add an assertion that checks the
Core balance credited to withdraw_address (or the corresponding DB row) to
ensure the correct amount was received; e.g., after the existing match arm for
WithdrewFromIdentity(fee_result) call the test helper or client to fetch the
wallet/DB balance for withdraw_address (or use your existing
wallet_client.get_balance(withdraw_address) /
query_db_balance(withdraw_address)), compute the expected credited amount from
fee_result or test fixtures, and assert equality (panic/assert_eq!) so the test
fails if the wrong address or amount was used.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Run ID: 3009ac48-02db-4262-a825-ec37623e694f

📥 Commits

Reviewing files that changed from the base of the PR and between c124149 and e054d4c.

📒 Files selected for processing (16)

• src/backend_task/core/mod.rs
• src/backend_task/identity/mod.rs
• src/context/wallet_lifecycle.rs
• src/database/wallet.rs
• src/model/wallet/mod.rs
• src/ui/wallets/add_new_wallet_screen.rs
• tests/backend-e2e/cleanup.rs
• tests/backend-e2e/harness.rs
• tests/backend-e2e/identity_create.rs
• tests/backend-e2e/identity_helpers.rs
• tests/backend-e2e/identity_withdraw.rs
• tests/backend-e2e/register_dpns.rs
• tests/backend-e2e/send_funds.rs
• tests/backend-e2e/spv_wallet.rs
• tests/backend-e2e/task_runner.rs
• tests/backend-e2e/wait.rs

🚧 Files skipped from review as they are similar to previous changes (1)

• tests/backend-e2e/cleanup.rs

[lklimek]

Waiting for mempool support in dash-spv

[Copilot]

Pull request overview

Adds a headless backend E2E test harness (SPV + funded wallets + Platform flows) and refactors wallet creation so UI and tests can construct/register wallets through a shared, side-effect-controlled API.

Changes:

• Introduce tests/backend-e2e/ harness + ignored network-dependent tests for SPV wallet ops, Core sends, identity flows, DPNS, and contract fetch.
• Refactor wallet creation into Wallet::new_from_seed() (pure) + AppContext::register_wallet() (DB + in-memory + SPV activation).
• Make filesystem/config/SPV paths depend on an explicit data_dir carried by AppContext (incl. DASH_EVO_DATA_DIR override), and adapt callers accordingly.

Reviewed changes

Copilot reviewed 39 out of 40 changed files in this pull request and generated 5 comments.

Show a summary per file

File	Description
tests/backend-e2e/main.rs	Defines the backend E2E test binary and modules.
tests/backend-e2e/README.md	Documents how to run and extend the backend E2E suite.
tests/backend-e2e/spv_wallet.rs	Verifies SPV startup + wallet registration + DB persistence.
tests/backend-e2e/send_funds.rs	E2E Core send/receive flow between two wallets.
tests/backend-e2e/register_dpns.rs	Identity registration + DPNS name registration and lookup.
tests/backend-e2e/identity_create.rs	Identity creation smoke test.
tests/backend-e2e/identity_withdraw.rs	Withdraw credits from Platform identity to Core address.
tests/backend-e2e/fetch_contract.rs	Fetch contracts from Platform (existing + non-existent).
tests/backend-e2e/cleanup_only.rs	Noop test to trigger orphan wallet sweep as a CI step.
tests/backend-e2e/framework/mod.rs	Exposes harness helper modules.
tests/backend-e2e/framework/harness.rs	Singleton context: temp DB/workdir, SPV startup, framework wallet restore/funding.
tests/backend-e2e/framework/task_runner.rs	Test wrapper around run_backend_task.
tests/backend-e2e/framework/wait.rs	Polling helpers (balance/spendable/SPV peer/wallet presence).
tests/backend-e2e/framework/funding.rs	Framework wallet balance checks + optional faucet helper.
tests/backend-e2e/framework/cleanup.rs	Best-effort sweep of orphaned test wallet funds.
tests/backend-e2e/framework/identity_helpers.rs	Test helpers for identity key derivation + receive address.
src/model/wallet/mod.rs	Adds Wallet::new_from_seed() and centralizes BIP44 constants/first address derivation.
src/context/wallet_lifecycle.rs	Adds AppContext::register_wallet() as the single entrypoint for persistence + SPV loading.
src/database/wallet.rs	Adds atomic store_wallet_with_addresses() transaction helper.
src/database/mod.rs	Adds shared is_unique_constraint_violation() helper.
src/backend_task/error.rs	Adds typed wallet creation/import error variants.
src/backend_task/identity/mod.rs	Adds IdentityKeys::new(), canonical default_identity_key_specs(), and key-data encoding fix for HASH160.
src/ui/identities/add_new_identity_screen/mod.rs	Switches to canonical default_identity_key_specs() source.
src/ui/wallets/add_new_wallet_screen.rs	Simplifies wallet creation to use Wallet::new_from_seed() + register_wallet().
src/ui/wallets/import_mnemonic_screen.rs	Same wallet creation refactor for mnemonic import flow.
src/spv/manager.rs	Makes SPV state directory relative to provided app data dir.
src/spv/tests.rs	Updates SPV tests for new SpvManager::new(&data_dir, ...) API.
src/config.rs	Adds Config::load_from(data_dir) / save(data_dir); keeps load() for default dir.
src/app_dir.rs	Adds DASH_EVO_DATA_DIR override + data_file_path() + directory/env helpers.
src/context/mod.rs	Adds AppContext.data_dir and uses Config::load_from(&data_dir) + SpvManager::new(&data_dir, ...).
src/app.rs	Threads data_dir through AppState creation and contexts; DB path now relative to data_dir.
src/backend_task/core/start_dash_qt.rs	Writes logs/configs relative to AppContext.data_dir.
src/backend_task/core/mod.rs	Uses Config::load_from(&self.data_dir); adapts fee API change.
src/ui/network_chooser_screen.rs	Loads/saves config relative to mainnet context data_dir.
src/ui/tools/masternode_list_diff_screen.rs	Removes obsolete NetworkExt import.
src/ui/tokens/tokens_screen/mod.rs	Updates tests for new AppContext::new(data_dir, ...) signature.
.github/workflows/tests.yml	Adds backend-e2e paths to triggers; backend E2E CI steps currently commented out.
CLAUDE.md	Documents backend-e2e test location and purpose.
Cargo.toml	Bumps dash-sdk rev; adds tokio-shared-rt dev dependency.
Cargo.lock	Updates dependency graph for new dash-sdk rev + tokio-shared-rt.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[lklimek]

Tests in this PR are commented / ignored. We need fully working SPV to enable them by default.