Page cover

Architecture Overview

Idle Finance is designed as a desktop-first, multi-layered system that turns idle digital resources into yield. The system combines secure local compute environments with intelligent AI, blockchain-based rewards, and user-friendly dashboards. The diagram below shows how each part of Idle Finance connects from the desktop app that runs on the user’s device to the smart contracts on Base.

Let’s walk through the key parts of the architecture:

  • Desktop App (Electron) - Cross-platform user interface (Windows, Mac, Linux)

  • Backend API (NestJS) - User profiles, node orchestration, reward tracking

  • Automation Layer (FastAPI) - Golem deployment, KVM setup, monitoring (Linux only)

  • DePIN Network (Golem) - Currently the only supported network (Linux only)

  • Local Reward Tracking - GLM earnings tracked locally (bridging planned) Platform Support:

  • Desktop App: Windows, macOS, Linux

  • Golem Nodes: Linux only (requires KVM virtualization)

  • Automation API: Cross-platform (but only deploys to Linux) Data Flow:

  • User signs up → Profile created → Curated wallet generated

  • System check → Node deployed → Connection established

  • Node runs tasks → Rewards earned → Automatic tracking

  • Future: Rewards bridged → Vault deposited → Yield generated

The process is simple:

  1. Download the Idle Finance desktop app

  2. Launch and check if you have an existing profile

  3. Sign up with your name and email (if new)

  4. Wait for the system check

Your device gets a unique profile tied to its IP address. This keeps things secure while letting you use multiple devices (though they won't sync together).

System Requirements

Before we can start earning, we check your device: What We Need (Golem):

Golem Node Requirements (Linux Only):

  1. OS: Linux (Ubuntu 18.04+ works best) - Currently the only supported network

  2. CPU: 2+ cores with virtualization support (VMX/SVM)

  3. RAM: 4GB minimum, 8GB recommended

  4. Storage: 20GB free space

  5. Internet: Stable connection

  6. Virtualization: KVM support (automatically installed) What Golem Uses:

    1. CPU: 1-4 cores (we adjust based on your system)

    2. RAM: 2-8GB (flexible based on what you have)

    3. Storage: 10-50GB for tasks

    4. Network: Stable internet for work distribution

If your system doesn't meet requirements, we'll tell you exactly what needs upgrading and why the node can't start.

Note: Right now we only support Golem Network on Linux systems. The desktop app works on all platforms, but DePIN nodes only run on Linux.

First Run

Once everything checks out:

  1. Wallet created - we generate a secure wallet for you

  2. Node deployed - Golem provider starts running

  3. Connection established - your device connects to the network

  4. Dashboard ready - start monitoring your earnings Everything happens automatically. No technical setup needed.

Brief Orientation on Navigation

Main Sections:

  1. Dashboard - Real-time monitoring and controls

  2. Rewards - Earnings tracking and history

  3. Node - Deployment and management

  4. $IDLE Token - Coming soon (vault integration)

  5. Activity Log - Transaction and event tracking

Settings - Profile and wallet management

Main Sections:

  1. Dashboard - Real-time monitoring and controls

  2. Rewards - Earnings tracking and history

  3. Node - Deployment and management

  4. $IDLE Token - Coming soon (vault integration)

  5. Activity Log - Transaction and event tracking

  6. Settings - Profile and wallet management Key Features:

    1. Connection Status - Animated rings show real-time status

    2. Curated Wallet - Automatically generated, no manual management

    3. One-Click Controls - Start/stop nodes with single clicks

    4. Real-Time Updates - All metrics update automatically

Visual User Flow

Complete User Journey Flowchart

Key Decision Points:

  1. Profile Check - Existing user goes straight to dashboard

  2. System Check - Requirements not met shows upgrade guidance

  3. Node Deployment - Automatic setup with progress indicators

  4. Connection Status - Real-time feedback on network connectivity Error Handling:

  5. Hardware Issues - Clear guidance on system upgrades

  6. Network Problems - Automatic retry with status updates

  7. Node Failures - Automatic recovery and restart

  8. Wallet Issues - Secure backup and recovery systems

Architecture & Tech Stack

Frontend Layer:

  1. Electron Desktop App - Cross-platform desktop application

  2. React/TypeScript - Modern UI with real-time updates

  3. Zustand - Local state management

  4. Tailwind CSS - Styling and responsive design

Backend Layer:

  1. NestJS - RESTful API framework

  2. SQLite - Local database for user profiles

  3. TypeORM - Database management and migrations

  4. Swagger - API documentation and testing Automation Layer:

    1. Golem Integration - Automated provider deployment

    2. KVM Virtualization - Resource isolation and management

    3. Cross-Platform Support - Linux, macOS, Windows compatibility

    4. Real-Time Monitoring - Performance tracking and logging Blockchain Layer:

      1. Base Network - Coinbase's L2 for smart contracts

      2. Meta-Vault Contracts - Yield aggregation and management

      3. Ethereum Bridge - Cross-chain reward bridging

      4. Non-Custodial Design - User maintains full control

Data Flow Architecture

User Registration Flow:

  1. Client → Electron app launches

  2. Backend → NestJS API receives registration

  3. Database → SQLite stores user profile

  4. Wallet → Curated wallet generated locally

  5. Automation → Golem provider deployed

  6. Monitoring → Real-time status tracking Reward Collection Flow:

  7. Node → Golem provider runs compute tasks

  8. Network → GLM tokens earned on Ethereum

  9. Tracking → Backend monitors earnings

  10. Future → Automatic bridging to Base

  11. Vault → Smart contracts manage yield

Security Architecture

Local Security:

  1. Encrypted Storage - Wallet data encrypted with device keys

  2. Local Processing - Sensitive operations on user device

  3. Non-Custodial - Users maintain full control

  4. Device-Specific - Profiles tied to specific devices Network Security:

    1. HTTPS/TLS - All communications encrypted

    2. API Authentication - Secure endpoint access

    3. Input Validation - Comprehensive data validation

    4. Error Handling - Secure error responses Privacy Protection:

      1. Minimal Data Collection - Only necessary information

      2. Local Analytics - Performance data stays on device

      3. Anonymous Participation - DePIN participation without identification

      4. GDPR Compliance - European data protection standards

Setup for Local Development

Prerequisites

System Requirements:

OS: Linux (Ubuntu 18.04+), macOS 10.15+, or Windows 10+ Node.js: Version 18+ with npm

Python: Version 3.8+ for automation scripts Git: Latest version for version control Hardware Requirements:

  1. CPU: 4+ cores recommended for development

  2. RAM: 8GB+ for running multiple services

  3. Storage: 50GB+ free space for dependencies

  4. Network: Stable internet connection Development Tools:

    1. VS Code - Recommended IDE with extensions

    2. Postman - API testing and documentation

    3. SQLite Browser - Database management

    4. Chrome DevTools - Frontend debugging

Installation Steps

  1. Clone Repository:

git clone https://github.com/your-org/idle-finance-v2.git cd idle-finance-v2

  1. Install Dependencies: # Frontend dependencies

cd frontend npm install

# Backend dependencies cd ../backend

npm install

# Automation dependencies cd ../automation/golem

pip install -r requirements.txt

  1. Environment Setup:

# Backend environment cd backend

cp .env.example .env

# Edit .env with your configuration

# Frontend environment cd ../frontend

cp .env.example .env

# Edit .env with your configuration

  1. Database Setup: cd backend

npm run migration:run npm run seed

Running Locally

  1. Start Backend:

// cd backend
// npm run start:dev

# API available at http://localhost:3000

# Swagger docs at http://localhost:3000/api/v1/docs

  1. Start Frontend:

cd frontend npm run dev

# App available at http://localhost:5173

  1. Start Automation (Optional): cd automation/golem

python -m uvicorn main:app --reload Automation API at http://localhost:8000

  1. Build Desktop App: cd frontend

npm run build
npm run electron:dev

How It Works

The Curated Wallet System

The Problem: Traditional DePIN participation requires:

  1. Creating and managing Web3 wallets

  2. Handling private keys

  3. Understanding blockchain transactions

  4. Managing multiple token types

Our Solution: We handle all of that for you. What We Do:

  1. Generate a secure wallet during signup

  2. Encrypt and store keys locally

  3. Automatically collect rewards

  4. Track everything transparently

  5. Keep you in full control Security:

  6. Everything encrypted locally

  7. Device-specific access

  8. Non-transferable profiles

  9. Automatic backups

Behind the Scenes

Your Desktop App:

  1. Cross-platform (Windows, Mac, Linux)

  2. Real-time monitoring

  3. Local state management

  4. Automatic updates Our Backend:

    1. Manages your profile and wallet

    2. Orchestrates node deployment

    3. Tracks rewards and performance

    4. Handles all the complex stuff Golem Integration:

      1. Automatically deploys provider nodes

      2. Monitors performance in real-time

      3. Optimizes resource usage

      4. Handles all the technical details Local Reward Tracking:

        1. Tracks GLM earnings locally

        2. Real-time performance monitoring

        3. Secure local storage

        4. Future: Will bridge to other networks

Earning Process

How You Earn:

  1. Node runs - Golem provider does compute tasks

  2. Rewards earned - GLM tokens on Ethereum network

  3. Automatic tracking - we monitor everything locally

  4. Real-time updates - see earnings as they happen

  5. Future features - bridging and vaults coming soon

Using Idle Finance

Dashboard

Your main control center shows:

  1. Connection status - animated rings show if you're connected

  2. Earnings - live GLM token tracking

  3. System health - CPU, memory, disk usage

  4. Node controls - start/stop your node

  5. Performance - uptime and efficiency stats

Everything updates in real-time. No manual refresh needed.

Rewards

  1. Live updates - see GLM tokens as they come in

  2. History - earnings over time

  3. Collection - rewards automatically tracked

  4. Transparency - know exactly what you're earning

Node Management

  1. Start/Stop - one-click control

  2. Status - see if it's running

  3. Resources - CPU, memory, disk usage

  4. Performance - uptime and efficiency

  5. Settings - we optimize automatically

Activity Log

See everything that happens:

  1. Node events - starts, stops, status changes

  2. Rewards - when you earn GLM tokens

  3. System alerts - performance issues

  4. Performance - uptime and resource usage

Settings

Manage your account:

  1. Profile - name, email, device info

  2. Wallet - view your curated wallet (show/hide address)

  3. Preferences - notifications, optimizations

Security - two-factor auth, account protection

See everything that happens:

  1. Node events - starts, stops, status changes

  2. Rewards - when you earn GLM tokens

  3. System alerts - performance issues

  4. Performance - uptime and resource usage

PreviousIdle Finance IntroductionNextDePIN Ecosystem

Last updated