Inheritance features in crypto are not generally built into the token itself, but are enabled by external wallet apps and platforms. Options like DeadMan's Vault, Nunchuk, and Bitkey use specific technologies—such as time-locked transactions, multisig, or smart contracts—to transfer assets to heirs after a period of user inactivity. These services allow you to designate beneficiaries who gain access if you miss automated check-ins.
If by “natively” you mean the blockchain/token itself has a built-in dead-man’s-switch inheritance mechanism, no major token currently does. The feature generally lives at the wallet, smart-contract, or script layer. parse.gl
The closest options are:
Bitcoin (BTC): Bitcoin Script supports relative timelocks (CSV), which can implement a true on-chain recovery/inheritance path. Wallets such as Liana use this approach.
Ethereum / EVM: Smart contracts can implement inactivity timers, beneficiary claims, and check-in mechanisms, and can handle ETH plus ERC-20/NFT assets. There are also proposed inheritance standards such as ERC-7878.
Solana (SOL): There are now concrete dead-man's-switch implementations supporting SOL, SPL tokens, and NFTs, although this is an application/protocol implementation rather than a native consensus feature.
Stellar (XLM): Soroban's TTL/state-expiration machinery can be used to build an automatic inheritance vault; one current implementation uses check-ins to extend the TTL.
If your goal is specifically “I stop checking in → my heir automatically gets my crypto,” Bitcoin and Ethereum/EVM are the most established architectural choices, but neither has this as a built-in feature of the token itself.
One important distinction: if you want a ready-to-use wallet rather than a programmable blockchain, there are now wallets advertising native inheritance features. For example, Bron says its wallet has built-in inheritance across supported networks using MPC rather than smart contracts holding the funds.
If you tell me whether you're looking to hold BTC, ETH/USDC, or another asset, I can identify the currently usable options and compare their trust model, inactivity mechanism, and failure modes.
However, "native support" looks very different depending on the ecosystem, trading off between protocol-level consensus vs. smart-contract flexibility.
1. The Bitcoin Ecosystem (Native Protocol-Level Timelocks)
If by “natively” you mean the blockchain itself has primitives that can implement a dead-man’s switch without relying on a centralized custodian, there are two notable ecosystems:
Bitcoin (BTC): Bitcoin Script supports relative timelocks via CSV (CheckSequenceVerify). This can create a recovery path that becomes spendable by an heir after a specified period of inactivity. Wallets such as Liana and Nunchuk build inheritance schemes around this.
Ethereum/EVM (ETH and ERC-20s): Smart contracts can implement heartbeat/check-in schemes, time locks, beneficiaries, and automatic transfers. For example, Lockd describes an entirely on-chain Ethereum implementation.
Solana (SOL/SPL tokens): There are now purpose-built implementations such as Dead Man’s Vault, which uses on-chain heartbeat state and distributes SOL, SPL tokens, and NFTs to predetermined beneficiaries after the grace period.
So there isn't a major token whose base protocol literally knows that its owner has died. The “dead man's switch” is generally a script/smart-contract layer built on top of the blockchain.
If you're specifically looking for a wallet you can actually set up today for inheritance, rather than an ecosystem you could build a switch on, the answer changes considerably. I can compare the current BTC, ETH, and SOL options by self-custody, trust assumptions, automaticity, and what happens if the provider disappears.
Strictly speaking, no major mainstream token ecosystem natively builds a mandatory "dead man's switch" into its base protocol layer as a default account feature , because automated time-based asset forfeiture or transfer introduces severe systemic risks (such as lost keys or hospitalization causing accidental loss of funds).[](https://www.ledger.com/academy/topics/crypto/what-happens-to-your-crypto-when-you-die-the-complete-guide)
However, programmable blockchains support native cryptographic primitives (like absolute or relative timelocks) that allow you to construct a trustless dead man's switch at the script or smart contract level.[](https://www.spark.money/glossary/dead-man-switch)
The primary ecosystems that support this natively via their scripting or execution layers include:
The Practical Consensus: Most institutional crypto-inheritance planners (such as or ) actually avoid fully automated dead man's switches because of false-positive risks. Instead, they use a (e.g., a 2-of-3 key setup where you hold 2 keys, or you hold 1, an heir holds 1, and a service holds 1) requiring an offline legal death certificate verification rather than an automated block-time countdown.[](]()]()
If you want to explore this further, tell me:
Do you prefer a fully trustless on-chain setup (no third parties) or a collaborative custody service with legal backing?
Which specific ecosystem (Bitcoin vs. Ethereum/EVM) do you prefer holding your primary assets on?
I can help outline the exact workflow and risk profile for that route.
If by “natively” you mean the blockchain/token itself has a built-in inheritance mechanism, no major token currently has a general-purpose native dead-man’s switch at the protocol level. The feature is usually implemented through wallet logic or smart contracts.
For actual usable implementations:
Bitcoin (BTC) supports timelocked inheritance directly through Bitcoin Script primitives such as relative timelocks/CSV. Wallets such as Liana can use this to create a normal spending path for you and a delayed recovery path for an heir if you stop refreshing the arrangement.
Solana (SOL/SPL tokens) now has projects such as Dead Man’s Vault that implement heartbeat-based inheritance at the on-chain program level, with configurable beneficiaries and automatic distribution after the grace period.
Ethereum/EVM is highly programmable and can implement the same pattern with smart contracts, but it isn't an Ethereum-native feature.
Stellar (XLM) has a newer Soroban implementation using contract TTL expiration as the inheritance trigger, but this is an application built on Stellar rather than a protocol-level inheritance feature.
So if your requirement is specifically “I want a crypto asset whose underlying blockchain can enforce a dead-man’s-switch inheritance arrangement without trusting a custodian,” BTC is the clearest established example. If you mean “I want a ready-to-use wallet that handles inheritance for me,” the answer is different: several newer wallets/services now provide this across multiple chains. For example, Bron advertises wallet-level inheritance across supported networks, while NoKLock implements an on-chain inheritance mechanism on Polygon.
One important caveat: a pure inactivity timer can trigger while you're alive but incapacitated or simply unable to check in. A long grace period and/or multiple recovery mechanisms are therefore important for an inheritance setup.
If by “natively” you mean the blockchain/token itself has a built-in inheritance mechanism, no major crypto ecosystem currently provides a true native dead-man’s switch at the protocol level. The trigger generally has to be implemented by a wallet or smart contract.
For practical options:
Ethereum / EVM (ETH) — supports programmable smart contracts and wallets, so an inactivity timer + beneficiary can be implemented for ETH and ERC-20 assets. There are also proposals such as ERC-7878 for bequeathable contracts.
Solana (SOL) — has concrete dead-man's-switch implementations. For example, Dead Man's Vault supports SOL, SPL tokens and NFTs with periodic heartbeats and beneficiary payouts, although this is an application rather than a native Solana protocol feature.
Stellar (XLM) — Soroban makes this particularly straightforward; projects such as InheritVault implement check-ins and automatic beneficiary claims for XLM/USDC.
Polygon — NoKLock currently describes an on-chain inheritance system using Polygon smart contracts and Chainlink, including a dead-man's-switch trigger.
One important distinction: a wallet can have native inheritance even though the underlying token doesn't. For example, Bron says its wallet has built-in digital inheritance across supported networks, using MPC and time-lock/multi-party safeguards rather than putting the assets into an inheritance smart contract.
So if your requirement is specifically “I want an on-chain, trust-minimized dead-man's switch for my crypto”, I'd focus on EVM, Solana, or Stellar implementations, rather than looking for a special “inheritance token.”
How it works natively: You create a conditional spending script. Key A (you) can spend the Bitcoin at any time. Key B (your heir) can also spend the Bitcoin, but only after a specific relative time lock expires (e.g., 6 months). To keep the switch from triggering, you periodically "refresh" the timer by signing a transaction moving the funds to a fresh address under the same rules. If you pass away or become incapacitated, you stop refreshing, the clock runs out, and your heir’s key becomes active.[](https://bitkit.to/learn/dead-mans-switch-bitcoin-inheritance)
Shamir’s Secret Sharing (SLIP-0039): Supported natively by hardware wallets like Trezor Safe , your seed phrase is split into multiple unique shares (e.g., any 2 out of 3 parts required). You give one to a spouse, one to a lawyer, and keep one. No timers are needed; your family recovers the wallet cooperatively after your passing.
Are you looking for a fully decentralized/DIY approach (like Bitcoin timelocks or a custom smart contract), or would you prefer a collaborative service that uses human executors and multisig custody?
If by “native” you mean the blockchain/token protocol itself has a built-in dead man’s switch, the answer is: no major cryptocurrency (BTC, ETH, SOL, etc.) has a native inheritance switch at the consensus layer. A blockchain cannot know whether a person is alive; the mechanism has to be implemented through scripts, smart contracts, or wallet infrastructure.
The ecosystems that are closest are:
Ecosystem
Token(s)
Why it fits
Caveat
Ethereum / EVM
ETH + ERC-20 tokens
Most mature smart-contract ecosystem; you can build inheritance vaults with inactivity timers, beneficiaries, multisig, and account-abstraction wallets
Not a protocol-native ETH feature
Bitcoin
BTC
Bitcoin Script supports timelocks and more constrained inheritance patterns (for example, a recovery path that becomes spendable after a delay)
Less flexible; no general smart contracts
Solana
SOL + SPL tokens
Newer programs can implement heartbeat/dead-man-switch vaults and automated beneficiary payouts
More application-specific and less battle-tested
Polygon / other EVM chains
MATIC/POL ecosystem assets, ERC-20s
Cheap execution makes inheritance contracts practical
If you are choosing an ecosystem specifically for a self-custody inheritance wallet, I would generally pick Ethereum/EVM, not because ETH has a built-in inheritance feature, but because it has the strongest tooling for programmable ownership:
smart-contract wallets
multisig
timelocks
automated keep-alive/check-in logic
broad support for tokens and NFTs
There are also emerging standards and projects exploring inheritance-style contracts on Ethereum.
If you want something closer to “ready-made”
Some wallets/protocols implement the feature at the wallet layer rather than the token layer. For example, Bron advertises a built-in digital inheritance workflow across supported networks using MPC rather than requiring users to share seed phrases.
There are also more explicitly on-chain dead-man-switch designs:
NoKLock uses Polygon smart contracts and a trigger mechanism for inheritance.
Solana projects such as Dead Man’s Vault and Heres are examples of application-level inheritance systems built around SOL/SPL assets.
Practical recommendation
For a long-term inheritance setup, I would prioritize:
EVM wallet + audited inheritance contract/multisig for ETH, stablecoins, and ERC-20s.
Bitcoin-specific inheritance tooling if your main holding is BTC.
Avoid choosing a token just because it advertises “dead man’s switch” — the important part is the security model of the inheritance mechanism, not the coin.
The key design question is whether you want:
automatic transfer after inactivity (“I stop checking in → heir receives funds”), or
a recovery plan (“my heirs can access assets with multiple safeguards after my death”).
No major layer-1 token ecosystem currently supports a true "dead man's switch" natively built into its base protocol wallet layer (i.e., built directly into the core consensus rules or default software of Bitcoin, Ethereum, or Solana).
This absence is intentional: a protocol-native dead man's switch requires the blockchain to track time relative to human inactivity and automatically reassign private key ownership without a signature from the owner. Doing this natively at the base layer creates massive security risks (e.g., state-level censorship, false-positive asset seizures, or consensus bugs if a user is just in a coma or offline).
Instead, dead man's switches are implemented using smart contract logic, programmable cryptography , or pre-signed transactions . The leading ecosystems that support these approaches include:
How it works: Smart contracts can function as an inactivity timer. A popular method involves building or plugging a dead-man's switch module into an account-abstraction or multisig wallet like Safe . Every time you interact with the wallet or ping it, the inactivity timer resets. If you fail to ping it within a set timeframe (e.g., 90 days), a designated heir address can trigger the contract to take over.
How it works: Bitcoin doesn't use smart contracts for this, but it supports a native script-based approach using pre-signed transactions with time-locks (nLockTime or OP_CHECKLOCKTIMEVERIFY) . You create a transaction ahead of time that sends your funds to an heir, locked until a future date. While alive, you periodically re-sign and push the lock date further into the future. If you die, you stop updating it, and the transaction eventually becomes valid to broadcast. Collaborative custody providers like Nunchuk or Casa offer guided workflows around assisted inheritance, though they rely on multi-sig key-splitting rather than a pure automated switch. [](https://www.reddit.com/r/BitcoinBeginners/comments/1qb59y8/are_there_any_hardware_wallet_that_supports_dead/)[[2](https://forum.safefoundation.org/t/dead-man-s-switch-module/6948)](https://.io/blog/bitcoin-inheritance-guide)[[3]()]()
Solana (SOL)
How it works: Because of Solana's high speed and low transaction fees, developers have built experimental program-based escrow frameworks (such as open-source repositories like Eternal Key ) that lock SOL or SPL tokens into an inactivity escrow requiring periodic liveness check-ins. [](https://github.com/retrogtx/eternal-key)
If you'd like to narrow this down, tell me:
Which specific token or asset are you primarily trying to pass down?
Do you prefer a trustless smart-contract approach (like Ethereum/Safe) or a collaborative custody/hardware setup (like Bitcoin/Casa)?
