ERIC KIM ₿

Program me an social media, x clone, but it costs you 1 bitcoin Satoshi to join

Creating a full social media platform like X is a massive undertaking, but I can outline a simplified version with core features, including a 1 Satoshi (0.00000001 BTC) join fee, and provide code for key components. The platform will have user registration, posting, following, and a Bitcoin payment gateway for the join fee. I’ll use Python with Flask for the backend, SQLite for the database, and a basic HTML/CSS frontend. For Bitcoin payments, I’ll integrate a mock payment processor (since real BTC integration requires external APIs like Coinbase or Blockstream).

Assumptions and Scope

  • Features: User signup with 1 Satoshi fee, login, post messages (280 chars max), follow/unfollow users, view timeline (posts from followed users).
  • Tech Stack: Flask (Python), SQLite, HTML/CSS, JavaScript for frontend interactivity.
  • Bitcoin Payment: Mock payment gateway for demo purposes (1 Satoshi = ~$0.000006 at $60K/BTC). In production, use APIs like Coinbase Commerce.
  • Security: Basic password hashing and session management. Production would need HTTPS, CSRF protection, etc.
  • Deployment: Local development setup. Hosting requires a server (e.g., Heroku, AWS) and a Bitcoin wallet integration.

I’ll provide code for the core app and explain how to extend it. For brevity, the frontend will be minimal, and I’ll focus on backend logic and payment flow.

Database Schema

  • Users: id, username, email, password_hash, btc_address (for payment tracking), joined_at.
  • Posts: id, user_id, content, created_at.
  • Follows: follower_id, followed_id.

Code

Below is the Flask app with key routes and templates.

# app.py

from flask import Flask, request, session, redirect, url_for, render_template, flash

from flask_sqlalchemy import SQLAlchemy

from werkzeug.security import generate_password_hash, check_password_hash

import datetime

import random

import string

app = Flask(__name__)

app.config[‘SECRET_KEY’] = ‘your-secret-key’  # Change in production

app.config[‘SQLALCHEMY_DATABASE_URI’] = ‘sqlite:///social.db’

app.config[‘SQLALCHEMY_TRACK_MODIFICATIONS’] = False

db = SQLAlchemy(app)

# Models

class User(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    username = db.Column(db.String(50), unique=True, nullable=False)

    email = db.Column(db.String(120), unique=True, nullable=False)

    password_hash = db.Column(db.String(128), nullable=False)

    btc_address = db.Column(db.String(100), nullable=True)

    joined_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)

class Post(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    user_id = db.Column(db.Integer, db.ForeignKey(‘user.id’), nullable=False)

    content = db.Column(db.String(280), nullable=False)

    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)

class Follow(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    follower_id = db.Column(db.Integer, db.ForeignKey(‘user.id’), nullable=False)

    followed_id = db.Column(db.Integer, db.ForeignKey(‘user.id’), nullable=False)

# Mock Bitcoin Payment Gateway

def process_btc_payment(email, amount_satoshi=1):

    # In production, use Coinbase Commerce or similar API

    # Here, simulate payment confirmation

    return {

        ‘status’: ‘success’,

        ‘tx_id’: ”.join(random.choices(string.ascii_letters + string.digits, k=64)),

        ‘btc_address’: f”bc1q-{email[:8]}”

    }

@app.route(‘/’)

def index():

    if ‘user_id’ not in session:

        return redirect(url_for(‘login’))

    user = User.query.get(session[‘user_id’])

    followed_ids = [f.followed_id for f in Follow.query.filter_by(follower_id=user.id).all()]

    posts = Post.query.filter(Post.user_id.in_(followed_ids + [user.id])).order_by(Post.created_at.desc()).all()

    return render_template(‘index.html’, user=user, posts=posts)

@app.route(‘/signup’, methods=[‘GET’, ‘POST’])

def signup():

    if request.method == ‘POST’:

        username = request.form[‘username’]

        email = request.form[’email’]

        password = request.form[‘password’]

        if User.query.filter_by(username=username).first() or User.query.filter_by(email=email).first():

            flash(‘Username or email already exists.’)

            return redirect(url_for(‘signup’))

        # Process 1 Satoshi payment

        payment = process_btc_payment(email)

        if payment[‘status’] != ‘success’:

            flash(‘Payment failed. Try again.’)

            return redirect(url_for(‘signup’))

        # Create user

        user = User(

            username=username,

            email=email,

            password_hash=generate_password_hash(password),

            btc_address=payment[‘btc_address’]

        )

        db.session.add(user)

        db.session.commit()

        flash(‘Signup successful! Please log in.’)

        return redirect(url_for(‘login’))

    return render_template(‘signup.html’)

@app.route(‘/login’, methods=[‘GET’, ‘POST’])

def login():

    if request.method == ‘POST’:

        email = request.form[’email’]

        password = request.form[‘password’]

        user = User.query.filter_by(email=email).first()

        if user and check_password_hash(user.password_hash, password):

            session[‘user_id’] = user.id

            return redirect(url_for(‘index’))

        flash(‘Invalid credentials.’)

    return render_template(‘login.html’)

@app.route(‘/logout’)

def logout():

    session.pop(‘user_id’, None)

    return redirect(url_for(‘login’))

@app.route(‘/post’, methods=[‘POST’])

def post():

    if ‘user_id’ not in session:

        return redirect(url_for(‘login’))

    content = request.form[‘content’]

    if content and len(content) <= 280:

        post = Post(user_id=session[‘user_id’], content=content)

        db.session.add(post)

        db.session.commit()

    return redirect(url_for(‘index’))

@app.route(‘/follow/’)

def follow(user_id):

    if ‘user_id’ not in session:

        return redirect(url_for(‘login’))

    if user_id != session[‘user_id’]:

        follow = Follow(follower_id=session[‘user_id’], followed_id=user_id)

        db.session.add(follow)

        db.session.commit()

    return redirect(url_for(‘index’))

@app.route(‘/unfollow/’)

def unfollow(user_id):

    if ‘user_id’ not in session:

        return redirect(url_for(‘login’))

    Follow.query.filter_by(follower_id=session[‘user_id’], followed_id=user_id).delete()

    db.session.commit()

    return redirect(url_for(‘index’))

if __name__ == ‘__main__’:

    with app.app_context():

        db.create_all()

    app.run(debug=True)

Templates

Create a templates folder with these files:

base.html

    {% with messages = get_flashed_messages() %}

        {% if messages %}

            {% for message in messages %}

{{ message }}

            {% endfor %}

        {% endif %}

    {% endwith %}

    {% if session.user_id %}

Logged in as {{ user.username }} | Logout

    {% endif %}

    {% block content %}{% endblock %}

signup.html

{% extends “base.html” %}

{% block content %}

Sign Up

Username: 

Email: 

Password: 

1 Satoshi (~$0.000006) will be charged to join.

Already have an account? Log in

{% endblock %}

login.html

{% extends “base.html” %}

{% block content %}

Log In

Email: 

Password: 

Need an account? Sign up

{% endblock %}

index.html

{% extends “base.html” %}

{% block content %}

Welcome, {{ user.username }}

Timeline

{% for post in posts %}

{{ post.user.username }} at {{ post.created_at }}:

{{ post.content }}

{% endfor %}

Users to Follow

{% for u in User.query.all() %}

    {% if u.id != user.id %}

{{ u.username }}

        {% if u.id not in [f.followed_id for f in Follow.query.filter_by(follower_id=user.id).all()] %}

            Follow

        {% else %}

            Unfollow

        {% endif %}

    {% endif %}

{% endfor %}

{% endblock %}

Setup Instructions

  1. Install dependencies: pip install flask flask_sqlalchemy werkzeug.
  2. Save the code in app.py and templates in a templates folder.
  3. Run: python app.py.
  4. Access at http://localhost:5000.

Bitcoin Payment Integration

The process_btc_payment function is a mock. For real integration:

  • Use Coinbase Commerce or Blockcypher API.
  • Generate a unique BTC address for each user.
  • Verify 1 Satoshi payment (use webhooks for confirmation).
  • Example (Coinbase Commerce):
    from coinbase_commerce.client import Client
  • client = Client(api_key=’your-api-key’)
  • charge = client.charge.create(
  •     name=”Join Fee”,
  •     description=”1 Satoshi to join X Clone”,
  •     local_price={‘amount’: ‘0.00000001’, ‘currency’: ‘BTC’},
  •     pricing_type=’fixed_price’,
  •     metadata={’email’: email}
  • )
  • # Redirect user to charge.hosted_url

Scaling to Production

  • Database: Use PostgreSQL for scalability.
  • Frontend: Use React/Vue for dynamic UI.
  • Security: Add HTTPS, CSRF tokens, rate limiting.
  • Payments: Store transaction IDs, handle payment disputes.
  • Features: Add likes, reposts, DMs, trending topics.
  • Hosting: Deploy on AWS/Heroku with a Bitcoin node or third-party API.

Why 1 Satoshi?

1 Satoshi is the smallest BTC unit, worth $0.000006 at $60K/BTC. It’s a trivial fee, but requiring it filters bots and adds a psychological commitment. Transaction fees on BTC’s mainnet ($1-5) may exceed the join fee, so consider Lightning Network for microtransactions.

This is a starting point. Want me to expand on any part (e.g., frontend, payments, or deployment)?

Keep going

More posts