A whale wallet intelligence system for Solana that monitors high-net-worth wallet activity to identify coordinated memecoin investment opportunities. Detects coordinated buying patterns and generates trading signals.
This skill has safety concerns that you should review before use. Some patterns were detected that may pose a risk.Safety score: 60/100.
KillerSkills scans all public content for safety. Use caution before installing or executing flagged content.
A comprehensive system for monitoring Solana whale wallets to identify coordinated memecoin investment opportunities through pattern detection and signal generation.
SolTrader monitors a curated list of high-net-worth wallets (whales, KOLs, insiders) on Solana to detect coordinated buying/selling patterns. When multiple wallets purchase the same memecoin within a configurable timeframe, the system generates trading signals. Paper trades are executed for analysis, and LLMs periodically evaluate performance to optimize trading rules.
1. **wallet-watcher**: Subscribes to wallet transactions via RPC services, maintains in-memory list of recent purchases, generates BUY/SELL signals when coordination detected
2. **wallet-analyzer**: Scans for wallet-to-wallet transactions to identify related wallets
3. **paper-trader**: Executes paper trades based on signals, records all trades in database
4. **signal-analyzer**: Analyzes batches of paper trades using LLMs to identify optimal strategies
5. **signal-trader**: Executes real trades based on rules derived from analysis (with trailing stop-loss/take-profit)
All services run in a single process managed by a ServiceManager. Each service follows this interface:
```typescript
interface Service {
name: string;
start(): Promise<void>;
stop(): Promise<void>;
getStatus(): ServiceStatus;
}
```
**Key Rules:**
When creating any new service, use this template:
```typescript
export class MyService implements Service {
name = 'MyService';
private running = false;
private unsubscribers: (() => void)[] = [];
constructor(private messageBus: MessageBus) {
console.log('[MyService] Initialized');
}
async start(): Promise<void> {
console.log('[MyService] Starting...');
// Subscribe to events
this.unsubscribers.push(
this.messageBus.subscribe('event.name', this.handleEvent.bind(this))
);
this.running = true;
}
async stop(): Promise<void> {
console.log('[MyService] Stopping...');
this.unsubscribers.forEach(unsub => unsub());
this.unsubscribers = [];
this.running = false;
}
getStatus(): ServiceStatus {
return { running: this.running };
}
private handleEvent(data: any): void {
// Process event and publish results
this.messageBus.publish('result.event', { result });
}
}
```
```typescript
// Publishing events
messageBus.publish('wallet.transaction.detected', {
wallet: '...',
token: '...',
amount: 1000
});
// Subscribing to events
const unsubscribe = messageBus.subscribe('wallet.transaction.detected', (data) => {
// Handle event
});
// Event naming convention: domain.action.detail
// Examples: wallet.buy.detected, signal.generated, trade.executed
```
**HTMX for User Actions:**
```html
<button hx-post="/api/start-watching"
hx-trigger="click"
hx-swap="none">
Start Watching
</button>
```
**Vanilla JavaScript + SSE for Real-time Updates (NOT HTMX SSE extension):**
```html
<script>
const evtSource = new EventSource('/api/sse');
evtSource.addEventListener('signal', (e) => {
const data = JSON.parse(e.data);
document.getElementById('signals').innerHTML += renderSignal(data);
});
</script>
```
Always use ReadableStream (NOT Hono's streamSSE helper):
```typescript
app.get('/api/sse', (c) => {
const encoder = new TextEncoder();
const stream = new ReadableStream({
start(controller) {
const unsub = messageBus.subscribe('signal.generated', (data) => {
const msg = `event: signal\ndata: ${JSON.stringify(data)}\n\n`;
controller.enqueue(encoder.encode(msg));
});
// Cleanup on close
c.req.raw.signal.addEventListener('abort', () => unsub());
}
});
return new Response(stream, {
headers: {
'Content-Type': 'text/event-stream',
'Cache-Control': 'no-cache',
'Connection': 'keep-alive'
}
});
});
```
When processing wallet transactions:
1. Add purchase to in-memory cache with timestamp
2. Remove purchases older than configured timeframe
3. Count wallets holding same token
4. Generate signal for each threshold (2, 3, 4, 5, 5+ wallets)
5. Publish signal via message bus
6. Store signal in database
```bash
bun run dev
bun run start
bun test # All tests
bun test path/to/test.ts # Single test
npm run deploy
```
Required:
Optional:
1. **Clean up after yourself**: Delete ALL related code when removing functionality
2. **Understand before changing**: Know how existing systems work first
3. **Work with frameworks**: Don't fight framework behavior with hacks
4. **HTMX-specific**: This is NOT a SPA - components re-initialize on swap (this is normal)
5. **Remove unused code**: Search for and remove orphaned code after changes
6. **Test mentally first**: Think through lifecycle and edge cases
7. **Be thorough**: No sloppy or half-finished implementations
Use these MCP servers when needed:
```bash
curl -N http://localhost:3000/api/sse
curl http://localhost:3000/health
bun run --watch server.ts
```
When 3 wallets buy the same token within 5 minutes:
1. Paper trades accumulate in database
2. Scheduled analysis runs (multiple times daily based on signal volume)
3. LLM analyzes: optimal wallet count threshold, time-of-day patterns, purchase amount correlation, specific wallet influence
4. System updates trading rules based on LLM recommendations
5. Signal trader uses rules to execute real trades (when enabled)
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/soltrader-whale-wallet-intelligence-system/raw