🏗️ MyZubster – Building a Full-Stack NFT Ecosystem on Monero with Tari

🏗️ MyZubster – Building a Full-Stack NFT Ecosystem on Monero with Tari

Introduction

MyZubster is an ambitious open-source project that combines multiple technologies to create a private, decentralized skills marketplace with NFT support on Monero's Tari sidechain. This article provides a comprehensive technical overview of the architecture, technologies, and design decisions behind the project.

---

📋 Project Overview

MyZubster is not just a single application – it's an ecosystem of interconnected services:

Component	Technology	Purpose
NFT Template	Rust + Tari	Create and manage NFT collections on Monero's sidechain
Marketplace API	Node.js + Express	Skills marketplace with Monero payments
Gateway API	Node.js + Express	Unified API gateway for frontend and mobile apps
Web Dashboard	React + TypeScript	NFT management and marketplace interface
Mobile App	Kotlin + Jetpack Compose	Android app for on-the-go access

---

🦀 Rust Backend – NFT Template on Tari

The core NFT functionality is built in Rust using the tari_template_lib crate. Tari is Monero's official sidechain designed for digital assets.

Template Structure

rust
#[template]
mod my_first_nft {
    pub struct MyFirstNFT {
        nft_vault: Vault,
        collection_name: String,
        collection_symbol: String,
        mint_count: u32,
    }

    impl MyFirstNFT {
        pub fn new(name: String, symbol: String) -> Component<Self> {
            let nft_resource = ResourceBuilder::non_fungible()
                .metadata("name", name.clone())
                .metadata("symbol", symbol.clone())
                .metadata("description", "A Tari NFT Collection")
                .build();
            // ...
        }

        pub fn mint(&mut self, id: NonFungibleId, immutable_data: String, mutable_data: String) -> Bucket {
            let manager = self.nft_vault.get_resource_manager();
            let nft_bucket = manager.mint_non_fungible(
                id.clone(),
                &metadata! {
                    "immutable" => immutable_data,
                    "minted_at" => "2026-07-19",
                },
                &mutable_data,
            );
            // ...
        }
    }
}
Key Features

    Immutable & Mutable Metadata: Each NFT can store both permanent and changeable data.

    Vault System: Built-in resource management for secure asset storage.

    WASM Compilation: Deployed as WebAssembly on the Tari network.

🟢 Node.js Backend – Marketplace & Gateway

The marketplace and gateway are built with Node.js + Express, providing REST APIs for the frontend and mobile apps.
Marketplace API (/marketplace)
javascript

// routes/orders.js
router.get('/', (req, res) => {
  // Fetch orders from SQLite database
  res.json({ orders: [] });
});

router.post('/', (req, res) => {
  // Create new order with Monero payment address
  const { amount, currency, customerEmail } = req.body;
  // Generate Monero address for payment
  res.json({ orderId: 123, moneroAddress: '4...' });
});

Gateway API (/gateway)

The gateway acts as a single entry point for all clients:
javascript

// server.js
app.use('/api/users', require('./routes/users'));
app.use('/api/skills', require('./routes/skills'));
app.use('/api/orders', require('./routes/orders'));
app.use('/api/nft', require('./routes/nft'));

Database Layer

Both services use SQLite with rusqlite (Rust) and sqlite3 (Node.js):
sql

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    amount FLOAT NOT NULL,
    currency VARCHAR(3) DEFAULT 'USD',
    customerEmail VARCHAR(255) NOT NULL,
    moneroAddress VARCHAR(255) NOT NULL,
    moneroAmount FLOAT NOT NULL,
    status TEXT DEFAULT 'pending',
    txHash VARCHAR(255),
    confirmations INTEGER DEFAULT 0
);

⚛️ React Frontend – NFT Dashboard

The frontend is built with React 19 + TypeScript + Vite for a fast, type-safe experience.
Component Architecture
text

src/
├── components/
│   ├── ConnectWallet.tsx      # Tari wallet connection
│   ├── CreateCollection.tsx   # NFT collection creation
│   ├── MintNFT.tsx            # NFT minting interface
│   └── NFTGallery.tsx         # Gallery display
├── hooks/
│   └── useTariWallet.ts       # Wallet connection logic
└── App.tsx

Wallet Connection Hook
typescript

// useTariWallet.ts
import { WalletDaemonTariSigner } from '@tari-project/tarijs';

export const useTariWallet = () => {
  const connectWallet = async () => {
    const signer = await WalletDaemonTariSigner.buildFetchSigner({
      serverUrl: 'http://localhost:18103',
    });
    // ... handle connection
  };
  return { isConnected, signer, connectWallet };
};

UI Design

The interface follows a dark theme inspired by GitHub:
css

body {
  background: #0d1117;
  color: #e6edf3;
}

.card {
  background: #161b22;
  border: 1px solid #30363d;
  border-radius: 12px;
}

📱 Android App – Kotlin + Jetpack Compose

The mobile app (in development) is built with Kotlin and Jetpack Compose for a modern Android experience.
Key Features

    Skills Marketplace: Browse and offer local services

    Monero Payments: Send and receive XMR

    Encrypted Chat: Signal Protocol for end-to-end encryption

    Geolocation: Privacy-preserving location sharing

Tech Stack
Technology  Purpose
Kotlin  Modern Android development
Jetpack Compose Declarative UI
SQLCipher   Encrypted local database
Signal Protocol End-to-end encryption
🐳 Deployment – Docker & VPS

The entire ecosystem is containerized with Docker for easy deployment.
Docker Compose
yaml

version: '3.8'
services:
  backend:
    image: myzubster/tari-nft-template:latest
    ports:
      - "8080:8080"
    networks:
      - myzubster-network

  frontend:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./dist:/usr/share/nginx/html
    networks:
      - myzubster-network

Deployment Script
bash

#!/bin/bash
# deploy.sh
git pull origin main
cd myzubster-frontend && npm install && npm run build
docker-compose down && docker-compose up -d

🔗 Integration Flow
text

[User] → [React Frontend] → [Gateway API] → [Marketplace API] → [SQLite DB]
                               ↓                    ↓
                          [Rust Backend]     [Monero RPC]
                               ↓
                          [Tari Network]

🚀 Future Development
Feature Status  Timeline
NFT Royalties   📝 Planned    Q3 2026
Whitelist Minting   📝 Planned    Q3 2026
Android App Beta    🚧 In Progress    Q4 2026
PostgreSQL Support  📝 Planned    Q1 2027
Multi-Chain Support 🔬 Research   Q2 2027
📚 Resources

    GitHub (Public): https://github.com/DanielIoni-creator/tari-nft-template

    Dev.to Article Series: https://dev.to/danielioni

    Tari Documentation: https://tari.com/lessons

    Monero: https://www.getmonero.org/

📬 Connect with Me

    📖 Dev.to: https://dev.to/danielioni

    🐦 Twitter: https://x.com/myzubster

    💼 LinkedIn: https://linkedin.com/in/daniel-ioni-62b2b9423/

    🐙 GitHub: https://github.com/DanielIoni-creator

Built with ❤️ for the Monero and Tari community.

If you're a Rust, Node.js, or React developer interested in privacy tech, I'd love to hear 
![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/z83nl6v02suq6qmxa2re.png)your feedback!