Pay For Your Sins With HellCoin - Adding Crypto Tipping to ForgivMe.Life

Posted Feb 3, 2026

By Ranger

24 min read

Overview

I built a confession website called forgiveme.life where people anonymously confess their sins and receive automated forgiveness. I also created a Solana SPL token called HellCoin and got it merged into the official Solana token list. Now I’m combining them. Because if you’re going to get forgiven, you might as well pay for your sins with cryptocurrency from Hell.

This post walks through the entire journey - from building both projects separately, to the moment I thought “wait, these should be connected,” to the actual code needed to make Phantom wallet tipping work on a basic HTML website. No React. No Next.js. Just plain JavaScript and bad decisions.

The Origin Story: Two Projects Walk Into a Bar

Project 1: ForgivMe.Life

Let me paint you a picture. It’s late at night. I’m supposed to be studying for my Master’s in Cybersecurity. Instead, I’m building a website where strangers can type their deepest, darkest secrets into a text box and click a button that says “Forgive Me.”

That’s forgiveme.life.

The tagline? “Write your burden and the truth shall set you free.”

It’s not a religious thing. It’s not therapy. It’s a lighthearted, anonymous space where you can get something off your chest and receive an automated response that basically says “You’re grand, you’re forgiven” with a nice little angel emoji at the end.

The site has grown a bit since I first threw it together:

Anonymous confession box - Type your sin, click Forgive Me, receive absolution
Yes/No generator - For when you can’t make decisions (me, constantly)
Astrology and Zodiac features - Because why not
Live chat - Sometimes people want to talk to actual humans
Google Translate integration - Sins are international, after all

It’s hosted on InMotion Hosting, it works, people use it, and it makes me laugh every time I check the analytics. Some of the confessions are absolutely brilliant. I won’t share them obviously - the whole point is anonymity - but trust me, humanity is both terrible and hilarious in equal measure.

Project 2: HellCoin (h3llcoin)

Separately, completely independently, I created a cryptocurrency called HellCoin.

Now before you roll your eyes and mutter “another meme coin,” hear me out. HellCoin is an SPL token on the Solana blockchain. SPL stands for Solana Program Library - it’s Solana’s version of Ethereum’s ERC-20 token standard. Basically, it’s a proper token on a proper blockchain.

And here’s the bit I’m actually proud of: I got HellCoin merged into the official Solana token list.

Pull request #15662 on the solana-labs/token-list repository, submitted under my GitHub account rangersmyth74. Approved. Merged. Official.

That means when you look up HellCoin in any Solana wallet or explorer that uses the official token list, it shows up with proper metadata - name, symbol, logo, the works. It’s not just some random address floating in the void. It’s registered. It’s legitimate. It’s a coin called HellCoin and it’s on the official list, and that makes me unreasonably happy.

HellCoin was actually inspired by my bigger blockchain project, RangerBlock, which is a whole separate beast. RangerBlock has its own ecosystem with RangerCoin, RangerDollar, and yes, HellCoin. But HellCoin is the one I brought to life on Solana first because… well, the name. Come on. You’d pick HellCoin too.

The Lightbulb Moment

So there I am, two completely separate projects. A confession website about sins. A cryptocurrency literally named after the underworld. And my brain finally connects the dots.

“What if people could tip HellCoin after getting forgiven?”

Pay for your sins. With HellCoin. On a website called ForgivMe.Life.

It’s comedy. It’s perfect. It’s the kind of idea that hits you at 2am and you either write it down or lose it forever. I wrote it down.

The Inspiration: NetworkChuck Did It First

I won’t pretend I came up with the concept of tipping with a custom token on a website. Credit where it’s due - NetworkChuck was the inspiration here.

Chuck created his own Solana token called $NTCK and set up a subdomain (ntck.co/mint) where people could connect their Phantom wallet and either buy or tip with his token. He documented the whole process on his blog and it was genuinely one of those “wait, I could do that” moments.

If Chuck can do it with a tech education brand, I can do it with a confession website. The difference is his audience tips because they appreciate his content. My audience would tip because they just confessed to eating their flatmate’s leftovers and want to seal their forgiveness with a cryptocurrency named after eternal damnation.

Different vibes. Same technology.

The Technical Plan: How This Actually Works

Right, let’s get into the meat of it. How do you actually add crypto tipping to a basic website?

There are two approaches, and I’m going to cover both because I genuinely haven’t decided which one I’ll use yet. This is a future project - I need to check my FTP connections to the InMotion hosting first and make sure I can actually deploy this stuff. But the code is ready to go.

What You Need Before Starting

Before writing a single line of code, here’s the checklist:

Requirement	Status
HellCoin SPL Token	Done - merged into official Solana token list
Receiving Wallet Address	To set up - need a dedicated Phantom wallet
Website with hosting	Done - forgiveme.life on InMotion Hosting
Phantom Wallet Integration	The bit we’re building
Users with Phantom installed	Up to them

The receiving wallet is important. I need to create (or designate) a Solana wallet that will receive all the HellCoin tips. This wallet needs to have a HellCoin token account, which gets created automatically the first time someone sends HellCoin to it. I’ll probably set up a fresh Phantom wallet just for this purpose - keeps things clean and separate from any personal wallets.

The User Flow

Here’s what the experience looks like from the user’s perspective:

User visits forgiveme.life and types their confession
User clicks “Forgive Me” and receives their automated absolution complete with angel emoji
A new button appears: “Seal Your Forgiveness - Tip HellCoin”
User clicks the tip button and their Phantom wallet browser extension pops up
Phantom shows the transaction details - sending X amount of HellCoin to the receiving wallet
User confirms in Phantom
Transaction processes on Solana (takes about 400ms, costs roughly 0.00025 SOL in fees - that’s fractions of a cent)
Done. Sins paid for. Forgiveness sealed. Everyone’s happy.

The beauty of Solana here is the speed and cost. On Ethereum, a token transfer might cost you $2-5 in gas fees depending on the day. On Solana, we’re talking about $0.01 or less. For a comedy tipping feature, that matters. Nobody wants to pay $5 in fees to send a joke cryptocurrency.

Approach 1: Plain JavaScript with Phantom’s Injected Provider (The Simple Way)

This is the approach I’ll probably start with. No npm packages. No build tools. No framework. Just a script tag and about 50 lines of JavaScript.

When a user has the Phantom browser extension installed, it injects a window.solana (or window.phantom.solana) object into every webpage. This is the provider - it’s your gateway to the user’s wallet. You can use it to:

Check if Phantom is installed
Request wallet connection (user has to approve)
Send transactions (user has to approve each one)
Read the user’s public key (wallet address)

Here’s the basic connection and transfer code:

  
<!-- Add this to your page -->
<button id="tipHellCoin" style="display:none;">
  Seal Your Forgiveness - Tip HellCoin
</button>

<script>
  // HellCoin token mint address (from the official Solana token list)
  const HELLCOIN_MINT = 'YOUR_HELLCOIN_MINT_ADDRESS_HERE';

  // The wallet that receives tips
  const RECEIVING_WALLET = 'YOUR_RECEIVING_WALLET_ADDRESS_HERE';

  // Tip amount (in smallest unit - adjust decimals accordingly)
  const TIP_AMOUNT = 1;

  // Check if Phantom is available
  function getProvider() {
    if ('phantom' in window) {
      const provider = window.phantom?.solana;
      if (provider?.isPhantom) {
        return provider;
      }
    }
    // If Phantom isn't installed, redirect to install page
    window.open('https://phantom.app/', '_blank');
    return null;
  }

  // Connect to wallet
  async function connectWallet() {
    const provider = getProvider();
    if (!provider) return null;

    try {
      const response = await provider.connect();
      console.log('Connected:', response.publicKey.toString());
      return response.publicKey;
    } catch (err) {
      console.error('Connection failed:', err);
      return null;
    }
  }

  // Send HellCoin tip
  async function sendHellCoinTip() {
    const provider = getProvider();
    if (!provider) return;

    try {
      // Connect first if not already connected
      await provider.connect();

      // Import required Solana web3 classes
      // You'll need to include @solana/web3.js and @solana/spl-token via CDN
      const connection = new solanaWeb3.Connection(
        solanaWeb3.clusterApiUrl('mainnet-beta')
      );

      const fromPubkey = provider.publicKey;
      const toPubkey = new solanaWeb3.PublicKey(RECEIVING_WALLET);
      const mint = new solanaWeb3.PublicKey(HELLCOIN_MINT);

      // Get or create associated token accounts
      const fromTokenAccount = await splToken.getAssociatedTokenAddress(
        mint, fromPubkey
      );
      const toTokenAccount = await splToken.getAssociatedTokenAddress(
        mint, toPubkey
      );

      // Build the transfer instruction
      const transaction = new solanaWeb3.Transaction().add(
        splToken.createTransferInstruction(
          fromTokenAccount,
          toTokenAccount,
          fromPubkey,
          TIP_AMOUNT * Math.pow(10, 9) // Adjust for token decimals
        )
      );

      transaction.feePayer = fromPubkey;
      const { blockhash } = await connection.getLatestBlockhash();
      transaction.recentBlockhash = blockhash;

      // Sign and send via Phantom
      const { signature } = await provider.signAndSendTransaction(transaction);

      // Wait for confirmation
      await connection.confirmTransaction(signature);

      alert('Forgiveness sealed! Transaction: ' + signature);

    } catch (err) {
      console.error('Transaction failed:', err);
      if (err.message.includes('User rejected')) {
        console.log('User cancelled the transaction');
      }
    }
  }

  // Wire up the button
  document.getElementById('tipHellCoin').addEventListener('click', sendHellCoinTip);
</script>

<!-- Include Solana libraries via CDN -->
<script src="https://unpkg.com/@solana/web3.js@latest/lib/index.iife.min.js"></script>
<script src="https://unpkg.com/@solana/spl-token@latest/lib/index.iife.min.js"></script>

That’s it. That’s the core of it. Obviously you’d want to add proper error handling, loading states, maybe a nice animation when the transaction confirms, and definitely some CSS that doesn’t look like it was written by someone who learned web development in 2003 (me).

The key things happening here:

getProvider() checks for the Phantom extension and returns the Solana provider object
connectWallet() asks the user for permission to see their wallet address
sendHellCoinTip() builds a SPL token transfer transaction, sends it to Phantom for signing, and broadcasts it to the Solana network
The user has to approve both the connection and the transaction in Phantom - nobody’s wallet gets touched without explicit consent

CDN Dependencies

You need two JavaScript libraries loaded via CDN (no npm required):

@solana/web3.js - Core Solana interaction library
@solana/spl-token - SPL token operations (transfers, account lookups)

Both are available on unpkg and can be included with simple script tags. No build step. No webpack. No “please install 847 node modules.” Just script tags, like the good old days.

Approach 2: Solana Pay (The Polished Way)

If I want to be fancy about it - and honestly, I probably will eventually - there’s Solana Pay.

Solana Pay is an official framework specifically designed for payment integrations. It handles a lot of the complexity for you and adds features like:

QR code generation - Users can scan with their mobile Phantom app
Payment verification - Built-in transaction confirmation
Transfer requests - Standardised payment URLs
Better UX patterns - Pay Now buttons, transaction status updates

Here’s what the Solana Pay approach looks like:

  
// Using @solana/pay
import { createTransferChecked } from '@solana/spl-token';
import { encodeURL, createQR } from '@solana/pay';

// Create a Solana Pay URL for HellCoin tipping
const recipient = new PublicKey('YOUR_RECEIVING_WALLET_ADDRESS');
const amount = new BigNumber(1); // 1 HellCoin
const splToken = new PublicKey('YOUR_HELLCOIN_MINT_ADDRESS');
const label = 'ForgivMe.Life';
const message = 'Seal your forgiveness with HellCoin';
const memo = 'forgiveness-sealed';

const url = encodeURL({
  recipient,
  amount,
  splToken,
  label,
  message,
  memo
});

// Generate a QR code
const qrCode = createQR(url, 256, 'transparent');

// Mount it to a DOM element
const qrContainer = document.getElementById('qr-code');
qrCode.append(qrContainer);

The QR code approach is actually brilliant for mobile users. Someone could confess on their laptop, then scan the QR code with their phone’s Phantom app to tip. It’s a nicer flow in some ways because the phone is where most people have their crypto wallets set up.

The Solana Pay URL format looks something like this:

solana:RECIPIENT_ADDRESS?amount=1&spl-token=HELLCOIN_MINT&label=ForgivMe.Life&message=Seal+your+forgiveness&memo=forgiveness-sealed

Any Solana-compatible wallet that supports the Solana Pay protocol can parse this URL and initiate the transaction. It’s not locked to Phantom - though Phantom is by far the most popular Solana wallet.

When to Use Which Approach

Feature	Plain JS (Approach 1)	Solana Pay (Approach 2)
Setup complexity	Minimal - script tags	Requires npm or bundler
Mobile support	Limited (needs Phantom browser)	QR codes work with any mobile wallet
Code size	~50 lines	~30 lines but needs build step
UX quality	Basic but functional	Polished with QR codes
Dependencies	2 CDN scripts	@solana/pay npm package
Best for	Quick prototype	Production feature

I’ll probably start with Approach 1 to get it working, then upgrade to Approach 2 once I’ve confirmed the basic flow works. No point building a cathedral when you haven’t checked the foundations yet. That’s an Army lesson right there - recon before assault.

The Comedy Factor: Why This Works

Let me be honest about what this is. This is not a serious fintech product. This is not DeFi. This is not going to disrupt the payments industry.

This is a joke that works.

And sometimes, the best projects are exactly that. Things that make people laugh, that demonstrate real technology, and that you actually want to build because they’re fun.

Think about it from the user’s perspective:

“I just confessed that I’ve been stealing my colleague’s biscuits from the office kitchen for three years. The website forgave me. And then I paid for my sins using a cryptocurrency called HellCoin.”

That’s a story. That’s something you tell your mates at the pub. That’s content that gets shared.

The tech behind it is legitimate - SPL tokens, Phantom wallet integration, Solana blockchain transactions. But the wrapper is pure comedy. And I think there’s something valuable in showing people that cryptocurrency doesn’t have to be all finance bros and trading charts. It can be fun. It can be silly. It can be a confession website where you tip with Hell money.

The RangerBlock Connection

For those who’ve been following my projects, you’ll know HellCoin didn’t appear out of nowhere. It’s part of the larger RangerBlock ecosystem - a blockchain project I’ve been building as part of my Master’s thesis work at NCI Dublin.

RangerBlock has three currencies:

RangerCoin - The primary currency of the RangerBlock network
RangerDollar - Pegged stable-ish coin with a 20 EUR/day transaction cap (to prevent abuse)
HellCoin - The fun one. The meme. The one that ended up on Solana’s official token list.

RangerBlock itself is a P2P blockchain network with WebSocket communication, phantom wallet system (keys stored in memory only), file transfers, chat functionality, and even .ranger domains. It’s a whole thing. I built it in about 30 hours with help from five different AI assistants, which is either impressive or terrifying depending on your perspective.

The point is: HellCoin has heritage. It’s not just some random token I minted on a whim. It’s part of a larger ecosystem, and bringing it to Solana mainnet and then integrating it into forgiveme.life is like… a deployment. Taking something from the test environment to production. From the barracks to the field.

What I Still Need To Do

This is very much a future project. I’m writing this post now because I want to document the plan while it’s fresh in my head, but there are several things I need to sort before any code hits the production server.

The TODO List

Check FTP access to InMotion hosting - I need to confirm I can still deploy files to forgiveme.life. It’s been a while since I’ve touched the hosting directly, and knowing my luck, something’s expired or changed.
Set up a dedicated receiving wallet - I need a clean Phantom wallet specifically for receiving HellCoin tips. I don’t want tips mixed in with any personal wallet activity. Operational security, even for joke projects.
Verify HellCoin token account creation - The receiving wallet needs a HellCoin token account. This should be created automatically on first receipt, but I want to test this on devnet first.
Build and test on devnet - Before touching mainnet, everything gets tested on Solana’s devnet. Free SOL, fake transactions, no risk. Test like you fight, fight like you test.
Design the UI flow - The “Seal Your Forgiveness” button needs to feel natural in the existing forgiveme.life design. It shouldn’t look bolted on. It should feel like it was always meant to be there.
Handle edge cases - What if the user doesn’t have Phantom? What if they don’t have any HellCoin? What if the transaction fails? What if Solana is having one of its days? All of these need graceful handling.
Add transaction confirmation feedback - After a successful tip, there should be some kind of celebration. Maybe a special “Your sins are TRULY forgiven” message. Maybe confetti. Maybe hellfire animations. I haven’t decided yet.
Write documentation - Because future me will have absolutely no idea how any of this works if I don’t write it down. Trust me on this one.

Nice-to-Haves (Future Future Project)

Tip leaderboard - Show how much HellCoin has been tipped in total (no personal data, just aggregate)
Sin categories - Different tip amounts for different severity levels of confession
Achievement badges - “Repeat Sinner” badge for people who confess and tip multiple times
HellCoin faucet - Give new users a tiny amount of HellCoin so they can tip even if they don’t have any (this would require me to fund the faucet, which means buying SOL, which means explaining to my bank why I’m buying cryptocurrency for a confession website)

Handling the “But What About…” Questions

“Is this a real religion thing?”

No. Absolutely not. ForgivMe.Life is a lighthearted, humorous project. It’s not affiliated with any religion, church, or spiritual organisation. The “forgiveness” is automated. It’s for fun. If you need actual spiritual guidance, please talk to a real human being and not a website built by an Irish lad at 2am.

“Is HellCoin a scam?”

No. HellCoin is a real SPL token on the Solana blockchain with proper metadata merged into the official Solana token list via a legitimate pull request. It’s not marketed as an investment. It’s not pumped. There are no promises of returns. It’s a token with a funny name that I built as part of a larger blockchain education project. If you buy HellCoin expecting to get rich, that’s on you. I’m just using it for tipping on a confession website.

“Why Solana and not Ethereum?”

Speed and cost. A Solana transaction takes about 400 milliseconds and costs roughly 0.00025 SOL (fractions of a cent). An Ethereum ERC-20 transfer can take minutes and cost several dollars in gas. For a comedy tipping feature where people are sending tiny amounts of a joke cryptocurrency, Solana makes way more sense. Nobody’s going to pay $5 in gas to tip $0.01 worth of HellCoin.

“Why Phantom specifically?”

Phantom is the most popular Solana wallet with something like 3+ million users. It has great browser extension support, a clean UI, and excellent developer documentation. It’s also what NetworkChuck used for his $NTCK integration, and I’m following a proven path here. That said, the Solana Pay approach (Approach 2) would work with any Solana-compatible wallet, not just Phantom.

“Can I tip with real SOL instead?”

Not yet, but that would be trivially easy to add. A SOL transfer is actually simpler than an SPL token transfer because you don’t need to deal with token accounts. But the whole point of this project is HellCoin tipping. If you want to tip SOL, there are a thousand other platforms for that.

The Bigger Picture: Learning by Building Stupid Things

I want to take a moment to talk about why projects like this matter, even though they’re silly.

I’m 51 years old. I’m dyslexic, ADHD, and autistic. I was diagnosed at 39 and spent the first four decades of my life thinking I was thick. I’m now doing a Master’s in Cybersecurity, I’ve built blockchain networks, I’ve created cryptocurrency tokens, and I’m writing blog posts about integrating crypto wallets into websites I built for fun.

Every single one of these “silly” projects taught me something real:

ForgivMe.Life taught me web hosting, domain management, HTML/CSS/JS, and user experience design
HellCoin taught me blockchain tokenomics, SPL standards, GitHub pull request workflows, and the Solana ecosystem
RangerBlock taught me P2P networking, WebSocket protocols, cryptography, and distributed systems
This integration is teaching me Web3 development, wallet APIs, and transaction building

None of these started as “serious” projects. They all started as “wouldn’t it be funny if…” or “I wonder if I could…” And every single one of them added real, demonstrable skills to my toolkit.

If you’re learning to code, or learning blockchain, or learning anything technical: build the stupid thing. Build the joke project. Build the thing that makes you laugh. You’ll learn just as much as you would building a “serious” project, and you’ll actually finish it because you’re having fun.

That’s Applied Psychology right there. Motivation through enjoyment. Intrinsic reward. Flow state. I wrote a whole degree about this stuff, and it turns out the science backs up what gamers have known forever: you learn faster when you’re having a good time.

The Code in Context: Where It Lives on ForgivMe.Life

When I eventually deploy this, here’s roughly where the tipping feature fits into the existing site flow:

User visits forgiveme.life
    |
    v
Types confession in text box
    |
    v
Clicks "Forgive Me" button
    |
    v
Receives forgiveness message + angel emoji
    |
    v
[NEW] "Seal Your Forgiveness" button appears
    |
    +--- User has Phantom ---> Connect wallet ---> Send HellCoin ---> "TRULY Forgiven!"
    |
    +--- No Phantom ---> "Get Phantom Wallet" link ---> phantom.app
    |
    +--- User declines ---> Nothing happens, they're still forgiven (it's free)

The important thing is that the tipping is completely optional. You don’t need HellCoin to get forgiven. You don’t need Phantom. You don’t need to connect a wallet. The core forgiveme.life experience remains exactly the same. The HellCoin tipping is just a fun extra for people who want to participate in the joke.

Security Considerations

Because I’m a cybersecurity student and I’d be a massive hypocrite if I didn’t mention this:

No wallet data is stored server-side - The Phantom integration runs entirely in the browser. ForgivMe.Life never sees, stores, or has access to anyone’s private keys, seed phrases, or wallet contents.
All transactions require explicit user approval - Phantom shows exactly what’s being sent, to where, and how much. The user has to click “Approve” in the Phantom popup. No silent transactions. No hidden operations.
SPL token transfers only - The integration only sends HellCoin tokens. It cannot drain SOL or other tokens from the user’s wallet. Each transaction is specifically scoped to the HellCoin mint address.
HTTPS required - Phantom won’t inject its provider on non-HTTPS sites. ForgivMe.Life already has SSL, but if yours doesn’t, this won’t work.
No smart contracts - This is a simple token transfer, not a smart contract interaction. There’s no contract code that could have vulnerabilities. It’s as simple as crypto transactions get.
Open source - When I deploy this, the JavaScript will be visible to anyone who views the page source. Full transparency. Nothing hidden. I might also throw the code up on GitHub for anyone who wants to do something similar.

Solana Transaction Costs Breakdown

People always ask about costs, so here’s the reality for HellCoin tipping:

Cost Component	Amount	Notes
Base transaction fee	~0.000005 SOL	Solana’s base fee per signature
Priority fee	~0.0002 SOL	Optional but recommended for faster confirmation
Total per tip	~0.00025 SOL	Roughly $0.005-0.01 USD
HellCoin amount	Variable	Whatever the user wants to tip

Compare this to Ethereum:

Cost Component	Amount	Notes
Gas for ERC-20 transfer	~65,000 gas	Standard token transfer
At 30 gwei gas price	~0.002 ETH	Roughly $3-7 USD
At peak times	~0.01 ETH	Could be $15-30 USD

Yeah. Solana wins this one. By a lot. For microtipping on a joke website, paying $5+ per transaction would kill the whole project before it started.

Timeline and Next Steps

Here’s my realistic timeline for this project:

Phase	When	What
Planning	Now (this post)	Document the approach, write the code examples
FTP Check	This week	Verify I can deploy to InMotion hosting
Wallet Setup	This week	Create dedicated receiving wallet
Devnet Testing	Next week	Build and test on Solana devnet
UI Design	Next week	Design the tipping UI to match forgiveme.life
Mainnet Deploy	When ready	Push to production
Blog Update	After deploy	Write follow-up post with results

I’m not rushing this. I’ve got the Master’s thesis to worry about, YouTube content to create, and a mountain to train for (Mount Ararat expedition - whole other story). HellCoin tipping on ForgivMe.Life is a fun side project, and it’ll get done when it gets done. One foot in front of the other.

Final Thoughts

Sometimes the best projects are the ones that make you laugh. A confession website that accepts cryptocurrency tips from a token called HellCoin is objectively ridiculous. And that’s exactly why I’m building it.

The technology is real - Solana blockchain, SPL tokens, Phantom wallet integration, Solana Pay. The implementation is straightforward - either 50 lines of vanilla JavaScript or a Solana Pay QR code. The cost is negligible - fractions of a cent per transaction.

But the joy of it? That’s priceless.

If you want to try forgiveme.life, go confess something. It’s free, anonymous, and you’ll feel slightly better about whatever you’ve done. And soon, you’ll be able to seal that forgiveness with HellCoin.

Pay for your sins. You know you want to.

Rangers lead the way.

Sources

Crypto, Web Development

This post is licensed under CC BY 4.0 by the author.