Pay with Euros Online, Settled in Blockchain: How Stablecoins Bridge Web2 and Web3

💡 The Value Proposition: What if you could accept Euro payments online with 0.1% fees instead of 3% credit card processing? Our decentralized e-commerce platform lets customers pay with credit cards via Stripe, while the backend automatically converts them into a custom EUR-pegged stablecoin (EURT) on-chain. Web2 convenience meets Web3 efficiency.

🎯 The Problem: Why "Accept Crypto" Isn't E-Commerce

Most Web3 e-commerce projects make one simple thing: accept ETH or USDC as a payment method. This is like putting a "Bitcoin accepted here" sign on a traditional online store. It doesn't solve the fundamental problems:

This project goes further: it doesn't just accept crypto — it issues its own stablecoin pegged to the Euro (EURT) and builds a complete e-commerce ecosystem on top of it.

💡 The Architecture: Four Projects, One Ecosystem

The project is a monorepo composed of four sub-projects that interact with each other:

flowchart TD
    Customer["🛒 Customer<br/>(Credit Card)"] --> Stripe["💳 Stripe API<br/>(Payment Processing)"]
    Stripe --> Webhook["🔔 Webhook<br/>(Payment Confirmed)"]
    Webhook --> Backend["⚙️ Backend<br/>(Verification + Mint)"]
    Backend --> EURT["🪙 EURT Token<br/>(ERC-20 Stablecoin)"]
    
    Customer --> WebCustomer["🌐 Web Customer<br/>(Next.js dApp)"]
    WebCustomer --> EURT
    EURT --> Products["📦 Products<br/>(Smart Contracts)"]
    Products --> WebCustomer
    
    Admin["👨‍💼 Administrator"] --> WebAdmin["🖥️ Web Admin<br/>(Next.js Dashboard)"]
    WebAdmin --> Products
    WebAdmin --> EURT
    WebAdmin --> Companies["🏢 Companies<br/>(Registration)"]

Project Structure

🛠️ The EURT Token: Euro on the Blockchain

Why 6 Decimals?

The decision to use 6 decimals (instead of ETH's standard 18) is intentional: it represents Euro cents precisely, avoiding truncation problems in price calculations. 1 EURT = €1.00, 0.01 EURT = €0.01 (one cent).

The Fiat → Crypto On-Ramp

The most innovative flow is how traditional payments become blockchain tokens:

sequenceDiagram
    participant Customer
    participant Stripe as Stripe API
    participant Backend
    participant EURT as EURT Contract
    participant Wallet as Customer Wallet
    
    Customer->>Stripe: Enter credit card details
    Stripe->>Stripe: Process payment (3D Secure)
    Stripe-->>Backend: Webhook: payment_intent.succeeded
    Backend->>Backend: Verify payment_intent_id<br/>(idempotency check)
    Backend->>EURT: mint(customer, amount)
    EURT-->>EURT: EURT created in customer wallet
    EURT-->>Wallet: ✅ EURT received
    Wallet-->>Customer: 🛒 Ready to shop

⚠️ Critical Design Decision: Idempotency If Stripe's webhook is sent twice (which it does on retry), the contract could mint twice. The solution: register each payment_intent_id in the contract to prevent duplicate mints.

Smart Contract Architecture

The e-commerce contracts use a Modular Libraries architecture in Solidity:

flowchart LR
    MainContract["📜 Main E-Commerce<br/>Contract"]
    
    MainContract --> CompanyLib["🏢 CompanyLib<br/>(Registration + Activation)"]
    MainContract --> ProductLib["📦 ProductLib<br/>(CRUD + Stock)"]
    MainContract --> CustomerLib["👤 CustomerLib<br/>(Registration)"]
    MainContract --> CartLib["🛒 ShoppingCartLib<br/>(Cart + Totals)"]

Payment State Machine

stateDiagram-v2
    [*] --> Pending: Customer places order
    Pending --> Completed: Payment confirmed
    Pending --> Failed: Payment failed / timeout
    Completed --> Refunded: Customer requests refund
    Completed --> [*]: Order fulfilled
    Failed --> [*]: Order cancelled
    
    note right of Pending
        EURT locked in contract
        Stock reserved
    end note
    
    note right of Completed
        EURT released to merchant
        Stock deducted
    end note

💻 Frontend: Two Interfaces, One System

For Customers (web-customer)

flowchart TD
    Landing["🏠 Landing Page"] --> Connect["🔗 Connect Wallet"]
    Connect --> Browse["📦 Browse Products"]
    Browse --> Cart["🛒 Add to Cart"]
    Cart --> Checkout["💳 Checkout via Stripe"]
    Checkout --> StripeAuth["🔐 Stripe 3D Secure"]
    StripeAuth --> Mint["⏳ EURT Minting..."]
    Mint --> Shop["🛍️ Shop with EURT"]
    Shop --> Order["📦 Track Orders"]

Technology Stack:

• Next.js 15 — Server-side rendering for SEO
• Wagmi v2 — React hooks for Ethereum interaction
• Viem — Type-safe Ethereum client
• Stripe Elements — Secure payment form

For Administrators (web-admin)

flowchart LR
    Dashboard["📊 Dashboard<br/>(Sales Metrics)"] --> Inventory["📦 Inventory<br/>(Stock Management)"]
    Dashboard --> Companies["🏢 Company<br/>(Registration)"]
    Inventory --> Products["📝 Product<br/>(CRUD)"]
    Companies --> Orders["📋 Orders<br/>(Fulfillment)"]

📈 Impact: What This Architecture Enables

Real-World Example: A Purchase Flow

🔗 Why This Matters Beyond E-Commerce

This project demonstrates that the bridge between traditional finance and blockchain is already built. Stripe integration proves that Web2 payment infrastructure can work with Web3 smart contracts — not as competitors, but as complementary layers.

The progression is natural: First, you learn how to move value with a stablecoin (this post). Then, you learn how to secure that value with role-based governance (RWA Security Agents). Finally, you see how it all fits into the bigger picture of institutional finance (RWA Conclusion).

The Future: Programmable Commerce

Imagine a world where:

• Refunds are automatic — if a product doesn't arrive, smart contracts return the EURT
• Royalties are instant — creators receive their cut on every resale automatically
• Compliance is built-in — only verified wallets can transerve certain assets
• Analytics are real-time — every transaction is visible on-chain, no black boxes

✅ Key Takeaways

1. EURT is a custom ERC-20 stablecoin pegged to the Euro with 6 decimals (represents cents)
2. Stripe integration bridges Web2 and Web3 — customers pay with cards, blockchain handles settlement
3. Idempotency is critical — payment_intent_id registration prevents duplicate mints from webhook retries
4. Modular libraries architecture — separate concerns (Company, Product, Customer, Cart) for maintainability
5. Two frontends, one backend — customer dApp for shopping, admin dashboard for management
6. State machine for payments — Pending → Completed → (Refunded | Failed)
7. 0.1% fees vs 3% credit card fees — the economic incentive for blockchain commerce is real

📋 Table of Contents

• The Problem: Why "Accept Crypto" Isn't E-Commerce
• The Architecture: Four Projects
• EURT Token: Euro on Blockchain
• Why 6 Decimals
• Fiat to Crypto On-Ramp
• Smart Contract Architecture
• Payment State Machine
• Frontend: Two Interfaces
• Impact: What This Architecture Enables
• Programmable Commerce
• Stablecoin Performance Metrics
• Continuous Learning
• Contribute
• Related Articles

📊 Stablecoin Performance Metrics

🔗 Continuous Learning

Deepen your understanding of stablecoins and e-commerce blockchain integration:

💬 Want to Contribute?

This e-commerce ecosystem is open-source and welcomes contributions:

🔗 Related Articles

Explore other projects from the Blockchain and Web3 Master:

🔗 Explore the Implementation

The complete e-commerce ecosystem is available in the following repository: