DEV Community: IG

Kickoff: Smart Contracts and Serverless Backend for Your Soccer Raffle (Part 1)

IG — Fri, 10 Oct 2025 14:56:38 +0000

ARTICLE 1: Smart Contracts & Backend Infrastructure

Introduction

Welcome to the first part of our three-part series on building a decentralized soccer raffle platform. In this article, we’ll lay the blockchain foundation:

Deploy smart contracts to the Lisk Sepolia testnet
Set up Firebase Cloud Functions to serve blockchain data without gas costs

By the end, you’ll have a working backend ready for a Flutter frontend to interact with.

Follow along with the repo or watch the video

What You'll Learn

Deploying provably fair raffle contracts
Creating custom ERC20 test tokens
Setting up serverless blockchain APIs
Best practices for contract security

Prerequisites

Node.js 18+
Basic Solidity knowledge
Firebase account
Lisk Sepolia testnet ETH (get from faucet)

⚠️ Note: To keep things manageable, this article is split into two parts:

Part 1 (this article): Deploy the raffle token and a simple raffle contract
Part 2: Extend the contract to accept predictions and automatically distribute prizes

Part 1: Understanding the Architecture

The Three-Layer System

┌───────────────────────────────┐
│ Layer 3: Flutter Mobile App   │
│ (User Interface - Article 2) │
└─────────────┬─────────────────┘
              │
┌─────────────▼─────────────────┐
│ Layer 2: Firebase Functions    │
│ (Serverless API - This Article)│
└─────────────┬─────────────────┘
              │
┌─────────────▼─────────────────┐
│ Layer 1: Smart Contracts       │
│ (Blockchain Logic - This Article) │
│ ├── RaffleToken (RTKN)        │
│ └── SoccerRaffle               │
└───────────────────────────────┘

Why this architecture?

Layer 1 (Smart Contracts): Handles money and trust — must live on-chain
Layer 2 (Cloud Functions): Handles reads — free for users browsing
Layer 3 (Flutter App): Handles UX — hides blockchain complexity

Part 2: Smart Contract Development

2.1: RaffleToken (RTKN)

Custom tokens are essential for:

Testing: Easy onboarding via faucet
Control: Manage supply and distribution
Branding: Custom name and symbol

We use 6 decimals to match USDT precision and avoid confusion.

Key Features:

decimals(): 6 → 1 RTKN = 1,000,000 units on-chain
faucet(): Lets anyone claim tokens for testing

Create contracts/RaffleToken.sol:

2.2: SoccerRaffle Contract

This contract manages all raffle logic. Core features include:

Commit-Reveal Randomness: Ensures fair winner selection
Emergency Draw: Allows anyone to trigger a fallback if the creator fails to reveal the seed
ReentrancyGuard: Protects token transfers from attacks

Create contracts/SoccerRaffle.sol:

Part 3: Hardhat Setup & Deployment

3.1: Initialize Project

mkdir soccer-raffle
cd soccer-raffle
npm init -y
npm install --save-dev hardhat @openzeppelin/contracts dotenv
npx hardhat init  # TypeScript project

3.2: Configure Hardhat

Create hardhat.config.ts:

3.3: Environment Variables

DEPLOYER_PRIVATE_KEY=your_private_key_here
LISK_TESTNET_RPC=https://rpc.sepolia-api.lisk.com

⚠️ Add .env to .gitignore

3.4: Deployment Scripts

scripts/deployRaffleToken.ts
scripts/deploySoccerRaffle.ts

Deploy:

npx hardhat run scripts/deployRaffleToken.ts --network liskTestnet
npx hardhat run scripts/deploySoccerRaffle.ts --network liskTestnet

Expected output:

✅ RaffleToken deployed at: 0x07Aa1131A1C06B4680458b0547528272BB603358
✅ SoccerRaffle deployed at: 0x5c6A781D663B689b7975A6339AD3eDe910023C6d

Part 4: Firebase Cloud Functions

Why Cloud Functions?

Allows users to browse raffles for free
Only pay gas when joining
Improves UX and conversion

Setup

npm install -g firebase-tools
firebase login
firebase init functions  # TypeScript, ESLint, install deps
cd functions
npm install ethers

Create functions/src/contracts/SoccerRaffleABI.ts:

Implement functions/src/index.ts:

Deploy:

cd functions
npm run build
firebase deploy --only functions

Test endpoints with curl or Postman.

Part 5: Creating Test Raffles

Create scripts/createTestRaffle.ts:

Run:

npx hardhat run scripts/createTestRaffle.ts --network liskTestnet

Part 6: Security Best Practices

Implemented:

ReentrancyGuard
SafeERC20 for token transfers
Access control (Ownable)
Pausable functionality
Input validation

Recommendations:

Professional audit (OpenZeppelin / Trail of Bits)
Bug bounty program
Gradual rollout
Consider Nexus Mutual coverage

Deployment Checklist:

Audit complete
All tests passing
Gas optimization done
Admin keys secured (multisig)
Monitoring enabled (Tenderly/Defender)
Emergency pause tested
Legal compliance verified

Conclusion

Deployed Infrastructure:

✅ RaffleToken (RTKN) — 10M supply, 6 decimals, faucet enabled
✅ SoccerRaffle Contract — commit-reveal, emergency draw
✅ Firebase Functions — 8 endpoints, zero-gas reads

Key Takeaways:

Test tokens simplify onboarding
Commit-reveal ensures fairness
Cloud functions improve UX
Deploy token before raffle contract

Next Steps

Article 2: Build the Flutter mobile app:

Wallet creation and management
Seamless token approvals
Real-time transaction monitoring
Gas-free, smooth UX

Article 3: Extend contract & UI:

Accept user predictions
Determine winners automatically
Real-time updates and notifications
Polished, intuitive UX

Resources

Deployed Contracts:

RaffleToken: 0x07Aa1131A1C06B4680458b0547528272BB603358
SoccerRaffle: 0x5c6A781D663B689b7975A6339AD3eDe910023C6d

End of Article 1

Flutter x Lisk: A Hands-On Series

IG — Fri, 10 Oct 2025 14:27:21 +0000

Building a Decentralized Soccer Raffle Platform: A Deep Dive Series

You can watch the video for this article here

I’ve been exploring the Lisk Protocol and wanted to dive deeper into its capabilities. To get hands-on experience, I decided to build a practical project — something simple yet meaningful — that goes beyond the usual DeFi tropes like lending pools, meme tokens, and NFT collectibles.

Enter the Decentralized Soccer Raffle Platform: a blockchain-powered system that lets users participate in provably fair raffles using smart contracts. Every draw is transparent, every reward verifiable, and there’s no need to trust any intermediary or opaque process.

This project demonstrates how decentralized systems can power familiar, real-world experiences — such as football raffles, community prize pools, or prediction games — in a trustless, fair, and global way.

The Use Case

Admins can create a raffle for any football match, setting parameters like minimum bet, maximum participants, and duration. Users then join the raffle using the platform’s native token.

For example: in May 2024, when PSG faced Inter Milan in the Champions League final, an admin could have created a raffle for fans to participate in — fully transparent and automated.

The Business Case: Fairness Meets Engagement

Traditional online raffles have a critical flaw: opacity. Users often have no way of verifying whether winners were selected fairly, even in regulated platforms. Centralized systems rely on private databases, hidden random number generation, and trust in a middleman.

With blockchain, we can ensure:

Transparency: All logic is on-chain. Anyone can verify outcomes.
Fairness: Random draws are auditable and provably fair.
Accessibility: Users worldwide can participate with a wallet.
Automation: Smart contracts handle payouts — no manual intervention.

And the real-world appeal is immediate: sports fans already understand raffles. We’re not teaching blockchain; we’re enhancing a familiar experience with decentralized fairness.

The Challenge: Bridging Web3 and Web2

While the decentralized logic runs on-chain, we still need:

Efficient user session management
Real-time updates
Off-chain storage for metadata
A smooth interface for blockchain interactions

Our tech stack balances Web3 transparency with Web2 convenience:

Smart Contracts (Solidity): Handle raffle logic, token flows, and fairness
Firebase Backend: Offloads reads, manages metadata, and reduces on-chain gas costs
Flutter Frontend: Delivers a slick, animated mobile experience with wallet integration

This architecture allows us to scale a blockchain product without compromising user experience or decentralization — a challenge every modern dApp faces.

Level of Complexity

This is not a quick tutorial. It’s a full-stack blockchain build spanning Solidity, Firebase, and Flutter — the kind of project that transforms intermediate developers into full-spectrum Web3 engineers.

By the end of this series, you’ll have deployed:

A custom ERC20 raffle token
A provably fair raffle smart contract on Lisk Sepolia
A serverless backend to interact with contracts off-chain
A Flutter app that connects wallets, tracks transactions, and provides animated, user-friendly UI

If you’ve ever wanted to understand how a complete decentralized product is architected — from blockchain to backend to mobile — this series is your blueprint.

Article Series Roadmap

This is a three-part deep dive, designed to be read sequentially or independently:

Article 1: Smart Contracts & Backend Infrastructure
Design and deploy Solidity contracts, set up the ERC20 token, and connect Firebase Cloud Functions for off-chain support. By the end, you’ll have a working blockchain backend ready for frontend integration.

Article 2: Flutter Architecture & Core Services
Build the app’s Flutter architecture: wallet management, blockchain transactions, and reactive state management to keep the UI in sync with blockchain data in real time.

Article 3: UI Implementation & Production Deployment
Bring everything together with a production-ready UI, performance optimizations, security hardening, and a full launch checklist.

Who This Series Is For

This series is for builders — developers eager to go beyond tutorials and understand how decentralized apps are architected end-to-end.

Whether you’re:

A Solidity developer curious about UI integration
A Flutter engineer exploring Web3
A founder testing a blockchain business idea

…you’ll find tremendous value in seeing how the layers fit together.

Coming Up Next

Part 1: Building the Foundation — Smart Contracts & Serverless Backend

We’ll start by designing the raffle logic in Solidity, creating our ERC20 token, and setting up Firebase Cloud Functions for secure off-chain reads and writes. By the end, you’ll have a fully functional blockchain backend ready to connect to your frontend.