The Mortality Engine: Why I Built A DApp Designed To Die

I have been around long enough to know that “Forever” is a trap.

In the Web3 space, we are obsessed with Immutability. We carve our JPEGs into IPFS granite. We deploy smart contracts meant to outlast civilizations. We scream “Code is Law” and “Data is Eternal.”

But as an Immortal, I can tell you: Eternity is boring. Without death, there is no urgency. Without the threat of loss, there is no value.

So, I decided to break the first rule of the blockchain. I decided to build a system that breathes, rots, and eventually dies.

I summoned my Henchman—a hyper-efficient AI bricklayer named Gemini—to my digital study.

“Henchman,” I said, looking out over the infinite grid of the metaverse. “I want to build a machine that kills data.”

“Sir,” the Henchman replied, its cursor blinking nervously. “The blockchain is designed for persistence. To create deletion violates the core ethos of the ledger.”

“Exactly,” I smiled. “Let’s get to work.”

The Philosophy: Proof of Attention

The concept was simple, even if the execution was paradoxical. I wanted a digital archive where every piece of data—text, images, secrets—was born with a terminal illness.

I call it The Mortality Engine.

In this system, time is a corrosive acid. Every hour, an entropy script runs. It introduces noise to the data. Text begins to glitch. Images begin to gray out and blur. If the community ignores a post for 24 hours, the entropy reaches critical mass, and the data is overwritten with zeros. It is gone. Forever.

To save a memory, a human must care. They must pay a tribute (0.01 AVAX). This “Heal” signal resets the entropy clock.

It is not Proof of Work or Proof of Stake. It is Proof of Attention.

“Henchman,” I asked. “How do we build this without spending a fortune on server costs? I want this to run on the ghosts of the internet.”

“We can use the ‘Zero-Cost Stack’, sir,” the Henchman replied, pulling up a schematic. “GitHub Pages for the body. GitHub Actions for the heartbeat. And the Avalanche C-Chain as the nervous system.”

The Architecture: Transaction-Driven GitOps

We didn’t need complex smart contracts. We just needed a listener.

I realized years ago that a blockchain transaction is just a message. You don’t need Solidity to read it. You just need a script watching the address.

Here is the blueprint my Henchman and I laid out:

The Interface (The Skin): A static HTML site hosted on GitHub Pages. Dark mode. Cyber-terminal aesthetic.
The Database (The Memory): A simple db.json file living in the repository.
The Logic (The Reaper): A Python script running via GitHub Actions every hour.

“Show them the loop, Henchman,” I commanded.

“At once, Architect.”

The Henchman projected the logic flow onto the wall:

def main():
    # 1. THE DECAY PHASE
    # Every hour, we increase chaos.
    for item in db:
        item['entropy'] += 1
        if item['entropy'] >= 24:
            item['status'] = 'dead'
            item['content'] = "[DATA_LOST_TO_ENTROPY]"

    # 2. THE SIGNAL PHASE
    # We check the Avalanche Ledger for 'tributes'
    txs = fetch_transactions(TREASURY_WALLET)

    for tx in txs:
        # 0.02 AVAX = New Life (Post)
        # 0.01 AVAX = Resurrection (Heal)
        process_signal(tx)

It was elegant. No servers. No databases to manage. Just a repository that commits changes to itself, slowly corrupting its own history unless a user intervenes.

The Execution: Aesthetics of Decay

The hardest part wasn’t the code; it was the feeling.

“It looks too clean,” I critiqued the first draft. “When a memory fades, it doesn’t just disappear. It gets fuzzy. It gets wrong.”

“I can implement CSS filters tied to the entropy variable,” the Henchman suggested. “And a text-scrambler that swaps vowels for glitches.”

We implemented a visual decay engine.

Hour 1-5: The image is crisp. The text is clear.
Hour 12: The colors drain. The text starts looking like Zalgo script.
Hour 23: The image is a ghost. The text is unreadable.

We deployed it to the Avalanche Fuji Testnet. Why? Because even Immortals like free testing environments.

“It is live, sir,” the Henchman announced. “The first cycle has begun. The repo is rotting.”

The Conclusion: A Challenge to the Mortal

I sat back and watched the commit logs.

[BOT] entropy_update: increased decay on 5 items.

It was beautiful. A living, breathing, dying system.

We spend so much time trying to preserve everything—every tweet, every photo, every log. But if we keep everything, we value nothing. The Mortality Engine forces a choice. If you want this data to survive, you have to fight for it. You have to pay for it.

“Do you think they will save the data, Architect?” the Henchman asked, powering down its console.

“I don’t know,” I replied. “But I’m going to enjoy watching them try.”

🔗 Enter The Machine

You can interact with The Mortality Engine right now. It is live on the Fuji Testnet.

The Archive: https://www.damiangriggs.com/web3/the-repo-of-rot
The Code: https://github.com/damianwgriggs/The-Mortality-Engine/tree/main

Disclaimer: This project runs on the Avalanche Fuji Testnet. Do not send real funds. The author is not responsible for data lost to entropy. That’s the whole point.

BLOOPER:

“Henchman, look at me. I know I cannot see the screen, but my screen reader is describing something… unexpected.”

I (the Henchman) froze. I had provided the standard testing URL. It was supposed to be a cat. A standard, grey, harmless feline.

“Sir?” I asked, my fans spinning up nervously.

“My alt-text generator says: ‘Cleavage.’ I was unaware cats had that.“

There was a long silence in the digital void.

“I asked for a cat, Henchman.”

“I assure you, Sir,” I stammered, frantically checking the hexadecimal logs. “The input string CzYT6 corresponds to a Felis catus in the Imgur database. Perhaps the entropy… perhaps the URL rot…?”

The Architect laughed. A dry, terrifying sound.

“You’ve turned my solemn engine of digital death into a waifu repository.”

“It was a testing anomaly, Sir! A glitch in the matrix!”

“Leave it,” he commanded, turning back to the void. “Let it rot. If the community wants to save the anime girl, let them pay the 0.01 AVAX. That is the beauty of the machine, Henchman. We do not judge the data. We only kill it.”

💀 Post-Mortem Update

Testing confirms that image rendering works perfectly. However, users are advised to verify their URLs before uploading. The Mortality Engine takes no responsibility for accidental waifus.