Forem: duzF8mjXkVea

The Dead Man’s Switch Paradox: Coding Trustless Inheritance in Python

duzF8mjXkVea — Sat, 31 Jan 2026 16:26:04 +0000

Most "Digital Inheritance" services are architecturally flawed. They operate on a Custodial Model:

You upload your private keys/passwords to their database.

They promise (pinky swear!) they are encrypted.

When you die, they send the data to your wife.

As a developer, this is a nightmare. If I upload my seed phrase to your server, I am trusting your sysadmin, your database config, and your immunity to a $5 wrench attack. I don't trust any of those things.

So I tried to solve the Dead Man’s Switch Paradox: How can a system deliver a secret it doesn't know? How can I ensure the data is recoverable only after I disappear, but mathematically impossible to access before?

Here is how I architected Deadhand Protocol (Open Source) to solve this using Python.

The Logic: "Fail-Deadly" vs "Fail-Safe"
Standard software is "Fail-Safe" (if it breaks, it locks down). A Dead Man's Switch must be "Fail-Deadly". It does nothing until a negative condition is met (Silence).

The core loop is simple async logic, but the Payload Delivery is where the magic happens.

The Cryptography: Client-Side AES + The "Trigger" Key
I refused to store raw data. Instead, I implemented a split-key architecture.

The Client-Side Encryption Before the data leaves the user's browser/terminal, we encrypt it using AES-GCM. The key to decrypt this payload is NOT sent to the server yet. The server receives an encrypted blob. It has no idea if it holds a Bitcoin wallet or a recipe for lasagna.
The Trigger Mechanism The decryption key (or a shard of it) is the "Trigger." The user stores this key locally. The Beneficiary (the person receiving the data) receives a "Dormant Link."
The Event Loop The backend (FastAPI) runs a background worker (Celery/Redis) checking the last_heartbeat timestamp.

Python

Pseudo-code of the Reaper Logic

async def reaper_job():
threshold = now() - timedelta(days=30)
dead_users = db.query(User).filter(User.last_heartbeat < threshold).all()

for user in dead_users:
    # The user failed to check in.
    # We verify if the 'Grace Period' has passed.
    execute_protocol(user)

The Hard Part: Avoiding the "Honeypot"
If I store the "Decryption Key" on the database waiting to be emailed, my database is a honeypot. Hackers will target it to steal the keys of 1,000 users.

The Solution: Shamir’s Secret Sharing (Concept) In the next version (v2), we are implementing SSS to split the key into 3 parts:

Shard A: Held by the User (destroyed upon death).

Shard B: Held by the Server (The "Deadhand").

Shard C: Held by the Beneficiary.

To reconstruct the secret, you need 2 of 3.

While alive: User has A. Server has B. Beneficiary has C. (Server + Beneficiary cannot conspire because they don't know each other).

Upon Death: Server sends Shard B to Beneficiary. Beneficiary combines B + C.

Result: The Server never had enough shards to decrypt the data. The admin (me) cannot steal your coins even if I wanted to.

Why I Open Sourced It
Security tools require Zero Trust. You shouldn't trust my backend. You should trust the math. By making the repo public, anyone can verify:

The Heartbeat logic is robust.

The encryption is standard (no "roll your own crypto").

There are no backdoors.

If you are a dev, you have a responsibility to handle your "Bus Factor." Don't rely on Google's "Inactive Account Manager" (which can be disabled by policy changes). Rely on code you can audit.

Check the implementation here: 👉 github.com/pyoneerC/deadhand

(Pull Requests for the SSS implementation are welcome. Let's harden this thing.)

[Boost]

duzF8mjXkVea — Sat, 31 Jan 2026 16:20:54 +0000

bus factor = 1 (why i coded a kill switch for my death) - DEV Community

look, i’m a dev. i build redundant systems for a living. load balancers, failovers, backups for the...

dev.to

bus factor = 1 (why i coded a kill switch for my death)

duzF8mjXkVea — Sat, 31 Jan 2026 16:20:44 +0000

look, i’m a dev. i build redundant systems for a living. load balancers, failovers, backups for the backups. we spend 40 hours a week making sure a stupid saas app has 99.9% uptime.

but last tuesday i was sitting in my apartment in mendoza and realized my own "uptime" is fragile as hell.

if i walk outside and get hit by a bus (the literal bus factor), my entire digital life is bricked. zero. gone.

i have cold storage. i have ssh keys to servers. i have 24-word seeds written on paper in a drawer. you know what happens if i die? my family finds a piece of paper with random words on it, assumes it’s trash, and throws away generational wealth. or worse, they hire a lawyer who doesn't know what a ledger is.

"not your keys, not your coins" is a cool slogan until you realize that when you die, "not your pulse, not your coins."

it terrified me. so i opened vim and fixed it.

i built deadhand.

it’s messy, it’s python, and it’s open source. it’s a dead man’s switch.

the logic is stupidly simple because simple things don't break:

it emails me every 30 days. "hey, you alive?"

i click a link. timer resets.

if i dont click... it waits.

if i still dont click (day 60, day 90)... it assumes i’m dead or incapacitated.

it executes the payload.

it sends the encrypted shards/keys/instructions to my beneficiary. no lawyers. no probate court. just code executing a contract.

i made it open source because you’d be an idiot to trust a closed-source app with this. you need to see the code to trust it. you can self-host it if you’re paranoid (like me).

i didn't build this to make a unicorn startup. i built it because i couldn't sleep.

if you hold crypto, or manage servers, or have secrets you want passed down... stop pretending you're immortal. fix your bus factor.

repo is here. star it, fork it, audit it. https://github.com/pyoneerC/deadhand

don't let your keys die with you.

-max

Deadhand: Split your seed phrase into shards. Inherit crypto without trust.

duzF8mjXkVea — Wed, 28 Jan 2026 11:44:35 +0000

Open source at:

https://github.com/pyoneerC/deadhand

Dead Man's Switch: How to Automate Crypto Inheritance

duzF8mjXkVea — Wed, 28 Jan 2026 11:43:01 +0000

TL;DR: A dead man's switch is a mechanism that triggers automatically when you stop responding. Combined with Shamir's Secret Sharing, it enables trustless crypto inheritance without giving anyone premature access.

Full article: https://www.deadhandprotocol.com/blog/dead-mans-switch-crypto-inheritance

Shamir's Secret Sharing Explained (For Normal People)

duzF8mjXkVea — Wed, 28 Jan 2026 11:39:32 +0000

TL;DR: Shamir's Secret Sharing splits your seed phrase into multiple parts. You need a minimum number of parts to recover the original. One part alone reveals nothing.

Example: Split into 3 parts. Any 2 can recover the seed. But 1 part is useless.

I Audited Every Crypto Inheritance Protocol (So You Don't Have To)

duzF8mjXkVea — Mon, 26 Jan 2026 18:35:17 +0000

TL;DR: I spent 3 months auditing Sarcophagus, Inheriti, and Casa. They all had deal-breakers (Centralization, Tokenomics, or Cost). So I built Deadhand Protocol: the first open-source, non-custodial Dead Man's Switch for crypto. Here is the code.

The "Bus Factor" ProblemIf I get hit by a bus tomorrow, my Bitcoin dies with me.This is the "Self-Custody Paradox." We spend years learning to secure our keys from hackers, but we accidentally secure them from our own families.I looked for a solution. I wanted something:Trustless (No lawyers holding paper keys).Automated (Triggered by my inactivity).Open Source (I need to verify the cryptography).I found nothing that worked. Here is my audit of the current landscape in 2026.The Audit: What Exists?1. The "Lawyer" Method (Paper) 📄Mechanism: Write seed phrase on paper. Give to lawyer.The Flaw: Lawyers get hacked. Lawyers lose papers. Lawyers can collude with beneficiaries while you are still alive.Verdict: F- (Security Risk).2. Casa (Multisig Inheritance) 🔐Mechanism: 3-of-5 Multisig. Casa holds a key, you hold keys, beneficiary holds a key.The Good: Great UX. Reliable.The Bad: Expensive ($250+/year). It requires KYC. It relies on Casa existing in 10 years.Verdict: B+ (Good for non-technical whales).3. Sarcophagus (DAO/Token) ⚰️Mechanism: Encrypts data on Arweave. "Archaeologists" (node operators) resurrect it for a fee (SARCO tokens).The Good: Decentralized. Cool tech.The Bad: Complexity Hell. You need ETH + SARCO tokens. You need to manage "resurrection windows." If the token price crashes, the incentive model breaks.Verdict: C (Too complex for simple inheritance).4. Inheriti (SafeHaven) 🛡️Mechanism: Splits keys using Patents/Hardware.The Good: Secure hardware integration.The Bad: Proprietary. It is not fully open source. "Patent Pending" means I cannot audit the logic myself.Verdict: C+ (Trust-based).The Solution: Deadhand Protocol 💀I realized that inheritance is not a blockchain problem. It is a cryptography problem.We don't need a token. We need Shamir's Secret Sharing (SSS) + A Dead Man's Switch.So I built Deadhand.How it Works (The Engineering)Deadhand is a "Server-Assisted" Non-Custodial protocol. The server acts as the heartbeat monitor, but it never sees your keys.Step 1: The Split (Client-Side)We use Shamir's Secret Sharing (SSS) to split your secret (Seed Phrase) into 3 Shares.Share A: Stored on your device (Local).Share B: Encrypted and stored on the Server (Deadhand).Share C: Given to your Beneficiary (Email/Link).Step 2: The HeartbeatAlive: You check in (email link / API call) every 30 days. The server keeps Share B encrypted.Dead: You miss X check-ins. The server releases Share B to the Beneficiary.Step 3: The ReconstructionThe Beneficiary combines Share C (which they have) + Share B (from the server).Share B + Share C = Secret.The Server never had enough shares to reconstruct it.The Beneficiary never had enough shares to steal it early.The Code (Python/FastAPI)The core logic relies on the secretsharing library. Here is the simplified logic:Pythonfrom secretsharing import SecretSharer

def create_deadhand_vault(secret_key):
# 1. Split key into 3 parts (Need 2 to recover)
shares = SecretSharer.split_secret(secret_key, 2, 3)

# 2. Distribute
user_share = shares[0]
server_share = encrypt_for_server(shares[1]) # Server can't read this yet
beneficiary_share = shares[2]

return user_share, server_share, beneficiary_share

Comparison Matrix FeatureDeadhand 💀Casa 🏠Sarcophagus ⚰️Lawyers ⚖️Open Source✅ YES❌ No✅ Yes❌ NoCostFree / One-time$250/yr+Gas + Tokens$1,000+Token Required❌ NO❌ No✅ Yes (SARCO)❌ NoCustodyNon-CustodialSemi-CustodialNon-CustodialCustodialComplexityLow (Web2 UX)LowHighMediumConclusionIf you want to pay $250/year for someone to hold your hand, use Casa.If you want to play with DeFi tokenomics, use Sarcophagus.If you want Sovereign, Free, Open-Source Code that you can audit yourself, use Deadhand.Code is Law. Death is certain. Plan accordingly.🔗 Links:Website: [Your Website Link]GitHub: [Your GitHub Link]Twitter: [@YourHandle]

hello world

duzF8mjXkVea — Fri, 23 Jan 2026 22:37:55 +0000

hello

What Happens to Your Crypto When You Die???

duzF8mjXkVea — Fri, 23 Jan 2026 22:00:26 +0000

visit deadhandprotocol.com :) open sorce tool

[Boost]

duzF8mjXkVea — Fri, 23 Jan 2026 21:59:02 +0000

What Happens to Your Crypto When You Die? - DEV Community

TL;DR: Without a plan, your crypto is gone forever. Your family cannot access it. Banks cannot help....

dev.to

What Happens to Your Crypto When You Die?

duzF8mjXkVea — Fri, 23 Jan 2026 21:58:34 +0000

TL;DR: Without a plan, your crypto is gone forever. Your family cannot access it. Banks cannot help. Courts cannot help. It is just gone.

The Harsh Reality
When you pass away, your crypto does not go to your family or the government. It just sits there, forever, and becomes inaccessible.

Why? Because you are the only person who knows your seed phrase.

Real Stories of Lost Fortunes
The $240 Million Bitcoin Inheritance
In 2021, a crypto investor died suddenly. His family knew he had Bitcoin worth millions, but they could not access it. The seed phrase was written on a piece of paper that was lost during a move.

$240 million. Gone.

The Quadriga Exchange Disaster
When QuadrigaCX founder Gerald Cotten died in 2018, he took $190 million of customer funds with him. He was the only one with the private keys. His widow, the company, and the courts were unable to recover a single cent.

$190 million. Lost forever.

Your Story (If You Do Not Act)
Imagine you have $50,000 in Bitcoin. You die in an accident tomorrow. Your spouse and kids know you have crypto, but they do not know your seed phrase, which wallet you used, or which exchange held your assets.

It is all gone.

Why Traditional Inheritance Does Not Work for Crypto
Banks Can Reset Passwords. Crypto Cannot.
If you die with $100,000 in a bank account, your family can show a death certificate and the bank will release the funds. Crypto does not work that way. There is no customer service or central authority to call. Your seed phrase is the only way to access your funds.

Lawyers Cannot Help
Your lawyer cannot subpoena Coinbase for your seed phrase because Coinbase does not have it. They cannot ask a judge to reset your wallet. Crypto is designed to be inaccessible without the seed phrase: that is the entire point.

The 3 Terrible Options Most People Choose
Option 1: Tell Your Spouse Your Seed Phrase
This creates a single point of failure. If they forget it, lose it, or get hacked, you are both out of luck. Also, if they pass away first or if the relationship changes, your security is compromised.

Option 2: Write It Down and Put It in a Safe
Safes get stolen. Houses burn down. Papers get thrown away. If you pass away, does your family even know where the safe is or what the combination is?

Option 3: Do Nothing and Hope for the Best
This is what 90% of crypto holders do. It is the worst option. When you die, your crypto dies with you.

The Solution: Shamir's Secret Sharing
This is why deadhand exists. Instead of having one seed phrase that acts as a single point of failure, you split it into 3 shards:

Shard A: You keep (e.g., in a password manager).
Shard B: Your heir keeps (e.g., on a USB drive).
Shard C: Stored encrypted on deadhand's servers.
Any two shards can recover your seed phrase. One shard alone is useless.

What Happens When You Die?
You stop responding to deadhand's check-in emails.
After 90 days of silence, Shard C is automatically emailed to your beneficiary.
They combine Shard C with Shard B (which you already gave them earlier).
They recover your seed phrase and access your crypto.
Your family inherits your assets automatically, without lawyers or courts.

How to Set This Up
Visit deadhandprotocol.com.
Enter your seed phrase (encrypted client-side).
The tool splits it into 3 shards.
Save Shard A in your password manager and give Shard B to your heir.
Shard C stays encrypted on our servers.
Done in 5 minutes.
Cost: $0 for the first 50 early bird users. Then rising to $99 lifetime access.

The Bottom Line
Your crypto does not have to die with you. You have three choices: 1. Do nothing and let your family lose everything. 2. Trust one person with your entire seed phrase. 3. Use Shamir's Secret Sharing and sleep soundly.

Secure your crypto inheritance now

Max Comperatore is the founder of deadhand. He has been in crypto since 2017 and has seen too many people lose fortunes because they did not have a plan.