Zelf Legacy: Biometric Inheritance Protocol for Stellar
Requested Budget: $40,000 USD (in XLM)
Organization: Zelf World LLC (Wyoming, USA)
Abstract
Zelf Legacy introduces a non-custodial inheritance infrastructure for digital assets built on Stellar and Soroban.
Users can maintain multiple self-custody wallets across trading, savings, and on-chain applications while ensuring that, in the event of post-mortem or prolonged inactivity, rightful beneficiaries can securely recover access rights without transferring assets into custody.
Instead of locking funds inside smart contracts, Zelf Legacy coordinates inheritance through programmable access-rights verification. Beneficiaries gain the ability to reconstruct wallet access only after predefined inheritance conditions are met, including inactivity verification, biometric authentication, and identity validation.
The system combines:
- Soroban smart contracts
- Heartbeat Protocol liveness verification
- Guardian Oracle coordination
- ZELF ID biometric identity infrastructure
- Shamir's Secret Sharing recovery architecture
No biometric templates are stored on centralized servers or databases. Assets remain in the original wallet throughout the inheritance lifecycle.
Zelf Legacy is powered by HumanAuthn, a biometric-rooted authentication and encryption primitive that regenerates ephemeral cryptographic keys from live facial verification. This architecture enables passwordless self-custody without exposing seed phrases or relying on custodial infrastructure.
The requested $40,000 grant will fund the development of:
- Soroban inheritance contracts
- Heartbeat Protocol infrastructure
- Guardian Oracle execution layer
- Stellar-native SDKs
- Developer tooling
- Testnet and mainnet deployment
All Stellar-specific infrastructure will be built natively for Soroban and open-sourced under MIT licensing.
Why This Matters for the Stellar Ecosystem
Stellar secures billions of dollars in self-custodied digital assets, yet the ecosystem lacks native inheritance infrastructure.
Without programmable inheritance mechanisms:
- assets can become permanently inaccessible
- families may lose access to funds
- long-term self-custody adoption becomes harder for mainstream users
Zelf Legacy introduces a non-custodial inheritance coordination layer designed specifically for the Stellar ecosystem.
The protocol expands Stellar's capabilities beyond payments into long-term digital asset continuity, rightful ownership transfer, and programmable beneficiary coordination.
This positions Stellar as infrastructure not only for payments, but also for generational digital asset ownership.
What Is Zelf?
Zelf is a cybersecurity and self-custody infrastructure platform powered by HumanAuthn, a biometric-rooted authentication and encryption primitive.
Unlike traditional authentication systems that anchor trust in hardware devices or custodial databases, HumanAuthn replaces device-rooted authentication with biometric-rooted cryptographic ephemeral key regeneration.
A live biometric scan regenerates a temporary encryption key used to decrypt wallet credentials, eliminating the need for:
- seed phrases
- password storage
- custodial recovery systems
- persistent biometric templates
This creates a device-agnostic identity layer designed for self-custody, authentication, and secure digital inheritance.
Zelf is available on: Web Extension, iOS, and Android.
What Is Zelf Legacy?
Zelf Legacy addresses one of the largest unresolved problems in self-custody:
What happens to digital assets when their owner dies or becomes permanently inactive?
Most crypto inheritance systems rely on:
- custodial escrow
- multisig dependency
- smart-contract fund locking, or
- manual legal coordination
Zelf Legacy introduces a different model. Instead of transferring assets into custody, the protocol coordinates inheritance through programmable access-rights activation.
Inheritance execution only begins after:
- inactivity verification
- grace-period expiration
- beneficiary biometric verification
- government-issued identity validation
Assets remain in the original wallet throughout the entire process.
Protocol Flow Diagram

Step 1: Create an Inheritance Policy
Users activate Legacy Mode inside the Zelf app and designate beneficiaries through ZELF ID biometric identity binding.
Each beneficiary is linked to an encrypted inheritance policy that defines:
- inheritance thresholds
- beneficiary consensus rules
- legal coordination preferences
- recovery conditions
The inheritance architecture combines:
- Soroban smart contracts
- ZELF ID biometric verification
- IPFS and Arweave decentralized storage
- Shamir's Secret Sharing recovery logic
Policy metadata is encrypted and stored off-chain while Soroban records only verification state and execution logic.
Users can configure:
- 2-of-3 or 3-of-5 recovery thresholds
- lawyer participation
- direct beneficiary execution
- multi-beneficiary inheritance structures
Step 2: Heartbeat Protocol
Zelf Legacy introduces a Heartbeat Protocol: a cryptographic liveness verification system anchored to Soroban smart contracts.
Instead of continuously tracking users or relying on custodial inactivity monitoring, the protocol enables periodic proof-of-life verification directly from the Zelf app.
Each heartbeat:
- verifies live user presence
- resets the inheritance inactivity timer
- emits a signed Soroban event
- updates the inheritance execution state
The protocol is privacy-preserving by design:
- heartbeat credentials remain private
- no public inheritance registry exists
- no behavioral tracking is required
- liveness detection prevents spoofing attacks
Users define:
- inactivity windows (30 days to 24 months)
- grace periods
- inheritance activation conditions
Heartbeat history is compressed through verifiable credential architecture and Merkle-proof validation, reducing on-chain storage requirements by 100–1000x compared to traditional state storage models.
If heartbeat expiration and grace-period thresholds are reached, the inheritance execution pipeline begins.
This transforms inheritance from a manual legal process into programmable self-custody infrastructure.
Step 3: Access Rights Recovery
Once inactivity and grace-period conditions are satisfied, beneficiaries can initiate the inheritance claim process.
Claim execution requires three verification layers:
1. Biometric Verification
A live facial scan is matched against the beneficiary's registered ZELF ID without exposing biometric templates.
2. Government Identity Verification
Beneficiaries complete identity verification through Verifik's KYC infrastructure covering 190+ countries.
3. Soroban Entitlement Verification
Soroban smart contracts verify inheritance eligibility and authorize access-right reconstruction.
Private keys remain off-chain throughout the process.
Access Rights Recovery
| Approach | Fund Transfer (typical approach) | Access Rights (Zelf Legacy) |
|---|---|---|
| User retains control | No. Funds locked in contract | Yes. Full control until inheritance |
| Smart contract risk | High. Funds at risk if contract is exploited | Minimal. Contract holds policies, not funds |
| DeFi composability | Broken. Locked funds can't be used | Preserved. Assets remain active |
| Yield/staking | Lost during lock period | Continues normally |
| Multi-chain assets | Requires per-chain deployment | Single policy covers cross-chain access |
| Legal enforceability | Uncertain. Code-is-law | Supported. Produces verifiable evidence for lawful off-chain execution |
Design Principles
Zelf Legacy is designed around the following principles:
- Non-custodial by default
- Assets remain in the original wallet
- No biometric templates stored
- Privacy-preserving liveness verification
- Human-rooted authentication
- Programmable inheritance execution
- Off-chain encrypted metadata
- Soroban-native coordination
- Long-term cost sustainability
Technical Architecture
Five coordinated layers power inheritance execution without moving assets into custody.

The HumanAuthn engine and ZELF ID infrastructure are already operational.
The Stellar grant focuses on building the inheritance coordination layer natively on Soroban, including:
- inheritance registry contracts
- Heartbeat Protocol infrastructure
- Guardian Oracle coordination
- claim verification pipeline
- Stellar SDK integration
- developer tooling
The architecture is divided into four layers:
Identity Layer
ZELF ID + HumanAuthn biometric authentication.
Liveness Layer
Heartbeat Protocol for periodic proof-of-life verification.
Storage Layer
Encrypted inheritance policies, ZELF ID packets, and recovery metadata are stored off-chain through IPFS and Arweave. Soroban records only state hashes, events, and verification logic, keeping the system scalable and cost-efficient.
Coordination Layer
Guardian Oracle monitors inactivity, grace periods, lawyer notification flows, and beneficiary claim activation.
Execution Layer
Soroban inheritance contracts enforce policy rules, claim eligibility, and access-right reconstruction.
Security & Privacy
Zelf Legacy is designed to minimize custodial risk and centralized attack surfaces.
Key security properties include:
- no biometric templates stored
- private keys remain off-chain
- encrypted off-chain metadata
- liveness verification with spoof resistance
- programmable inactivity thresholds
- decentralized storage through IPFS and Arweave
- cryptographic claim verification through Soroban
The protocol coordinates access-right recovery without taking custody of user assets.
Why Stellar?
Zelf Legacy aligns directly with Stellar's strengths in payments, identity, ownership verification, and real-world financial coordination.
Inheritance is fundamentally a real-world financial infrastructure problem. Stellar provides the technical foundations required to make programmable inheritance economically sustainable and globally accessible.
Key reasons for choosing Stellar include:
- Low transaction costs: Heartbeat verification must remain economically sustainable over years or decades.
- Fast finality: Time-sensitive inheritance execution requires reliable settlement guarantees.
- Soroban's Rust ecosystem: Enables direct portability from existing Rust-based infrastructure.
- Native BLS12-381 support: Critical for on-chain verification of ZELF ID cryptographic primitives.
- Real-world financial focus: Stellar's ecosystem aligns closely with long-term inheritance infrastructure and rightful ownership systems.
Stellar Integration Plan
Zelf Legacy is being built specifically around Soroban's authorization, storage, and cryptographic architecture.
Rather than porting an existing EVM inheritance system, the protocol leverages Stellar-specific components to optimize long-term storage efficiency, low-cost liveness verification, programmable inheritance execution, biometric entitlement verification, and real-world financial coordination.
Stellar-Specific Building Blocks
Soroban Smart Contracts (Rust)
Soroban contracts power:
- inheritance policy registry
- Heartbeat Protocol accumulation
- claim verification logic
- beneficiary entitlement execution
This architecture replaces our existing Anchor/Solana inheritance programs with a Soroban-native implementation.
Soroban Three-Tier Storage
Persistent Storage→ inheritance policy state and heartbeat rootsTemporary Storage→ intermediate claim verification stateInstance Storage→ contract configuration and execution parameters
Soroban require_auth() Authorization Model
Zelf Legacy uses Soroban's explicit authorization model rather than implicit msg.sender assumptions found in EVM architectures. This enables more deterministic inheritance execution flows and aligns directly with Stellar's account-based security model.
Soroban Event System
Heartbeat emissions are implemented through Soroban events rather than continuous state writes. This dramatically reduces long-term operational costs by keeping per-heartbeat verification costs near zero while preserving verifiable liveness history.
BLS12-381 Native Curve Support
Soroban's native BLS12-381 support enables on-chain HumanAuthn verification without requiring external cryptographic libraries. This is one of the primary technical reasons Stellar was selected over EVM-based ecosystems.
Stellar Wallets Kit
The Stellar Wallets Kit will be integrated during Tranche 3 to support Freighter, Lobstr, Stellar-native onboarding flows, and developer wallet integrations.
IPFS + Arweave Storage Layer
Inheritance policy metadata, encrypted ZELF ID packets, and recovery configuration are stored off-chain. The Stellar ledger records only: state hashes, heartbeat roots, verification events, and inheritance execution state.
| Component | Current Stack | Stellar Adaptation |
|---|---|---|
| HumanAuthn Engine | TypeScript/Native SDK (offline) | None needed. Chain-agnostic. |
| Inheritance business logic | Rust (Anchor/Solana) | Medium. Same language, swap macros and storage model. |
| Heartbeat Protocol | Solana + Light Protocol | Medium. Soroban events + BLS12-381 + Merkle accumulator. |
| Biometric SDKs | Web, iOS, Android | None needed. Client-side. |
| KYC/AML | Verifik Production API | None needed. Backend service. |
| Guardian Oracle | Proof of concept (Node.js) | Medium. Complete and adapt to Soroban. |
| Arweave/IPFS storage | Production integration | None needed. Chain-agnostic. |
Stellar Integration Flow
Data flow showing exactly how Stellar components participate in the inheritance lifecycle:

Tranche 1: MVP — Soroban Inheritance Core ($10,000)
Timeline: 3 Weeks
The first tranche focuses on building the foundational inheritance infrastructure natively on Soroban.
This phase includes:
- Soroban inheritance registry contracts
- ZELF ID integration
- Heartbeat Protocol implementation
- Merkle-proof heartbeat verification
- inheritance policy coordination logic
The MVP establishes the minimum viable inheritance flow:
- Create an inheritance policy
- Register beneficiaries through ZELF ID
- Emit heartbeat liveness proofs
- Trigger simulated inheritance conditions
- Execute claim verification on Stellar Testnet
At the end of Tranche 1, the result will be a fully simulated end-to-end inheritance event operating on Stellar Testnet.
Tranche 2: Testnet — Guardian Oracle & Claim Pipeline ($10,000)
Timeline: 3 Weeks
The second tranche focuses on building the inheritance coordination and verification pipeline.
This phase introduces the Guardian Oracle, responsible for monitoring:
- inactivity thresholds
- grace periods
- lawyer notification flows
- beneficiary activation conditions
Once inheritance conditions are satisfied, the claim pipeline validates:
- beneficiary biometric verification through ZELF ID
- government-issued identity verification
- inheritance entitlement through Soroban contracts
- seed phrase reconstruction authorization
The goal of this phase is to establish a secure and programmable inheritance execution flow operating fully on Stellar Testnet.
Tranche 3: Mainnet — SDKs, Wallet Integration & Deployment ($20,000)
Timeline: 3 Weeks
The final tranche focuses on ecosystem integration, developer tooling, and mainnet readiness.
This phase includes:
- Stellar-native SDKs
- Freighter and Lobstr wallet integrations
- developer documentation
- demo applications
- UX-ready onboarding flows
- mainnet deployment
The objective is to deliver a production-ready inheritance infrastructure that developers, wallets, and users can integrate directly into the Stellar ecosystem.
At completion, Zelf Legacy will operate as a live Soroban-native inheritance protocol with open-source Stellar infrastructure and public developer tooling.
Open Source Commitment
All Stellar-specific infrastructure developed through this grant will be released under MIT licensing, including:
- Soroban smart contracts
- Heartbeat Protocol infrastructure
- Guardian Oracle interfaces
- SDKs
- demo applications
- developer documentation
The HumanAuthn and ZELF ID core architecture will remain proprietary while being exposed through developer SDKs with free-tier access for Stellar ecosystem developers.
Summary
A $40,000 grant enables the development of a human-rooted, decentralized inheritance infrastructure for the Stellar ecosystem.
The architecture combines:
- Soroban inheritance contracts
- Heartbeat Protocol liveness verification
- Guardian Oracle coordination
- ZELF ID biometric authentication
- Stellar-native SDKs
- developer tooling
- testnet and mainnet deployment
Zelf Legacy transforms inheritance from a manual legal process into programmable self-custody infrastructure while preserving self-custody and keeping assets in their original wallet throughout the entire lifecycle.