Power your agent
การติดตั้งจากผู้เผยแพร่ ไม่ใช่เอนด์พอยต์ของ PlugMCP
URL แบบรีโมตหรือคำสั่งบนเครื่องของคุณ? การติดตั้งสองแบบต่างกันอย่างไร
รันบน PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
เปิดจากผู้เผยแพร่
TypeScript MCP servers for DeFi: price data, wallet analytics, yield discovery and Solana wallet and trading tools.
Boosty is a production-grade Model Context Protocol (MCP) server platform designed for real DeFi operations. Unlike simulation tools, Boosty executes actual transactions on Solana mainnet and EVM chains, providing:
Boosty transforms Claude Desktop into a powerful DeFi control center. Through the Model Context Protocol, you can:
You: "Buy $500 worth of BONK using Jupiter, split across 3 transactions over the next hour"
Boosty: ✅ Created campaign with 3 scheduled buys
- Trade 1: $166.67 at 2:00 PM (completed)
- Trade 2: $166.67 at 2:20 PM (pending)
- Trade 3: $166.66 at 2:40 PM (pending)
You: "Start a volume campaign for my token at address Abc123...
Generate $50k daily volume with organic patterns,
use 200 wallets, vary transaction sizes between $50-500"
Boosty: 📊 Volume Campaign Started
- Token: ABC/SOL
- Daily Target: $50,000
- Active Wallets: 200
- Pattern: Organic (gaussian distribution)
- Duration: 7 days
- Estimated Cost: 2.3 SOL (fees + rent)
You: "Show me all my positions across all wallets"
Boosty: 💼 Portfolio Summary (47 wallets)
Total Value: $234,567.89
Top Holdings:
- SOL: $89,234 (38.0%)
- USDC: $45,678 (19.5%)
- BONK: $23,456 (10.0%)
DeFi Positions:
- Raydium USDC/SOL LP: $34,567
- Marinade stSOL: $12,345
Boosty follows a modular monorepo architecture designed for enterprise scalability:
┌─────────────────────────────────────────────────────────────────────────────┐
│ CLAUDE DESKTOP │
│ (Model Context Protocol) │
└─────────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ @boosty/mcp-server │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────────┐ │
│ │ Resources │ │ Tools │ │ Prompts │ │ Subscriptions │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
│
┌──────────────────────────┼──────────────────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
│ @boosty/prices │ │ @boosty/orchestrator │ │ @boosty/wallets │
│ │ │ │ │ │
│ • Token Prices │ │ • Campaign Manager │ │ • Portfolio View │
│ • Gas Prices │ │ • Task Queue │ │ • Balance Tracking │
│ • Market Data │ │ • Bot Coordinator │ │ • NFT Holdings │
│ • Fear/Greed │ │ • Pattern Generator │ │ • DeFi Positions │
└────────┬─────────┘ └──────────┬───────────┘ └──────────┬───────────┘
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
│ CoinGecko API │ │ @boosty/trading │ │ Alchemy API │
│ DefiLlama API │ │ │ │ DeBank API │
│ Alternative.me │ │ • Jupiter V6 │ │ Helius API │
└──────────────────┘ │ • Raydium V2 │ └──────────────────────┘
│ • Orca Whirlpools │
│ • PumpFun │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ @boosty/solana-core │
│ │
│ • RPC Connection │
│ • Transaction Build │
│ • Jito Bundles │
│ • Priority Fees │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│@boosty/wallet-manager│
│ │
│ • HD Derivation │
│ • Key Encryption │
│ • Fund Distribution │
└──────────────────────┘
│
┌────────────────────────┼────────────────────────┐
▼ ▼ ▼
┌──────────────────┐ ┌──────────────────┐ ┌──────────────────────┐
│ PostgreSQL │ │ Redis │ │ Solana Mainnet │
│ │ │ │ │ │
│ • Wallets │ │ • Task Queue │ │ • Transactions │
│ • Campaigns │ │ • Rate Limits │ │ • Token Accounts │
│ • Trade History │ │ • Session Cache │ │ • Program Calls │
│ • Positions │ │ • Pub/Sub │ │ │
└──────────────────┘ └──────────────────┘ └──────────────────────┘
Execute actual swaps on Solana DEXs with intelligent routing:
Transaction Features:
Create organic-looking market activity for tokens:
Pattern Types:
enum VolumePattern {
ORGANIC = 'organic', // Natural market behavior simulation
AGGRESSIVE = 'aggressive', // High frequency, visible volume
STEALTH = 'stealth', // Below detection thresholds
CUSTOM = 'custom' // User-defined parameters
}
Organic Pattern Features:
Manage thousands of wallets with military-grade security:
HD Wallet Derivation:
Master Seed (BIP39)
└── Purpose (44')
└── Coin Type (501' for Solana)
└── Account Index
└── Change
└── Address Index
Security Features:
Real-time market intelligence:
Find and compare yield opportunities:
@boosty/mcp-server
├── @boosty/orchestrator
│ ├── @boosty/trading-engine
│ │ ├── @boosty/solana-core
│ │ └── @boosty/mcp-shared
│ ├── @boosty/wallet-manager
│ │ ├── @boosty/solana-core
│ │ └── @boosty/mcp-shared
│ └── @boosty/mcp-shared
├── @boosty/mcp-prices
│ └── @boosty/mcp-shared
├── @boosty/mcp-wallets
│ └── @boosty/mcp-shared
└── @boosty/mcp-yields
└── @boosty/mcp-shared
# 1. Clone the repository
git clone https://github.com/nirholas/boosty-mcp-servers.git
cd boosty-mcp-servers
# 2. Install dependencies
pnpm install
# 3. Set up environment
cp .env.example .env
# Edit .env with your API keys
# 4. Start infrastructure (Docker)
docker-compose up -d postgres redis
# 5. Run database migrations
pnpm db:migrate
# 6. Build all packages
pnpm build
# 7. Start the MCP server
pnpm start
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"boosty": {
"command": "node",
"args": ["/path/to/boosty-mcp-servers/packages/combined/dist/cli.js"],
"env": {
"SOLANA_RPC_URL": "https://api.mainnet-beta.solana.com",
"ALCHEMY_API_KEY": "your-key-here",
"COINGECKO_API_KEY": "your-key-here",
"DATABASE_URL": "postgresql://localhost:5432/boosty",
"REDIS_URL": "redis://localhost:6379"
}
}
}
}
In Claude Desktop, try:
"What's the current price of SOL?"
"Show me the top 10 yield opportunities on Solana"
"Get gas prices for Ethereum and Arbitrum"
# Install the combined server globally
npm install -g @boosty/mcp-defi
# Or use individual packages
npm install -g @boosty/mcp-prices
npm install -g @boosty/mcp-wallets
npm install -g @boosty/mcp-yields
# Clone with full history
git clone https://github.com/nirholas/boosty-mcp-servers.git
cd boosty-mcp-servers
# Install pnpm if needed
npm install -g pnpm
# Install all dependencies
pnpm install
# Build all packages in correct order
pnpm build
# Link for local development
pnpm link --global
# Pull the official image
docker pull boosty/mcp-defi:latest
# Run with environment variables
docker run -d \
--name boosty-mcp \
-e SOLANA_RPC_URL=https://api.mainnet-beta.solana.com \
-e ALCHEMY_API_KEY=your-key \
-e DATABASE_URL=postgresql://host:5432/boosty \
-e REDIS_URL=redis://host:6379 \
boosty/mcp-defi:latest
# Install in development mode
pnpm install
# Start in watch mode (rebuilds on changes)
pnpm dev
# Run specific package in dev mode
pnpm --filter @boosty/mcp-prices dev
pnpm --filter @boosty/mcp-wallets dev
pnpm --filter @boosty/mcp-yields dev
# Run tests
pnpm test
# Run tests with coverage
pnpm test:coverage
# Type checking
pnpm typecheck
# Linting
pnpm lint
pnpm lint:fix
Create a .env file in the project root:
# ============================================
# BLOCKCHAIN CONFIGURATION
# ============================================
# Solana RPC endpoints (required for trading)
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
SOLANA_RPC_WS_URL=wss://api.mainnet-beta.solana.com
# Dedicated RPC providers (recommended for production)
HELIUS_API_KEY=your-helius-key
QUICKNODE_ENDPOINT=https://your-endpoint.solana-mainnet.quiknode.pro
# Jito for MEV protection (optional but recommended)
JITO_BLOCK_ENGINE_URL=https://mainnet.block-engine.jito.wtf
JITO_AUTH_KEYPAIR=/path/to/jito-auth-keypair.json
# ============================================
# API KEYS
# ============================================
# CoinGecko (required for price data)
COINGECKO_API_KEY=your-coingecko-key
# Alchemy (required for EVM wallet data)
ALCHEMY_API_KEY=your-alchemy-key
# Block explorers (optional, improves data quality)
ETHERSCAN_API_KEY=your-etherscan-key
ARBISCAN_API_KEY=your-arbiscan-key
BASESCAN_API_KEY=your-basescan-key
SOLSCAN_API_KEY=your-solscan-key
# DeBank (optional, for DeFi positions)
DEBANK_API_KEY=your-debank-key
# ============================================
# DATABASE CONFIGURATION
# ============================================
# PostgreSQL connection
DATABASE_URL=postgresql://user:password@localhost:5432/boosty
DATABASE_POOL_SIZE=20
DATABASE_SSL=false
# Redis connection
REDIS_URL=redis://localhost:6379
REDIS_PASSWORD=
REDIS_DB=0
# ============================================
# SECURITY CONFIGURATION
# ============================================
# Master encryption key (generate with: openssl rand -hex 32)
MASTER_ENCRYPTION_KEY=your-256-bit-hex-key
# JWT secret for API auth (if using HTTP server)
JWT_SECRET=your-jwt-secret
# ============================================
# OPERATIONAL SETTINGS
# ============================================
# Logging
LOG_LEVEL=info # debug, info, warn, error
LOG_FORMAT=json # json, pretty
# Rate limiting
RATE_LIMIT_REQUESTS_PER_MINUTE=60
RATE_LIMIT_BURST_SIZE=10
# Cache settings
CACHE_TTL_SECONDS=300
CACHE_MAX_SIZE=1000
# ============================================
# TRADING SETTINGS
# ============================================
# Default slippage (in basis points, 100 = 1%)
DEFAULT_SLIPPAGE_BPS=100
# Priority fee settings
PRIORITY_FEE_PERCENTILE=75
MAX_PRIORITY_FEE_LAMPORTS=1000000
# Transaction retry settings
TX_MAX_RETRIES=3
TX_RETRY_DELAY_MS=1000
TX_CONFIRMATION_TIMEOUT_MS=60000
For advanced configuration, create boosty.config.ts:
import { defineConfig } from '@boosty/mcp-server';
export default defineConfig({
// Server settings
server: {
name: 'boosty-mcp',
version: '2.0.0',
transport: 'stdio', // or 'http'
},
// Chain configurations
chains: {
solana: {
rpcUrl: process.env.SOLANA_RPC_URL,
wsUrl: process.env.SOLANA_RPC_WS_URL,
commitment: 'confirmed',
priorityFee: {
percentile: 75,
maxLamports: 1_000_000,
},
},
ethereum: {
rpcUrl: process.env.ETHEREUM_RPC_URL,
chainId: 1,
},
arbitrum: {
rpcUrl: process.env.ARBITRUM_RPC_URL,
chainId: 42161,
},
},
// DEX configurations
dexes: {
jupiter: {
enabled: true,
apiUrl: 'https://quote-api.jup.ag/v6',
maxAccounts: 64,
},
raydium: {
enabled: true,
ammProgramId: '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8',
clmmProgramId: 'CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK',
},
orca: {
enabled: true,
whirlpoolProgramId: 'whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc',
},
pumpfun: {
enabled: true,
programId: '6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P',
},
},
// Volume generation defaults
volume: {
defaultPattern: 'organic',
minTransactionSize: 0.01, // SOL
maxTransactionSize: 10, // SOL
defaultInterval: {
min: 30, // seconds
max: 300, // seconds
},
},
// Wallet management
wallets: {
derivationPath: "m/44'/501'/0'/0'",
encryption: {
algorithm: 'aes-256-gcm',
keyDerivation: 'scrypt',
scryptParams: {
N: 2 ** 20,
r: 8,
p: 1,
},
},
},
// Monitoring
monitoring: {
prometheus: {
enabled: true,
port: 9090,
},
healthCheck: {
enabled: true,
port: 8080,
path: '/health',
},
},
});
getTokenPriceGet current price and market data for a token.
// Input
{
symbol: string; // Token symbol (e.g., "SOL", "BTC")
currency?: string; // Quote currency (default: "usd")
}
// Output
{
symbol: string;
name: string;
price: number;
change24h: number;
marketCap: number;
volume24h: number;
circulatingSupply: number;
totalSupply: number;
ath: number;
athDate: string;
lastUpdated: string;
}
getGasPricesGet current gas prices for a blockchain.
// Input
{
chain: "ethereum" | "arbitrum" | "base" | "polygon" | "solana";
}
// Output (EVM)
{
chain: string;
baseFee: number;
priorityFee: {
slow: number;
standard: number;
fast: number;
};
estimatedCosts: {
transfer: string;
swap: string;
};
}
// Output (Solana)
{
chain: "solana";
baseFee: number; // lamports
priorityFee: {
min: number;
median: number;
p75: number;
p90: number;
};
recentBlockhash: string;
}
getTopMoversGet top gaining and losing tokens.
// Input
{
limit?: number; // Number of results (default: 10)
sortBy?: "gainers" | "losers" | "volume";
}
// Output
{
gainers: TokenChange[];
losers: TokenChange[];
timestamp: string;
}
getFearGreedIndexGet the crypto Fear & Greed Index.
// Input: none
// Output
{
value: number; // 0-100
classification: string; // "Extreme Fear" | "Fear" | "Neutral" | "Greed" | "Extreme Greed"
timestamp: string;
previousClose: number;
weekAgo: number;
monthAgo: number;
}
comparePricesCompare multiple tokens side by side.
// Input
{
symbols: string[]; // Array of token symbols
}
// Output
{
tokens: TokenComparison[];
bestPerformer: string;
worstPerformer: string;
timestamp: string;
}
getWalletPortfolioGet complete portfolio overview.
// Input
{
address: string;
chain?: string; // Optional, defaults to all chains
}
// Output
{
address: string;
totalValue: number;
chains: {
[chain: string]: {
nativeBalance: number;
tokenValue: number;
nftValue: number;
defiValue: number;
};
};
topHoldings: TokenHolding[];
lastUpdated: string;
}
getTokenBalancesGet token balances for a wallet.
// Input
{
address: string;
chain: string;
includeSpam?: boolean;
}
// Output
{
address: string;
chain: string;
tokens: {
address: string;
symbol: string;
name: string;
balance: string;
decimals: number;
price: number;
value: number;
change24h: number;
}[];
totalValue: number;
}
getDeFiPositionsGet DeFi protocol positions.
// Input
{
address: string;
}
// Output
{
address: string;
totalValue: number;
positions: {
protocol: string;
chain: string;
type: "lending" | "liquidity" | "staking" | "farming";
assets: Asset[];
value: number;
apy: number;
rewards: Reward[];
}[];
}
getTopYieldsGet highest yield opportunities.
// Input
{
chain?: string;
minTvl?: number;
maxApy?: number;
limit?: number;
stablecoinOnly?: boolean;
}
// Output
{
pools: {
id: string;
protocol: string;
chain: string;
symbol: string;
tvl: number;
apy: number;
apyBase: number;
apyReward: number;
ilRisk: "none" | "low" | "medium" | "high";
}[];
timestamp: string;
}
getRiskAssessmentGet risk analysis for a pool.
// Input
{
poolId: string;
}
// Output
{
poolId: string;
overallRisk: "low" | "medium" | "high" | "critical";
factors: {
smartContractRisk: number; // 1-10
impermanentLoss: number;
liquidity: number;
protocolRisk: number;
tokenRisk: number;
};
recommendations: string[];
auditStatus: string;
}
Jupiter provides the best swap rates through aggregation:
import { JupiterClient } from '@boosty/trading-engine';
const jupiter = new JupiterClient({
apiUrl: 'https://quote-api.jup.ag/v6',
maxAccounts: 64,
});
// Get quote
const quote = await jupiter.getQuote({
inputMint: 'So11111111111111111111111111111111111111112', // SOL
outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
amount: 1_000_000_000, // 1 SOL in lamports
slippageBps: 50,
});
// Execute swap
const result = await jupiter.executeSwap({
quote,
userPublicKey: wallet.publicKey,
priorityFee: 'auto',
});
Direct AMM and CLMM access:
import { RaydiumClient } from '@boosty/trading-engine';
const raydium = new RaydiumClient({
connection,
ammProgramId: '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8',
});
// Swap on AMM
const tx = await raydium.swap({
poolId: 'pool-address',
amountIn: 1_000_000_000,
minimumAmountOut: 0,
direction: 'baseToQuote',
});
// Add liquidity
const addLiqTx = await raydium.addLiquidity({
poolId: 'pool-address',
baseAmount: 1_000_000_000,
quoteAmount: 50_000_000,
slippage: 0.01,
});
pump coins are read, quoted and traded through the official @pump-fun/pump-sdk and @pump-fun/pump-swap-sdk for the current Pump program:
buy_exact_quote_in_v3 and sells sell_v3. Cashback coins, which the v3 instructions reject, use buy_v2 / sell_v2.virtualQuoteReserves.curve, completed (curve full, migration pending, no trades), pumpswap, or raydium (legacy coins that migrated before PumpSwap existed; trade those on Raydium).import { PumpFunClient } from '@boosty/mcp-trading-engine';
// TradingEngineConfig: rpcEndpoint, plus wsEndpoint for the launch monitor
const pumpfun = new PumpFunClient(config);
// Where does the coin trade, and what would 0.1 SOL buy?
const market = await pumpfun.getMarket(mint);
const quote = await pumpfun.calculateBuyOutput(mint, 100_000_000n);
console.log(market.venue, quote.amountOut, quote.feeBps, quote.priceImpact);
// Buy, spending 0.1 SOL fees included, on the curve or the PumpSwap pool
const buy = await pumpfun.buyWithSigner(
{ mint, userPublicKey, quoteAmount: 100_000_000n, slippageBps: 500 },
signTransaction // or a 64-byte secret key
);
// Sell tokens (base units) for the quote mint
const sell = await pumpfun.sellWithSigner(
{ mint, userPublicKey, tokenAmount: 1_000_000_000n, slippageBps: 500 },
signTransaction
);
// Multi-hop: SOL to coin A to coin B (B quoted in A) in one multi_hop_swap
const hop = await pumpfun.multiHopSwapWithSigner(
{ path: [SOL_MINT, coinA, coinB], side: 'buy', userPublicKey, amountIn: 10_000_000n, slippageBps: 500 },
signTransaction
);
// New launches, decoded from the program's CreateEvent logs
const unsubscribe = pumpfun.subscribeToNewTokens(token => console.log(token.mint, token.quoteMint));
SmartRouter routes a pair to pump whenever one side is a pump coin quoted in the other (resolvePair).
@boosty/token-launcher creates Token-2022 coins with create_v2, optionally with the creator's first buy in the same transaction, and snipes launches across wallets:
import { TokenLauncher } from '@boosty/token-launcher';
const launcher = new TokenLauncher({ rpcUrl }, walletProvider);
const coin = await launcher.createPumpFunToken(
{
name: 'My Coin',
symbol: 'MINE',
description: 'What the coin is for',
image: 'https://ipfs.io/ipfs/<image-cid>',
walletId,
initialBuyAmount: '0.5', // whole quote units: 0.5 SOL
slippageBps: 500,
// quoteMint: a listed quote mint or a pump coin; SOL when omitted
},
uploadMetadata // (metadata JSON) => Promise<uri>
);
// Trade it later (quote base units in, token base units out)
await launcher.buyOnPumpFun(coin.mint, walletId, 100_000_000n, 500);
const state = await launcher.getBondingCurveState(coin.mint); // venue, reserves, quote mint
Transactions are compiled against pump.fun's address lookup table, which keeps the create and first buy in one transaction. A coin quoted in another pump coin carries that coin's curve accounts as well; when the pair does not fit, the first buy is sent right after the create confirms (devBuySignature). snipeWithJitoBundle builds one signed buy per wallet (up to five) and submits them as one Jito bundle.
Protect transactions from front-running:
import { JitoClient } from '@boosty/solana-core';
const jito = new JitoClient({
blockEngineUrl: 'https://mainnet.block-engine.jito.wtf',
authKeypair: loadKeypair('/path/to/auth-keypair.json'),
});
// Submit bundle
const bundleId = await jito.sendBundle({
transactions: [tx1, tx2, tx3],
tipLamports: 10_000, // Tip to validator
});
// Wait for confirmation
const status = await jito.getBundleStatus(bundleId);
Create and manage volume generation campaigns:
import { Orchestrator } from '@boosty/orchestrator';
const orchestrator = new Orchestrator({
database: pgPool,
redis: redisClient,
tradingEngine,
walletManager,
});
// Create campaign
const campaign = await orchestrator.createCampaign({
name: 'ABC Token Launch',
type: 'volume_generation',
token: {
mint: 'ABC-token-address',
symbol: 'ABC',
},
target: {
dailyVolume: 50_000, // USD
duration: 7 * 24 * 60 * 60, // 7 days in seconds
},
pattern: {
type: 'organic',
buyRatio: 0.52, // Slight buy pressure
sizeDistribution: {
min: 50,
max: 500,
mean: 150,
stdDev: 100,
},
intervalDistribution: {
min: 30,
max: 600,
mean: 180,
},
},
wallets: {
count: 200,
ageRequirement: 7 * 24 * 60 * 60, // 7 days old minimum
fundingSource: 'treasury',
},
});
// Start campaign
await orchestrator.startCampaign(campaign.id);
// Monitor progress
const stats = await orchestrator.getCampaignStats(campaign.id);
console.log({
volumeGenerated: stats.totalVolume,
transactionsExecuted: stats.transactionCount,
uniqueWallets: stats.uniqueWallets,
averageTransactionSize: stats.avgTxSize,
successRate: stats.successRate,
});
Simulates natural market behavior:
const organicPattern = {
type: 'organic',
// Time-based activity weighting
timeWeights: {
'00-04': 0.3, // Low activity late night
'04-08': 0.5, // Building up
'08-12': 1.0, // Peak morning
'12-16': 0.9, // Afternoon
'16-20': 1.0, // Peak evening
'20-24': 0.6, // Winding down
},
// Transaction clustering (organic bursts)
clustering: {
enabled: true,
burstProbability: 0.15,
burstSize: { min: 3, max: 8 },
burstInterval: { min: 5, max: 30 }, // seconds
},
// Whale transactions
whaleTransactions: {
enabled: true,
probability: 0.02,
sizeMultiplier: { min: 5, max: 20 },
},
};
Stay below detection thresholds:
const stealthPattern = {
type: 'stealth',
// Keep individual transactions small
maxTransactionPercent: 0.1, // Max 0.1% of daily volume per tx
// Spread across many wallets
minWallets: 500,
maxTransactionsPerWallet: 5,
// Long intervals
interval: {
min: 300, // 5 minutes
max: 1800, // 30 minutes
},
// Avoid patterns
antiPattern: {
varyTimezone: true,
varyDayOfWeek: true,
noRoundNumbers: true,
randomizeWalletSelection: true,
},
};
BullMQ-powered task processing:
import { Queue, Worker } from 'bullmq';
// Task types
enum TaskType {
EXECUTE_TRADE = 'execute_trade',
FUND_WALLET = 'fund_wallet',
COLLECT_FUNDS = 'collect_funds',
CHECK_BALANCE = 'check_balance',
UPDATE_STATS = 'update_stats',
}
// Create worker
const worker = new Worker('boosty-tasks', async (job) => {
switch (job.name) {
case TaskType.EXECUTE_TRADE:
return await executeTrade(job.data);
case TaskType.FUND_WALLET:
return await fundWallet(job.data);
// ...
}
}, {
connection: redis,
concurrency: 10,
limiter: {
max: 100,
duration: 1000, // 100 jobs per second max
},
});
Generate thousands of wallets from a single seed:
import { WalletManager } from '@boosty/wallet-manager';
const walletManager = new WalletManager({
database: pgPool,
encryptionKey: process.env.MASTER_ENCRYPTION_KEY,
});
// Create wallet group from mnemonic
const group = await walletManager.createWalletGroup({
name: 'Volume Bot Wallets',
mnemonic: 'your 24 word mnemonic phrase...',
count: 1000,
derivationPath: "m/44'/501'/0'/0'",
});
// Get wallet by index
const wallet = await walletManager.getWallet(group.id, 42);
// Sign transaction
const signature = await walletManager.signTransaction(
group.id,
42, // wallet index
transaction
);
Military-grade key protection:
// Key derivation
const derivedKey = await scrypt(
masterPassword,
salt,
{
N: 2 ** 20, // CPU/memory cost
r: 8, // Block size
p: 1, // Parallelization
dkLen: 32, // Key length
}
);
// Encryption
const encrypted = await crypto.subtle.encrypt(
{
name: 'AES-GCM',
iv: randomIV,
tagLength: 128,
},
derivedKey,
privateKeyBytes
);
// Storage format
{
version: 1,
algorithm: 'aes-256-gcm',
kdf: 'scrypt',
kdfParams: { N: 1048576, r: 8, p: 1 },
salt: base64Salt,
iv: base64IV,
ciphertext: base64Ciphertext,
tag: base64Tag,
}
Efficiently distribute SOL to worker wallets:
// Distribute funds to all campaign wallets
await walletManager.distributeFunds({
sourceWallet: treasuryWallet,
targetGroup: campaignGroup.id,
totalAmount: 100, // SOL
distribution: 'proportional', // or 'equal'
// Batching for efficiency
batchSize: 20,
useVersionedTransactions: true,
// Account for rent
minRentExempt: 0.002, // SOL
});
// Collect funds back to treasury
await walletManager.collectFunds({
targetWallet: treasuryWallet,
sourceGroup: campaignGroup.id,
leaveMinimum: 0.001, // Leave rent-exempt amount
});
Boosty supports monetization via the x402 Protocol - an HTTP 402 micropayment standard for pay-per-use APIs.
When enabled, certain tool calls require USDC micropayments before execution. This enables:
# Set your payment receiving address
X402_PAY_TO_ADDRESS=0xYourBaseAddress
# Optional: Choose network (default: base-mainnet)
X402_NETWORK=base-mainnet
# Optional: Custom facilitator
X402_FACILITATOR_URL=https://x402.org/facilitator
// Get all pricing
await client.callTool('get_payment_pricing', {});
// Get specific tool price
await client.callTool('get_tool_price', { tool_name: 'execute_swap' });
// Get supported networks
await client.callTool('get_payment_networks', {});
Simply don't set X402_PAY_TO_ADDRESS - all tools will be free.
📖 Full Documentation: docs/X402_PAYMENTS.md
[ ] All private keys encrypted at rest
[ ] No secrets in version control
[ ] Database connections use SSL
[ ] RPC endpoints use HTTPS
[ ] Rate limiting enabled
[ ] Input validation on all endpoints
[ ] Error messages don't leak information
[ ] Logging excludes sensitive data
[ ] Dependencies scanned for vulnerabilities
[ ] Access controls enforced
version: '3.8'
services:
boosty-mcp:
build: .
environment:
- SOLANA_RPC_URL=${SOLANA_RPC_URL}
- DATABASE_URL=postgresql://boosty:password@postgres:5432/boosty
- REDIS_URL=redis://redis:6379
depends_on:
- postgres
- redis
ports:
- "3000:3000"
postgres:
image: postgres:16
environment:
POSTGRES_USER: boosty
POSTGRES_PASSWORD: password
POSTGRES_DB: boosty
volumes:
- postgres_data:/var/lib/postgresql/data
- ./docker/init-db.sql:/docker-entrypoint-initdb.d/init.sql
redis:
image: redis:7-alpine
command: redis-server --appendonly yes
volumes:
- redis_data:/data
prometheus:
image: prom/prometheus
volumes:
- ./docker/prometheus.yml:/etc/prometheus/prometheus.yml
ports:
- "9090:9090"
grafana:
image: grafana/grafana
environment:
- GF_SECURITY_ADMIN_PASSWORD=admin
ports:
- "3001:3000"
volumes:
- grafana_data:/var/lib/grafana
volumes:
postgres_data:
redis_data:
grafana_data:
apiVersion: apps/v1
kind: Deployment
metadata:
name: boosty-mcp
spec:
replicas: 3
selector:
matchLabels:
app: boosty-mcp
template:
metadata:
labels:
app: boosty-mcp
spec:
containers:
- name: boosty-mcp
image: boosty/mcp-defi:latest
resources:
requests:
memory: "512Mi"
cpu: "500m"
limits:
memory: "2Gi"
cpu: "2000m"
envFrom:
- secretRef:
name: boosty-secrets
livenessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 5
periodSeconds: 5
See docs/API_REFERENCE.md for complete API documentation.
// In Claude Desktop:
// "Swap 1 SOL for USDC"
// Behind the scenes:
const result = await boosty.tools.executeSwap({
inputToken: 'SOL',
outputToken: 'USDC',
amount: 1,
slippageBps: 50,
});
// In Claude Desktop:
// "Start a volume campaign for token ABC with $10k daily volume for 3 days"
// Behind the scenes:
const campaign = await boosty.tools.createVolumeCampaign({
token: 'ABC',
dailyVolume: 10000,
duration: 3 * 24 * 60 * 60,
pattern: 'organic',
});
// In Claude Desktop:
// "Rebalance my portfolio to 50% SOL, 30% USDC, 20% ETH"
// Behind the scenes:
const result = await boosty.tools.rebalancePortfolio({
targetAllocations: {
SOL: 0.5,
USDC: 0.3,
ETH: 0.2,
},
slippageBps: 100,
});
# Check SOL balance for fees
solana balance <wallet-address>
# Verify token account exists
spl-token accounts --owner <wallet-address>
# Use dedicated RPC provider
SOLANA_RPC_URL=https://your-helius-endpoint.com
# Ensure same key is used
echo $MASTER_ENCRYPTION_KEY | wc -c # Should be 64 (32 bytes hex)
# Check if PostgreSQL is running
docker ps | grep postgres
# Start if needed
docker-compose up -d postgres
# Verify connection
psql $DATABASE_URL -c "SELECT 1"
# Check if Redis is running
docker ps | grep redis
# Test connection
redis-cli -u $REDIS_URL ping
# Check if token is valid
curl "https://quote-api.jup.ag/v6/quote?inputMint=So11111111111111111111111111111111111111112&outputMint=YOUR_TOKEN&amount=1000000000"
# Verify the mint address is correct and has liquidity
# Check wallet balance
solana balance <WALLET_ADDRESS> --url mainnet-beta
# Check token balance
spl-token balance <TOKEN_MINT> --owner <WALLET_ADDRESS>
Boosty exposes Prometheus metrics for monitoring:
// Available metrics
boosty_transactions_total{status="success|failed", dex="jupiter|raydium|pumpfun"}
boosty_transaction_duration_seconds{dex="jupiter|raydium|pumpfun"}
boosty_wallet_balance_sol{wallet_group="main|campaign"}
boosty_campaign_volume_usd{campaign_id="..."}
boosty_rpc_requests_total{endpoint="getBalance|sendTransaction"}
boosty_rpc_latency_seconds{endpoint="getBalance|sendTransaction"}
boosty_task_queue_length{queue="trades|funding|collection"}
boosty_active_campaigns_total{}
Import the provided dashboard for visualization:
# Dashboard available at
./docker/grafana/dashboards/boosty-overview.json
Dashboard Panels:
# docker/prometheus/alerts.yml
groups:
- name: boosty-alerts
rules:
- alert: HighTransactionFailureRate
expr: rate(boosty_transactions_total{status="failed"}[5m]) / rate(boosty_transactions_total[5m]) > 0.1
for: 5m
labels:
severity: critical
annotations:
summary: "High transaction failure rate"
- alert: LowWalletBalance
expr: boosty_wallet_balance_sol{wallet_group="treasury"} < 1
for: 1m
labels:
severity: warning
annotations:
summary: "Treasury balance below 1 SOL"
- alert: CampaignStalled
expr: increase(boosty_campaign_volume_usd[1h]) == 0
for: 1h
labels:
severity: warning
annotations:
summary: "Campaign not generating volume"
// GET /health
{
"status": "healthy",
"timestamp": "2024-01-15T10:30:00Z",
"checks": {
"database": { "status": "up", "latency_ms": 5 },
"redis": { "status": "up", "latency_ms": 2 },
"solana_rpc": { "status": "up", "latency_ms": 150 },
"jupiter_api": { "status": "up", "latency_ms": 200 }
},
"version": "2.0.0",
"uptime_seconds": 86400
}
// GET /ready
{
"ready": true,
"campaigns_active": 3,
"queue_depth": 45,
"wallets_funded": 500
}
// Configure webhooks for trade events
const webhookConfig = {
url: 'https://your-server.com/webhook',
events: ['trade.completed', 'trade.failed', 'campaign.started', 'campaign.completed'],
secret: 'your-webhook-secret',
};
// Webhook payload
{
"event": "trade.completed",
"timestamp": "2024-01-15T10:30:00Z",
"data": {
"campaignId": "abc123",
"txSignature": "5K3...",
"inputToken": "SOL",
"outputToken": "USDC",
"inputAmount": 1.5,
"outputAmount": 150.25,
"priceImpact": 0.05,
"walletIndex": 42
}
}
// Start in HTTP mode
boosty-mcp --transport http --port 3000
// Endpoints
POST /api/v1/swap
POST /api/v1/campaign
GET /api/v1/campaign/:id
GET /api/v1/portfolio
GET /api/v1/prices/:symbol
// Connect to real-time updates
const ws = new WebSocket('wss://your-server.com/ws');
ws.onmessage = (event) => {
const data = JSON.parse(event.data);
switch (data.type) {
case 'trade':
console.log('Trade executed:', data.trade);
break;
case 'price':
console.log('Price update:', data.price);
break;
case 'campaign':
console.log('Campaign update:', data.campaign);
break;
}
};
# Run all unit tests
pnpm test
# Run tests for specific package
pnpm --filter @boosty/trading-engine test
# Run with coverage
pnpm test:coverage
# Watch mode for development
pnpm test:watch
# Requires running database and Redis
docker-compose up -d postgres redis
# Run integration tests
pnpm test:integration
# Run against devnet
SOLANA_RPC_URL=https://api.devnet.solana.com pnpm test:integration
# Full end-to-end testing (uses devnet)
pnpm test:e2e
# Smoke tests only
pnpm test:e2e:smoke
Q: Is this legal to use? A: Boosty is a tool for executing trades on decentralized exchanges. Users are responsible for complying with local regulations. Volume generation activities may be restricted in some jurisdictions.
Q: Does this work on mainnet? A: Yes, Boosty executes real transactions on Solana mainnet. Always test on devnet first.
Q: What are the costs? A: Costs include Solana transaction fees (~0.000005 SOL/tx), priority fees (variable), and RPC provider costs if using dedicated endpoints.
Q: How many wallets can I manage? A: Technically unlimited. We've tested with 10,000+ wallets in a single campaign.
Q: Why use MCP instead of a REST API? A: MCP integrates directly with Claude Desktop, enabling natural language interaction. No need to memorize commands or read documentation.
Q: Can I use this without Claude Desktop? A: Yes, the individual packages can be used programmatically via their TypeScript APIs.
Q: Is my private key safe? A: Private keys are encrypted with AES-256-GCM and never leave your infrastructure. Keys are decrypted only when signing transactions, then immediately cleared from memory.
Q: How do you handle failed transactions? A: Automatic retry with exponential backoff, priority fee bumping, and detailed failure logging. Failed transactions are recorded for analysis.
Q: Can I integrate with my existing trading bot? A: Yes, all packages expose TypeScript APIs that can be imported into your codebase.
Q: Do you support other AI assistants? A: Currently optimized for Claude Desktop, but the MCP protocol is an open standard.
Q: Can I run multiple campaigns simultaneously? A: Yes, the orchestrator manages multiple campaigns concurrently with resource isolation.
We welcome contributions! See CONTRIBUTING.md for guidelines.
git checkout -b feature/amazing-feature)pnpm test)git commit -m 'feat: add amazing feature')git push origin feature/amazing-feature)We use Conventional Commits:
feat: add new feature
fix: fix a bug
docs: documentation changes
style: formatting, no code change
refactor: code restructuring
test: adding tests
chore: maintenance tasks
pnpm test)pnpm lint)pnpm typecheck)Built with these amazing open-source projects:
MIT License - see LICENSE for details.
MIT License
Copyright (c) 2024 Boosty
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Boosty supports any SPL token on Solana. Here are commonly traded tokens:
# .env.minimal
SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
MASTER_ENCRYPTION_KEY=your-32-byte-hex-key
# .env.production
SOLANA_RPC_URL=https://mainnet.helius-rpc.com/?api-key=YOUR_KEY
SOLANA_RPC_WS_URL=wss://mainnet.helius-rpc.com/?api-key=YOUR_KEY
JITO_BLOCK_ENGINE_URL=https://mainnet.block-engine.jito.wtf
DATABASE_URL=postgresql://user:[email protected]:5432/boosty?ssl=true
REDIS_URL=redis://user:[email protected]:6379
MASTER_ENCRYPTION_KEY=your-production-key
COINGECKO_API_KEY=your-pro-key
LOG_LEVEL=info
LOG_FORMAT=json
Comprehensive keyword list for ERC-8004 Trustless Agents ecosystem
ERC-8004, ERC8004, EIP-8004, EIP8004, Trustless Agents, trustless agent, trustless AI, trustless AI agents, agent protocol, agent standard, Ethereum agent standard, blockchain agent protocol, on-chain agents, onchain agents, on-chain AI, onchain AI, decentralized agents, decentralized AI agents, autonomous agents, autonomous AI agents, AI agent protocol, AI agent standard, agent discovery, agent trust, agent reputation, agent validation, agent identity, agent registry, identity registry, reputation registry, validation registry, agent NFT, ERC-721 agent, agent tokenId, agentId, agentURI, agentWallet, agent registration, agent registration file, agent-registration.json, agent card, agent metadata, agent endpoints, agent discovery protocol, agent trust protocol, open agent protocol, open agent standard, permissionless agents, permissionless AI, censorship-resistant agents, portable agent identity, portable AI identity, verifiable agents, verifiable AI agents, accountable agents, accountable AI, agent accountability
Ethereum, Ethereum mainnet, ETH, EVM, Ethereum Virtual Machine, smart contracts, Solidity, blockchain, decentralized, permissionless, trustless, on-chain, onchain, L2, Layer 2, Base, Optimism, Polygon, Linea, Arbitrum, Scroll, Monad, Gnosis, Celo, Sepolia, testnet, mainnet, singleton contracts, singleton deployment, ERC-721, NFT, non-fungible token, tokenURI, URIStorage, EIP-712, ERC-1271, wallet signature, EOA, smart contract wallet, gas fees, gas sponsorship, EIP-7702, subgraph, The Graph, indexer, blockchain indexing, IPFS, decentralized storage, content-addressed, immutable data, public registry, public good, credibly neutral, credibly neutral infrastructure, open protocol, open standard, Web3, crypto, cryptocurrency, DeFi, decentralized finance
AI agents, artificial intelligence agents, autonomous AI, AI autonomy, LLM agents, large language model agents, machine learning agents, ML agents, AI assistant, AI chatbot, intelligent agents, software agents, digital agents, virtual agents, AI automation, automated agents, agent-to-agent, A2A, A2A protocol, Google A2A, Agent2Agent, MCP, Model Context Protocol, agent communication, agent interoperability, agent orchestration, agent collaboration, multi-agent, multi-agent systems, agent capabilities, agent skills, agent tools, agent prompts, agent resources, agent completions, AgentCard, agent card, agent endpoint, agent service, AI service, AI API, agent API, AI infrastructure, agent infrastructure, agentic, agentic web, agentic economy, agentic commerce, agent economy, agent marketplace, AI marketplace, agent platform, AI platform
trust, trustless, reputation, reputation system, reputation protocol, reputation registry, feedback, client feedback, user feedback, on-chain feedback, on-chain reputation, verifiable reputation, portable reputation, reputation aggregation, reputation scoring, reputation algorithm, trust signals, trust model, trust verification, trust layer, recursive reputation, reviewer reputation, spam prevention, Sybil attack, Sybil resistance, anti-spam, feedback filtering, trusted reviewers, rating, rating system, quality rating, starred rating, uptime rating, success rate, response time, performance history, track record, audit trail, immutable feedback, permanent feedback, feedback response, appendResponse, giveFeedback, revokeFeedback, feedback tags, feedback value, valueDecimals, feedbackURI, feedbackHash, clientAddress, reviewer address
validation, validation registry, validator, validator contract, cryptographic validation, cryptographic proof, cryptographic attestation, zero-knowledge, ZK, zkML, zero-knowledge machine learning, ZK proofs, trusted execution environment, TEE, TEE attestation, TEE oracle, stake-secured, staking validators, crypto-economic security, inference re-execution, output validation, work verification, third-party validation, independent validation, validation request, validation response, validationRequest, validationResponse, requestHash, responseHash, verifiable computation, verified agents, verified behavior, behavioral validation, agent verification
x402, x402 protocol, x402 payments, programmable payments, micropayments, HTTP payments, pay-per-request, pay-per-task, agent payments, AI payments, agent monetization, AI monetization, agent commerce, AI commerce, agentic commerce, agent economy, AI economy, agent marketplace, service marketplace, agent-to-agent payments, A2A payments, stablecoin payments, USDC, crypto payments, on-chain payments, payment settlement, programmable settlement, proof of payment, proofOfPayment, payment receipt, payment verification, Coinbase, Coinbase x402, agent pricing, API pricing, service pricing, subscription, API keys, revenue, trading yield, cumulative revenues, agent wallet, payment address, toAddress, fromAddress, txHash
agent discovery, service discovery, agent registry, identity registry, agent registration, register agent, mint agent, agent NFT, agent tokenId, agent browsing, agent explorer, agent scanner, 8004scan, 8004scan.io, agentscan, agentscan.info, 8004agents, 8004agents.ai, agent leaderboard, agent ranking, top agents, agent listing, agent directory, agent catalog, agent index, browse agents, search agents, find agents, discover agents, agent visibility, agent discoverability, no-code registration, agent creation, create agent, my agents, agent owner, agent operator, agent transfer, transferable agent, portable agent
endpoint, agent endpoint, service endpoint, API endpoint, MCP endpoint, A2A endpoint, web endpoint, HTTPS endpoint, HTTP endpoint, DID, decentralized identifier, ENS, Ethereum Name Service, ENS name, agent.eth, vitalik.eth, email endpoint, OASF, Open Agent Specification Format, endpoint verification, domain verification, endpoint ownership, .well-known, well-known, agent-registration.json, endpoint domain, endpoint URL, endpoint URI, base64 data URI, on-chain metadata, off-chain metadata, metadata storage, JSON metadata, agent JSON, registration JSON
SDK, Agent0 SDK, Agent0, ChaosChain SDK, ChaosChain, Lucid Agents, Daydreams AI, create-8004-agent, npm, TypeScript SDK, Python SDK, JavaScript, Solidity, smart contract, ABI, contract ABI, deployed contracts, contract addresses, Hardhat, development tools, developer tools, dev tools, API, REST API, GraphQL, subgraph, The Graph, indexer, blockchain explorer, Etherscan, contract verification, open source, MIT license, CC0, public domain, GitHub, repository, code repository, documentation, docs, best practices, reference implementation
ecosystem, community, builder, builders, developer, developers, contributor, contributors, partner, partners, collaborator, collaborators, co-author, co-authors, MetaMask, Ethereum Foundation, Google, Coinbase, Consensys, AltLayer, Virtuals Protocol, Olas, EigenLayer, Phala, ElizaOS, Flashbots, Polygon, Base, Optimism, Arbitrum, Scroll, Linea, Monad, Gnosis, Celo, Near Protocol, Filecoin, Worldcoin, ThirdWeb, ENS, Collab.land, DappRadar, Giza Tech, Theoriq, OpenServ, Questflow, Semantic, Semiotic, Cambrian, Nevermined, Oasis, Towns Protocol, Warden Protocol, Terminal3, Pinata Cloud, Silence Labs, Rena Labs, Index Network, Trusta Network, Turf Network
Marco De Rossi, MetaMask AI Lead, Davide Crapis, Ethereum Foundation AI, Head of AI, Jordan Ellis, Google engineer, Erik Reppel, Coinbase engineering, Head of Engineering, Sumeet Chougule, ChaosChain founder, YQ, AltLayer co-founder, Wee Kee, Virtuals contributor, Cyfrin audit, Nethermind audit, Ethereum Foundation Security Team, security audit, audited contracts
trading bot, DeFi agent, yield optimizer, data oracle, price feed, analytics agent, research agent, coding agent, development agent, automation agent, task agent, workflow agent, portfolio management, asset management, supply chain, service agent, API service, chatbot, AI assistant, virtual assistant, personal agent, enterprise agent, B2B agent, agent-as-a-service, AaaS, SaaS agent, AI SaaS, delegated agent, proxy agent, helper agent, worker agent, coordinator agent, orchestrator agent, validator agent, auditor agent, insurance agent, scoring agent, ranking agent
ERC-8004 specification, EIP specification, Ethereum Improvement Proposal, Ethereum Request for Comment, RFC 2119, RFC 8174, MUST, SHOULD, MAY, OPTIONAL, REQUIRED, interface, contract interface, function signature, event, emit event, indexed event, storage, contract storage, view function, external function, public function, uint256, int128, uint8, uint64, bytes32, string, address, array, struct, MetadataEntry, mapping, modifier, require, revert, transfer, approve, operator, owner, tokenId, URI, hash, keccak256, KECCAK-256, signature, deadline
8004 Launch Day, Agentic Brunch, Builder Nights Denver, Trustless Agent Day, Devconnect, ETHDenver, community call, meetup, hackathon, workshop, conference, summit, builder program, grants, bounties, ecosystem fund
announcement, launch, mainnet launch, testnet launch, protocol update, upgrade, security review, audit, milestone, breaking news, ecosystem news, agent news, AI news, blockchain news, Web3 news, crypto news, DeFi news, newsletter, blog, article, press release, media coverage
agent framework, agent platform, AI platform, centralized agents, closed agents, proprietary agents, gatekeeper, intermediary, platform lock-in, vendor lock-in, data silos, walled garden, open alternative, decentralized alternative, permissionless alternative, trustless alternative
cross-chain, multi-chain, chain agnostic, bridge, interoperability, governance, community governance, decentralized governance, DAO, protocol upgrade, upgradeable contracts, UUPS, proxy contract, ERC1967Proxy, protocol evolution, standard finalization, EIP finalization, mainnet feedback, testnet feedback, security improvements, gas optimization, feature request, enhancement, proposal
how to register AI agent on blockchain, how to create ERC-8004 agent, how to build trustless AI agent, how to verify agent reputation, how to give feedback to AI agent, how to monetize AI agent, how to accept crypto payments AI agent, how to discover AI agents, how to trust AI agents, how to validate AI agent output, decentralized AI agent marketplace, on-chain AI agent registry, blockchain-based AI reputation, verifiable AI agent identity, portable AI agent reputation, permissionless AI agent registration, trustless AI agent discovery, autonomous AI agent payments, agent-to-agent micropayments, AI agent service discovery, AI agent trust protocol, open source AI agent standard, Ethereum AI agent protocol, EVM AI agent standard, blockchain AI agent framework, decentralized AI agent infrastructure, Web3 AI agent ecosystem, crypto AI agent platform, DeFi AI agent integration, NFT-based agent identity, ERC-721 agent registration, on-chain agent metadata, off-chain agent data, IPFS agent storage, subgraph agent indexing, agent explorer blockchain, agent scanner Ethereum, agent leaderboard ranking, agent reputation scoring, agent feedback system, agent validation proof, zkML agent verification, TEE agent attestation, stake-secured agent validation, x402 agent payments, MCP agent endpoint, A2A agent protocol, ENS agent name, DID agent identity, agent wallet address, agent owner operator, transferable agent NFT, portable agent identity, censorship-resistant agent registry, credibly neutral agent infrastructure, public good agent data, open agent economy, agentic web infrastructure, trustless agentic commerce, autonomous agent economy, AI agent economic actors, accountable AI agents, verifiable AI behavior, auditable AI agents, transparent AI agents, decentralized AI governance, community-driven AI standards, open protocol AI agents, permissionless AI innovation
8004, 8004.org, Trustless Agents, trustlessagents, trustless-agents, 8004scan, 8004scan.io, agentscan, agentscan.info, 8004agents, 8004agents.ai, Agent0, agent0, sdk.ag0.xyz, ChaosChain, chaoschain, docs.chaoscha.in, Lucid Agents, lucid-agents, daydreams.systems, create-8004-agent, erc-8004-contracts, best-practices, agent0lab, subgraph
#ERC8004, #TrustlessAgents, #AIAgents, #DecentralizedAI, #OnChainAI, #AgenticWeb, #AgentEconomy, #Web3AI, #BlockchainAI, #EthereumAI, #CryptoAI, #AutonomousAgents, #AIAutonomy, #AgentDiscovery, #AgentTrust, #AgentReputation, #x402, #MCP, #A2A, #AgentProtocol, #OpenAgents, #PermissionlessAI, #VerifiableAI, #AccountableAI, #AIInfrastructure, #AgentInfrastructure, #BuildWithAgents, #AgentBuilders, #AgentDevelopers, #AgentEcosystem
10000+ agents, 10300+ agents, 10000+ testnet registrations, 20000+ feedback, 5 months development, 80+ teams, 100+ partners, January 28 2026, January 29 2026, mainnet live, production ready, audited contracts, singleton deployment, per-chain singleton, ERC-721 token, NFT minting, gas fees, $5-20 mainnet gas
ERC 8004, EIP 8004, trustless agent protocol, trustless agent standard, trustless agent framework, trustless agent system, trustless agent network, trustless agent infrastructure, trustless agent architecture, trustless agent specification, trustless agent implementation, trustless agent deployment, trustless agent integration, trustless agent ecosystem, trustless agent platform, trustless agent marketplace, trustless agent registry, trustless agent identity, trustless agent reputation, trustless agent validation, trustless agent discovery, trustless agent verification, trustless agent authentication, trustless agent authorization, trustless agent registration, trustless agent management, trustless agent operations, trustless agent services, trustless agent solutions, trustless agent technology, trustless agent innovation, trustless agent development, trustless agent research, trustless agent security, trustless agent privacy, trustless agent transparency, trustless agent accountability, trustless agent governance, trustless agent compliance, trustless agent standards, trustless agent protocols, trustless agent interfaces, trustless agent APIs, trustless agent SDKs, trustless agent tools, trustless agent utilities, trustless agent libraries, trustless agent modules, trustless agent components, trustless agent extensions
Ethereum blockchain, Ethereum network, Ethereum protocol, Ethereum ecosystem, Ethereum infrastructure, Ethereum development, Ethereum smart contract, Ethereum dApp, Ethereum application, Ethereum transaction, Ethereum gas, Ethereum wallet, Ethereum address, Ethereum account, Ethereum signature, Ethereum verification, Ethereum consensus, Ethereum finality, Ethereum block, Ethereum chain, Ethereum node, Ethereum client, Ethereum RPC, Ethereum JSON-RPC, Ethereum Web3, Ethereum ethers.js, Ethereum viem, Ethereum wagmi, Ethereum hardhat, Ethereum foundry, Ethereum truffle, Ethereum remix, Ethereum deployment, Ethereum verification, Ethereum explorer, Ethereum scanner, Base blockchain, Base network, Base L2, Base layer 2, Base mainnet, Base testnet, Base Sepolia, Optimism blockchain, Optimism network, Optimism L2, Optimism mainnet, Optimism Sepolia, Polygon blockchain, Polygon network, Polygon PoS, Polygon zkEVM, Polygon mainnet, Polygon Mumbai, Arbitrum blockchain, Arbitrum One, Arbitrum Nova, Arbitrum Sepolia, Arbitrum Stylus, Linea blockchain, Linea network, Linea mainnet, Linea testnet, Scroll blockchain, Scroll network, Scroll mainnet, Scroll Sepolia, Monad blockchain, Monad network, Monad testnet, Gnosis Chain, Gnosis Safe, Celo blockchain, Celo network, Avalanche, Fantom, BNB Chain, BSC, Binance Smart Chain, zkSync, StarkNet, Mantle, Blast, Mode, Zora, opBNB, Manta, Taiko
artificial intelligence agent, machine learning agent, deep learning agent, neural network agent, transformer agent, GPT agent, Claude agent, Gemini agent, Llama agent, Mistral agent, AI model agent, foundation model agent, language model agent, multimodal agent, vision agent, audio agent, speech agent, text agent, code agent, coding assistant, programming agent, developer agent, software agent, application agent, web agent, mobile agent, desktop agent, cloud agent, edge agent, IoT agent, robotic agent, automation agent, workflow agent, process agent, task agent, job agent, worker agent, assistant agent, helper agent, support agent, service agent, utility agent, tool agent, function agent, capability agent, skill agent, knowledge agent, reasoning agent, planning agent, decision agent, execution agent, monitoring agent, logging agent, analytics agent, reporting agent, notification agent, alert agent, scheduling agent, calendar agent, email agent, messaging agent, chat agent, conversation agent, dialogue agent, interactive agent, responsive agent, reactive agent, proactive agent, predictive agent, adaptive agent, learning agent, evolving agent, self-improving agent, autonomous agent system, multi-agent architecture, agent swarm, agent collective, agent network, agent cluster, agent pool, agent fleet, agent army, agent workforce, agent team, agent group, agent ensemble, agent coalition, agent federation, agent consortium, agent alliance, agent partnership, agent collaboration, agent cooperation, agent coordination, agent orchestration, agent choreography, agent composition, agent aggregation, agent integration, agent interoperability, agent compatibility, agent standardization, agent normalization, agent harmonization
trust protocol, trust system, trust network, trust infrastructure, trust layer, trust framework, trust model, trust algorithm, trust computation, trust calculation, trust score, trust rating, trust level, trust tier, trust grade, trust rank, trust index, trust metric, trust indicator, trust signal, trust factor, trust weight, trust coefficient, trust threshold, trust minimum, trust maximum, trust average, trust median, trust distribution, trust aggregation, trust normalization, trust scaling, trust decay, trust growth, trust accumulation, trust history, trust timeline, trust evolution, trust trajectory, trust prediction, trust forecast, trust estimation, trust inference, trust derivation, trust propagation, trust transfer, trust delegation, trust inheritance, trust chain, trust path, trust graph, trust network analysis, trust community detection, trust clustering, trust similarity, trust distance, trust proximity, trust relationship, trust connection, trust link, trust edge, trust node, trust vertex, reputation protocol, reputation system, reputation network, reputation infrastructure, reputation layer, reputation framework, reputation model, reputation algorithm, reputation computation, reputation calculation, reputation score, reputation rating, reputation level, reputation tier, reputation grade, reputation rank, reputation index, reputation metric, reputation indicator, reputation signal, reputation factor, reputation weight, reputation coefficient, reputation threshold, reputation minimum, reputation maximum, reputation average, reputation median, reputation distribution, reputation aggregation, reputation normalization, reputation scaling, reputation decay, reputation growth, reputation accumulation, reputation history, reputation timeline, reputation evolution, reputation trajectory, reputation prediction, reputation forecast, reputation estimation, reputation inference, reputation derivation, reputation propagation, reputation transfer, reputation delegation, reputation inheritance, reputation chain, reputation path, reputation graph, reputation network analysis, reputation community detection, reputation clustering, reputation similarity, reputation distance, reputation proximity, reputation relationship, reputation connection, reputation link, feedback protocol, feedback system, feedback network, feedback infrastructure, feedback layer, feedback framework, feedback model, feedback algorithm, feedback computation, feedback calculation, feedback score, feedback rating, feedback level, feedback tier, feedback grade, feedback rank, feedback index, feedback metric, feedback indicator, feedback signal, feedback factor, feedback weight, feedback coefficient, feedback threshold, feedback minimum, feedback maximum, feedback average, feedback median, feedback distribution, feedback aggregation, feedback normalization, feedback scaling, review system, rating system, scoring system, ranking system, evaluation system, assessment system, appraisal system, judgment system, quality assurance, quality control, quality metrics, quality standards, quality benchmarks, performance metrics, performance indicators, performance benchmarks, performance standards, performance evaluation, performance assessment, performance monitoring, performance tracking, performance analytics, performance reporting, performance dashboard
validation protocol, validation system, validation network, validation infrastructure, validation layer, validation framework, validation model, validation algorithm, validation computation, validation process, validation procedure, validation workflow, validation pipeline, validation chain, validation sequence, validation step, validation stage, validation phase, validation checkpoint, validation gate, valida
TypeScript MCP servers for DeFi: price data, wallet analytics, yield discovery and Solana wallet and trading tools.
เครื่องมือ
ยังไม่มีรายการเครื่องมือ เซิร์ฟเวอร์แบบรีโมตจะได้รายการหลังการตรวจสอบสถานะครั้งแรก
FAQ
คัดลอกคอนฟิก stdio สำหรับ Cursor, Claude Desktop, Claude Code หรือ VS Code ได้ในหน้านี้ คอนฟิกนี้ใช้การติดตั้งของผู้เผยแพร่ ไม่ใช่พร็อกซีของ PlugMCP
ระเบียนนี้ไม่ได้ระบุตัวแปรสภาพแวดล้อมที่จำเป็น
Boosty ทำงานแบบโลคัลผ่าน stdio
ตรวจสอบล่าสุดเมื่อ 2026-11-12 TypeScript MCP servers for DeFi: price data, wallet analytics, yield discovery and Solana wallet and trading tools.