Bybit lost roughly $1.5 billion in ETH and staked-ether assets in one of the largest exchange hacks on record, an attack U.S. authorities later tied to North Korea’s Lazarus Group. CoinGecko’s 2026 State of Crypto Security Report, published August 27, 2026, still lists Bybit among the industry’s highest-profile security failures. Bybit itself says it blocked more than $700 million in attempted losses in the first half of 2026 alone, a sign that the attempts have not slowed down even after the exchange rebuilt its defenses.

None of that means exchanges are reckless. It means that even a well-funded, well-audited platform is still a single point of failure for anyone who keeps a balance there. Self-custody removes that single point by putting the private keys, and therefore the coins, directly in your hands instead of on someone else’s balance sheet. This guide walks through a full self-custody wallet setup in 12 steps: picking hardware or software, generating and backing up a seed offline, verifying every address before you send a cent, and proving your backup actually works before you trust it with real money.

Expect to spend 60 to 90 minutes on the core setup, plus extra time if you add a passphrase or a multisig layer. shattered.io has previously covered Safe multisig setup after the Bybit hack and how to lock down a Trezor Safe 7 after its TROPIC01 firmware issue. This tutorial is the step before either of those: getting your funds off an exchange and into a working self-custody wallet for the first time, correctly, on the first try. By the end you’ll have a funded wallet, a tested backup, and a small verification toolkit you can reuse the next time you set one up. It fits alongside the rest of shattered.io’s cryptocurrency security coverage, which tracks exchange breaches, wallet vulnerabilities, and the tooling built to defend against both.

What Self-Custody Actually Means

When coins sit on an exchange, the exchange’s database records that you’re owed a balance, but the exchange itself holds the private keys that can actually move that balance on-chain. You have a claim, not the asset. Self-custody flips that: you generate and hold the private key (or, in a multisig setup, one of several keys), and the key is what proves ownership and authorizes a transaction, not a login and password on someone else’s server.

For Bitcoin, that private key derives a tree of public addresses through the BIP-32 and BIP-44 standards covered later in this guide, all traceable back to a single seed phrase. For Ethereum and other account-based chains, one private key typically controls one address directly, which is why hardware wallets and software like Sparrow and Electrum spend so much effort on address verification: the private key never leaves the device, but the address it corresponds to has to be checked by a human every time money moves.

This distinction is also why “not your keys, not your coins” isn’t just a slogan. When Bybit lost roughly $1.5 billion, the coins that vanished belonged, cryptographically, to whoever controlled the compromised keys at that moment, not to the account holders whose balances showed up in the exchange’s ledger. Self-custody moves that cryptographic fact back in your favor. It also protects against risks that have nothing to do with hacking: a platform freezing withdrawals during a liquidity crunch, a regulatory order blocking access to an account, or a simple database error crediting the wrong balance. None of those scenarios can touch coins that never sat on the platform in the first place.

Self-Custody for Ethereum and Other Account-Based Assets

Everything above applies to Bitcoin’s UTXO model, but the same 12-step structure works for Ethereum and other account-based chains with a few adjustments. Instead of Sparrow or Electrum, the common software companion is MetaMask, paired with the same hardware wallets covered in step 2. Most current hardware wallets, including the Trezor and Keystone lines, support Ethereum signing alongside Bitcoin from the same seed phrase, so you don’t need a second device for a second chain.

The verification habits carry over directly: confirm the receive address on the hardware device’s screen before funding it, send a small test transaction first, and never approve a transaction you can’t read and understand on the device display, not just in the browser extension. Gas fees add a wrinkle Bitcoin users don’t deal with, so budget slightly more than the minimum for your test transaction to avoid it getting stuck during network congestion. If you’re holding ERC-20 tokens rather than plain ETH, double-check that your wallet software has added the correct token contract address, since a wrong contract address can make a real balance appear as zero.

Smart contract wallets like Safe add another option on top of a plain hardware wallet, letting you require multiple approvals for any transaction without relying on a single seed phrase at all. That approach trades some simplicity for a meaningfully stronger security model, and it’s worth considering directly if you’re setting up self-custody for a business or a shared fund rather than a personal holding.

Prerequisites: Hardware, Software, and Versions You’ll Need

You don’t need to buy anything expensive to start. A software wallet is enough for small balances, and you can upgrade to hardware later. Here’s what to have ready before you begin.

  • A hardware wallet if you’re moving a meaningful balance: current options include the Trezor Safe 7 or Safe 5 (both shipped firmware 2.12.5 on September 16, 2026), a Coldcard Q on firmware 1.5.2Q, or a Keystone 3 Pro on firmware 2.5.0.
  • A software wallet if you’re starting small: Sparrow Wallet or Electrum, both free and open source.
  • A dedicated computer, or at least a freshly rebooted one, with your OS fully patched.
  • Python 3.10 or newer and pip, only if you want to run the verification scripts in this guide.
  • A steel or paper backup medium for your recovery phrase, bought before you start, not after.
  • 90 uninterrupted minutes and a room with no cameras, smart speakers, or phones pointed at your desk.

One more thing worth stressing up front: nothing about seed generation should ever happen on a device connected to the internet. Every step below is written with that separation in mind. If you’re using a purely software wallet for now, that separation still matters. Generate the wallet on a machine you trust, ideally offline for the initial key generation, and only reconnect once the seed is written down and put away.

Step 1: Decide Your Custody Model Before You Buy Anything

Self-custody isn’t one thing. It ranges from a hot software wallet on your phone to a 2-of-3 multisig split across three devices in three locations. Match the model to the amount at stake and how often you need to move funds, not the other way around.

Custody ModelWho Holds the KeysSetup TimeBest For
Exchange custodialThe exchange0 minutesActive trading only
Software hot walletYou, on an online device15 minutesSmall amounts, frequent spending
Hardware single-sigYou, on an offline device45-60 minutesLong-term holdings
Multisig (2-of-3)You, across multiple devices2-3 hoursLarge holdings, inheritance planning

Most people reading this fall into the third row. If your balance is large enough that losing it would hurt for years, read the advanced tips section below before you finish setup, since it’s easier to plan for multisig now than to migrate into it later. Moving an existing single-sig wallet into a multisig arrangement means generating new addresses and transferring every coin again, so the earlier you decide, the less work it costs you down the line.

A Realistic Timeline

If you’re wondering how the 12 steps below map onto an actual afternoon, here’s the rough breakdown most first-time setups follow.

StageWhat HappensTime Estimate
Decide and buyPick a custody model and, if needed, order hardwareVaries (shipping)
Initialize and back upSteps 3-6: verify device, generate seed, write backup, add passphrase20-30 minutes
Software setupSteps 7-8: install companion app, verify receive address10-15 minutes
Fund and reconcileSteps 9-11: test transaction, batch withdrawals, on-chain check15-20 minutes, plus confirmation wait
Recovery drillStep 12: restore on a second device and verify15-20 minutes

None of these stages need to happen back to back. It’s fine to initialize a device one evening and run the recovery drill the next day once you’ve had time to store the backup properly.

Step 2: Choose Your Hardware or Software Wallet

If you’re going the hardware route, four current-generation devices dominate the market in September 2026. The Trezor Safe 7 pairs two secure elements, including a TROPIC01 chip, with a color touchscreen and both wired and wireless connectivity, and Trezor markets it as “quantum-ready” thanks to firmware signature verification built on SLH-DSA-128 with ML-DSA-44 device attestation, two of the post-quantum signature schemes shattered.io has covered in its cryptography reporting. The Trezor Safe 5 shares the same September 16, 2026 firmware release but skips the second secure element and wireless link. Coldcard’s Q model, running firmware 1.5.2Q as of a September 4, 2026 security-status update, leans toward a QR-code and microSD workflow for fully air-gapped signing. The Keystone 3 Pro, on firmware 2.5.0, takes the same air-gapped approach with no USB data connection at all.

WalletConnectivityCurrent FirmwareOpen Source
Trezor Safe 7USB-C + wireless2.12.5 (Sep 16, 2026)Yes
Trezor Safe 5USB-C2.12.5 (Sep 16, 2026)Yes
Coldcard QUSB-C, microSD, QR1.5.2Q (Sep 4, 2026 status)Yes
Keystone 3 PromicroSD, QR (no USB data)2.5.0Yes

Prefer software for now? Sparrow Wallet and Electrum both work as standalone hot wallets, and both can act as the companion app once you add a hardware device later, so starting with either doesn’t box you in.

Step 3: Verify Your Hardware Wallet Is Genuine

Before you initialize anything, check the tamper-evident packaging against the photos on the manufacturer’s own site, and confirm the device ships blank with no pre-set PIN or seed. A device that arrives already initialized has almost certainly been tampered with and should be returned, not used. Buy directly from the manufacturer or an authorized reseller listed on their site. shattered.io reported on a Coldcard incident tied to a five-year RNG flaw affecting older units, a reminder that firmware history matters as much as the box it arrived in.

If your device supports firmware updates before initialization, verify the update package rather than trusting the installer blindly. Most vendors, including Trezor and Coldcard, publish checksums and signatures alongside every release. Also check the physical seal itself: most current devices use a holographic sticker or a sealed tray that visibly tears if opened, and a photo comparison against the manufacturer’s official unboxing guide takes less time than the return process would if you skip it and get it wrong.

# Verify a firmware bundle before flashing it
sha256sum trezor-safe7-fw-2.12.5.bin
# Compare the printed hash against the one published on trezor.io/support

gpg --verify trezor-safe7-fw-2.12.5.bin.sig trezor-safe7-fw-2.12.5.bin
# Expected output ends with: gpg: Good signature from "SatoshiLabs "

Coldcard’s own firmware upgrade documentation and security FAQ walk through the equivalent process for that device, including how the device itself displays a hash you can cross-check on-screen.

Step 4: Initialize the Device and Generate Your Seed Offline

Power on the device and choose “create new wallet,” never “restore,” at this stage. The device generates entropy internally, using its own hardware random number generator, and turns that entropy into a 12, 18, or 24-word recovery phrase following the BIP-39 standard. Twenty-four words gives you the largest key space and is the safer default unless a specific wallet forces a shorter phrase.

The computer or phone you eventually pair the device with never sees this generation step, and it shouldn’t. The full BIP-39 specification, including the word list and checksum method, is published on the Bitcoin Improvement Proposals repository if you want to see exactly how the math works before trusting it with real funds.

Step 5: Back Up Your Seed Phrase the Right Way

Write the words on the steel or paper backup you bought in advance, in order, checking each one against the device screen as you go. Do this once, carefully, rather than rushing and rewriting it later. Store the backup somewhere fire-resistant and away from the device itself. A safe deposit box, a fireproof home safe, or a trusted family member’s house all work, and using two separate locations for two copies protects against a single disaster wiping out your only backup.

If you’d rather split the backup across multiple parties so no single copy is ever complete, shattered.io’s guide to Shamir Secret Sharing for Bitcoin seeds covers that approach in depth. It’s more setup work, but it removes the “one fireproof box holds everything” risk entirely.

Steel plates resist fire and water damage in ways paper never will, and a house fire is a far more likely threat to a seed backup than a targeted burglary. If a steel plate isn’t in budget yet, a laminated paper copy in a fireproof document bag is a reasonable interim step, just don’t let “interim” quietly become permanent.

Step 6: Add a Passphrase for an Extra Layer of Security

A BIP-39 passphrase, sometimes called the 25th word, combines with your seed to derive an entirely different set of addresses. Anyone who finds your written seed phrase alone still can’t reach funds protected by a passphrase, since the passphrase itself is never written down anywhere near the seed. shattered.io’s dedicated BIP-39 passphrase setup guide covers the hidden-wallet pattern in full, but the core trade-off is simple: forget the passphrase and the funds behind it are gone, even with a perfectly correct seed phrase in hand.

To understand why a passphrase changes everything about the derived addresses, it helps to see the math run once on a public test vector, never on your real seed.

# NEVER run this with your real seed phrase, and never on a device
# connected to the internet with real funds at stake.
# This uses the well-known public BIP-39 test vector for learning only.

from bip_utils import Bip39SeedGenerator, Bip44, Bip44Coins, Bip44Changes

test_mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"

seed_bytes = Bip39SeedGenerator(test_mnemonic).Generate()
bip44_ctx = Bip44.FromSeed(seed_bytes, Bip44Coins.BITCOIN)
account = bip44_ctx.Purpose().Coin().Account(0).Change(Bip44Changes.CHAIN_EXT)

for i in range(3):
    addr = account.AddressIndex(i)
    print(f"m/44'/0'/0'/0/{i}: {addr.PublicKey().ToAddress()}")

Run that script, then run it again with a passphrase added via Bip39SeedGenerator(test_mnemonic, "test-passphrase"), and every derived address changes completely. That’s the entire point: the same 24 words plus a different passphrase point to a different wallet, which is exactly what makes decoy and hidden-wallet setups possible.

Step 7: Install and Verify Your Companion Wallet Software

Download Sparrow or Electrum only from their official sites, never a search-ad link or a third-party mirror. Both publish signed releases, and both support connecting to a hardware wallet in watch-only or full signing mode. Install the app, plug in your hardware wallet (or skip this for a software-only setup), and let the app detect the device automatically.

# macOS/Linux example: verify a Sparrow release before installing
sha256sum -c sparrow-2.x-x86_64.tar.gz.sha256

# Electrum publishes GPG signatures for every release; verify similarly
gpg --verify Electrum-x.x.x.tar.gz.asc Electrum-x.x.x.tar.gz

Once connected, the software should show a zero balance and a fresh receive address, since this is a brand-new wallet with nothing in it yet. If it shows an existing balance you don’t recognize, stop and re-check that you initialized a new wallet in step 4 rather than restoring an old one by mistake.

Decide at this point whether the software will run in watch-only mode, tracking balances and building unsigned transactions without ever touching your keys, or full signing mode, where the hardware device connects directly for each approval. Watch-only is the safer default for a computer you use for other browsing and email, since a compromised browser still can’t move funds without the physical device in hand.

Step 8: Verify Your Receive Address Before You Fund It

Generate a receive address in your wallet software and then confirm it independently on the hardware device’s own screen, character by character or at minimum the first four and last four characters. Clipboard-hijacking malware that silently swaps a copied address for an attacker’s own is common enough that this check is worth the extra 20 seconds every single time, not just the first time.

Address-poisoning scams that send a fake zero-value transaction from a look-alike address into your transaction history are another reason to always confirm on-device rather than trusting your history. Never copy an address from a list of past transactions.

Step 9: Send a Small Test Transaction First

From your exchange, send a small amount, enough to cover the network fee with a little to spare, to the verified address before you move anything larger. Wait for at least one confirmation. Then check the balance independently through a public block explorer rather than trusting the wallet software alone, just in case there’s a display bug or a sync issue on your end.

curl -s "https://mempool.space/api/address/YOUR_ADDRESS_HERE" | python3 -m json.tool

# Example response shape:
# {
#   "chain_stats": {
#     "funded_txo_sum": 15000,
#     "spent_txo_sum": 0,
#     "tx_count": 1
#   }
# }

If funded_txo_sum matches what you sent and spent_txo_sum is zero, the test transaction landed cleanly and it’s safe to move on. Confirmation times vary by chain and by the fee you paid: a well-fee’d Bitcoin transaction typically confirms within 10 to 30 minutes, while Ethereum transactions usually settle in under a minute but still benefit from a block explorer check before you trust the balance shown in your wallet software.

Step 10: Withdraw the Remaining Balance in Batches

With the test transaction confirmed, withdraw the rest of your exchange balance. If the amount is large, consider splitting it into two or three transactions rather than one, both to stay under any exchange withdrawal limits and to avoid a single point of failure if one transaction has an issue. Generate a new receive address for each batch instead of reusing the same one, since address reuse makes it easier for outside observers to link your holdings together on a public chain.

Double-check the exchange’s own withdrawal confirmation screen against your verified address one more time before you approve each transaction. This is the single moment where a copy-paste mistake becomes permanent.

Most exchanges also require a whitelisting delay, often 24 to 48 hours, before a new withdrawal address becomes active for larger amounts. Plan around that delay rather than treating it as a bug, since it exists specifically to give you a window to cancel a withdrawal if your account gets compromised between adding the address and sending funds.

Step 11: Reconcile Your Balances On-Chain

Once every batch has confirmed, add up what your wallet software reports and compare it against what you withdrew, minus network fees. They should match exactly. For better privacy going forward, point Electrum or Sparrow at your own node instead of a public server, so your address history isn’t visible to a third-party server operator.

# Point Electrum at your own Electrum-protocol server (e.g. Electrs or Fulcrum)
electrum --oneserver --server=your-node.local:50002:s

# Or run against testnet first if you want to rehearse the whole flow
# with worthless test coins before doing it on mainnet
electrum --testnet

Running your own backend removes the need to trust a stranger’s server with your entire transaction history, though a public server over Tor is a reasonable middle ground if running a full node isn’t practical yet.

Step 12: Run a Full Recovery Drill Before You Trust the Setup

This is the step almost everyone skips, and it’s the one that actually proves your backup works. Take a second device, either a spare hardware wallet or a factory-reset version of the same model, and restore it from your written seed phrase alone, without looking anything up. Confirm the first few receive addresses match exactly what your live wallet shows. If they don’t match, you have a transcription error in your backup, and you want to find that out now, with the drill, not years from now when you actually need the recovery.

If you’re running a multisig setup, this is also where you test the full partially signed Bitcoin transaction (PSBT) flow end to end, so every cosigner knows their part before it matters.

# PSBT workflow using bitcoin-core's CLI, once a hardware signer
# has added its signature to the PSBT via Sparrow or Electrum
bitcoin-cli walletprocesspsbt "cHNidP8BAH..."
bitcoin-cli finalizepsbt "cHNidP8BAH..."
bitcoin-cli sendrawtransaction "0200000001..."

A simple recovery checklist script, run before you consider the setup finished, keeps the drill from turning into a rushed afternoon task you never quite complete.

#!/usr/bin/env bash
# recovery_checklist.sh - run through this before trusting a new wallet setup
echo "[ ] Restored seed on a second, separate device"
echo "[ ] First 3 receive addresses match the live wallet"
echo "[ ] Passphrase (if used) tested on the restored device too"
echo "[ ] Backup copies stored in at least two separate locations"
echo "[ ] Test transaction confirmed and reconciled on-chain"
echo "[ ] Firmware on all signing devices is the latest stable release"

Together, the checksum verification from step 3, the derivation script from step 6, and this checklist form a small, complete toolkit you can reuse for every wallet you set up after this one, hardware or software.

Advanced Tips: Multisig, Air-Gapped Signing, and Running Your Own Node

Once single-sig self-custody feels routine, a few upgrades close most of the remaining gaps. A 2-of-3 multisig setup, walked through in shattered.io’s Bitcoin multisig wallet setup with Sparrow guide, means no single device or location can move funds alone, which also solves a lot of inheritance and shared-custody problems. For Ethereum-side assets, the earlier Safe multisig setup guide covers the equivalent pattern for smart-contract wallets.

Fully air-gapped signing, using a Coldcard Q or Keystone 3 Pro’s QR-code or microSD workflow instead of any USB data connection, removes an entire class of USB-based attacks since the signing device never touches an internet-connected computer directly. Pair that with your own Bitcoin node and an Electrum-protocol server like Electrs, ideally reachable only over Tor, and neither your balance nor your address history ever has to pass through a server you don’t control.

Running a full Bitcoin node yourself takes roughly 600GB to 700GB of disk space and a stable always-on connection, which is more commitment than most people want on day one. A cheaper middle step is running just an Electrum-protocol server like Electrs against a pruned node, or connecting through Tor to a public server so at least your IP address isn’t tied directly to your wallet queries.

Multisig also solves a problem single-sig can’t: what happens to the funds if something happens to you. A 2-of-3 arrangement lets you give one key to a spouse or attorney, keep one yourself, and store one in a safe deposit box, so no single person can move funds alone but any two can recover them if needed. That’s a meaningfully better outcome than a single seed phrase that only you know how to use.

None of this is required on day one. Build the single-sig habit first, run the recovery drill, and layer in multisig or air-gapping once the basics feel automatic.

Common Pitfalls That Wreck Self-Custody Setups

Most self-custody losses trace back to one of a handful of repeated mistakes, not to some exotic exploit. Watch for these before they cost you a wallet.

  • Photographing or typing the seed phrase into any device. A phone photo can sync to a cloud backup before you even think about it.
  • Buying a hardware wallet from a secondhand marketplace instead of the manufacturer directly, where a pre-loaded seed can drain funds the moment you fund the device.
  • Storing the only backup copy in the same room, or even the same building, as the device itself.
  • Skipping the test transaction in step 9 and sending a full balance on the first try.
  • Reusing the same receive address for every deposit, which makes your holdings trivially easy to track on-chain.
  • Never running the recovery drill, and discovering a transcription error only after the original device is lost or broken.
  • Letting firmware go months without an update, missing security fixes that vendors like Trezor and Coldcard ship on a regular cadence.
  • Setting a weak or shared PIN on the device itself, treating it as an afterthought when it’s actually the last line of defense if the device is ever lost or stolen.

Troubleshooting Your Self-Custody Setup

Even a careful setup runs into friction. Here’s what to check first for the issues that come up most often, before assuming something is broken beyond repair.

  • Computer doesn’t recognize the hardware wallet: try a different USB cable and port first, since a charge-only cable is a common culprit.
  • Firmware update stalls mid-install: don’t unplug the device. Most vendors design for recovery from an interrupted flash, but pulling power mid-write can brick it.
  • Wallet shows a zero balance after restoring a seed: check the derivation path and script type (legacy versus SegWit versus Taproot) match what generated the original addresses.
  • Transaction stuck unconfirmed for hours: use your wallet’s replace-by-fee or child-pays-for-parent option to bump the fee rather than resending.
  • Restored wallet looks empty but you know you used a passphrase: re-enter the exact passphrase, since even a single character difference derives a completely different, empty wallet.
  • One seed word gets rejected during restore: check for transcription errors against the official BIP-39 word list, since only 2,048 specific words are valid.
  • Sparrow or Electrum won’t connect to your node: confirm the server’s port is open and that you’re using the correct protocol flag (SSL versus plain TCP).
  • Address on the computer screen doesn’t match the hardware device screen: stop immediately and do not send funds. This is the exact scenario the on-device verification in step 8 exists to catch.
  • Multisig quorum can’t sign because one cosigner device is lost: this is precisely why 2-of-3 rather than a stricter threshold is the common recommendation, so one lost device doesn’t lock funds permanently.
  • Antivirus software blocks the hardware wallet’s USB bridge: add an exception for the specific vendor bridge process rather than disabling antivirus entirely.
  • Balance shows correctly in the block explorer but not in your wallet software: force a full rescan of the blockchain history for that wallet, since some software wallets only scan a limited address gap by default and can miss funds sent to an address further down the derivation path.

Frequently Asked Questions

Is self-custody actually safer than keeping crypto on an exchange?

It removes exchange-side risk, like the Bybit hack, entirely, but it shifts responsibility for backup and operational security onto you. Self-custody is safer against a repeat of an exchange breach and riskier against your own mistakes, which is exactly why steps like the recovery drill in step 12 matter so much. Think of it as trading one risk for a different, more controllable one: instead of trusting a third party’s security team, you’re trusting your own process, and this guide exists to make that process repeatable rather than a one-time leap of faith.

What happens if I lose my hardware wallet?

Nothing, as long as your seed phrase backup is intact. Buy a new device, or a different brand entirely, and restore from the written seed. This is exactly what the recovery drill in step 12 tests before you actually need it.

Do I need a passphrase in addition to my seed phrase?

Not for everyone. A passphrase adds meaningful protection against someone finding your written seed, but it also adds a second secret you must never forget and never write near the seed itself. For smaller balances, a well-backed-up seed alone is often enough.

Can I use a software wallet instead of a hardware wallet?

Yes, for smaller amounts. Sparrow and Electrum are both solid choices, and either can later connect to a hardware device once your balance grows enough to justify the extra cost and setup time.

How much crypto should I move to self-custody at once?

Start with the small test transaction described in step 9, confirm it lands correctly, then move the rest in batches as described in step 10. There’s no fixed dollar threshold, only the discipline of testing before committing the full balance.

What’s the difference between BIP-39 and BIP-44?

BIP-39 defines how a seed phrase turns into cryptographic seed bytes. BIP-44 defines how those seed bytes get organized into a structured tree of accounts and addresses, using paths like m/44'/0'/0'/0/0, which is what lets one seed manage multiple accounts and coin types cleanly.

Is multisig necessary for a typical user?

Not for everyday balances. It becomes worth the extra setup time, covered in the advanced tips above, once the amount at stake would meaningfully change your life if a single device or backup failed.

How do I know my hardware wallet hasn’t been tampered with?

Buy directly from the manufacturer, check that the device arrives blank with no pre-set PIN, and verify any firmware update against the vendor’s published checksum or signature before installing it, as shown in step 3. The Ledger Academy and each vendor’s own security documentation walk through the specific checks for their hardware.

Can I self-custody Ethereum and Bitcoin with the same seed phrase?

Yes, on most current hardware wallets. A single BIP-39 seed can derive separate account trees for Bitcoin, Ethereum, and other supported chains at the same time, using different derivation paths under BIP-44. Your companion software (Sparrow or Electrum for Bitcoin, MetaMask for Ethereum) just needs to be pointed at the correct path for each chain.

What’s the single most common mistake first-time self-custody users make?

Skipping the recovery drill in step 12. It’s the step with no immediate reward, since the setup already appears to work, which is exactly why it gets skipped and exactly why a transcription error in a written seed phrase so often surfaces only after it’s too late to fix.