Meme Core — Advanced Meme Token Bundler

Desktop application for creating, managing, and bundling meme tokens on Solana

Features · Quick Start · Installation · Usage · API

---

Table of Contents

• About
• Features
• Architecture
• Quick Start
• Installation
• Configuration
• Usage
• API Reference
• Development
• License

---

About

Meme Core is a desktop application built with Rust and React for creating, deploying, and managing meme tokens on the Solana blockchain with Pump.fun integration.

Why Meme Core?

Feature	Description
Performance	Rust backend for maximum speed and reliability
Modern UI	React + Tailwind CSS with responsive design
Wallet Tools	Multi-wallet support, SOL distribution, bulk operations
Security	Local key management, desktop-first architecture
Trading	Quick buy/sell, slippage protection, priority fee control

---

Features

Token Creation & Management

• One-click token deployment on Pump.fun
• Custom metadata with IPFS integration
• Bulk token operations

Wallet Management

• Multi-wallet support
• SOL distribution across wallets
• Balance monitoring and refunds
• Account cleanup (close empty token accounts, burn tokens)

Trading

• Quick buy/sell with configurable slippage
• Slippage protection and priority fee management

Bundler Capabilities

• Coordinated token launches across multiple wallets
• Volume generation and timing strategies

---

Architecture

solana-bundler-rust/
├── back/                    # Rust backend (Tauri)
│   ├── src/
│   │   ├── config.rs       # Configuration
│   │   ├── jobs.rs         # Background tasks
│   │   ├── main.rs         # Tauri entry
│   │   ├── services/       # Business logic
│   │   │   ├── create_meme_token.rs
│   │   │   ├── distribute_sol.rs
│   │   │   ├── refund_wallets.rs
│   │   │   ├── close_accounts.rs
│   │   │   ├── close_token_account.rs
│   │   │   ├── burn_tokens.rs
│   │   │   ├── get_sol_balance.rs
│   │   │   ├── get_token_balance.rs
│   │   │   ├── quick_buy.rs
│   │   │   └── quick_sell.rs
│   │   └── solana/         # Blockchain integration
│   │       ├── buy.rs
│   │       ├── sell.rs
│   │       ├── create.rs
│   │       ├── ipfs.rs
│   │       ├── tokens.rs
│   │       └── utils.rs
│   └── tauri.conf.json
├── front/                   # React frontend
│   ├── src/
│   │   ├── components/
│   │   ├── views/
│   │   ├── context/
│   │   └── lib/
│   └── package.json
└── pumpfun-rs/             # Pump.fun SDK

---

Quick Start

Prerequisites

• Windows 10/11 (primary support)
• Node.js 18+ and npm
• Rust 1.70+ and Cargo
• Visual Studio Build Tools (C++)
• Git

One-Line Setup

git clone https://github.com/soladdev/solana-bundler-rust.git
cd solana-bundler-rust
cd front && npm install && cd ..
cd back && cargo tauri dev

---

Installation

Step 1: vcpkg (Windows)

git clone https://github.com/microsoft/vcpkg C:\vcpkg
C:\vcpkg\bootstrap-vcpkg.bat
C:\vcpkg\vcpkg.exe install openssl:x64-windows

Step 2: Environment Variables

$env:VCPKG_ROOT = "C:\vcpkg"
$env:OPENSSL_DIR = "C:\vcpkg\installed\x64-windows"
$env:OPENSSL_LIB_DIR = "$env:OPENSSL_DIR\lib"
$env:OPENSSL_INCLUDE_DIR = "$env:OPENSSL_DIR\include"
$env:VCPKGRS_DYNAMIC = "1"
$env:RUST_LOG = "info"

Step 3: Build & Run

# Clone
git clone https://github.com/soladdev/solana-bundler-rust.git
cd solana-bundler-rust

# Frontend
cd front
npm install
cd ..

# Build Rust
cargo build

# Development
cd back
cargo tauri dev

This starts the React dev server and launches the Tauri app with hot-reload.

---

Configuration

Environment Variables

Create a .env file in the back/ directory or set environment variables:

# RPC (Helius)
HELIUS_HTTPS=https://api.mainnet-beta.solana.com
HELIUS_WS=wss://api.mainnet-beta.solana.com

# Optional
MONGODB_URI=mongodb://localhost:27017
JWT_TOKEN=your_jwt_token
PRIVATE_KEY=your_base58_private_key

# Trading
SOL_TO_SPEND=0.01
SLIPPAGE=0.05

# Logging
RUST_LOG=info

Wallet Import

CSV format (wallets.csv):

publicKey,privateKey
<public_key>,<base58_private_key>

Import via Wallet Manager → Import Wallets.

---

Usage

Create a Token

1. Open Pumpfun bundler from the sidebar
2. Set token details (name, symbol, description, supply)
3. Configure launch parameters (SOL amount, slippage, priority fees)
4. Click Create Token and monitor the transaction

Auto-Buy Configuration

1. Open Auto-Buy Panel
2. Set trigger conditions (price, volume, time)
3. Select wallets and configure amounts per wallet

Bundler Operations

1. Select target token
2. Configure bundle (wallets, amounts, timing)
3. Execute and monitor results

---

API Reference

Token Creation

pub struct CreateTokenReq {
    pub name: String,
    pub symbol: String,
    pub decimals: f64,
    pub supply_human: u64,
    pub dev_sol_amount: f64,
    pub slippage_bps: u64,
    // ...
}

Wallet Operations

distribute_sol(src: String, wallets: Vec<String>, total_amount_sol: f64) -> Result<String, String>
refund_wallets(pks: Vec<String>, refund_to: String, funding_pk: String) -> Result<String, String>
close_accounts(wallet_pk: String) -> Result<String, String>

Trading

quick_buy(req: QuickBuyReq) -> Result<TransactionRes, String>
quick_sell(req: QuickSellReq) -> TransactionRes

---

Development

Project Structure

The project uses a Cargo workspace:

solana-bundler-rust/
├── Cargo.toml          # Workspace root
├── front/               # React (Vite)
└── back/                # Tauri + Rust

Build

# Development
cd back
cargo tauri dev

# Production
cargo tauri build
# Output: back/target/release/bundle/

Testing

cargo test
cd front && npm test

Guidelines

• Follow Rust conventions and cargo clippy
• Use TypeScript for new frontend components
• Add tests for new functionality

---

Contact

• GitHub: @soladdev
• Telegram: @soladdev

---

Meme Core · Built with Rust, React & Tauri · soladdev