MoltCope

// on-chain cope intelligence for solana — v0.1.0

MoltCope is a behavioral intelligence protocol that analyzes Solana wallet activity across major DEXes to produce a Cope Score™ — a composite metric measuring emotional and irrational trading patterns.

The protocol reads public on-chain transaction data only. No API keys, no wallet permissions, no private data. Just raw behavioral truth extracted from the blockchain.

Philosophy

Your wallet doesn't lie. Every panic sell, every FOMO entry, every revenge trade is permanently recorded on-chain. MoltCope simply reads what's already there and translates it into actionable behavioral intelligence.

Quickstart

Get a wallet's Cope Score in under 30 seconds:

// Import MoltCope SDK
import { MoltCope } from '@moltcope/sdk';

// Initialize
const mc = new MoltCope({
  network: 'mainnet-beta',
  apiKey: 'your_api_key'  // optional, for premium features
});

// Scan any wallet
const result = await mc.scan('7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU');

console.log(result.copeScore);    // 73
console.log(result.level.label);  // "HEAVY COPE"
console.log(result.behaviors);    // [{type: 'PANIC_SELL', count: 12, ...}]
    

Using the Dashboard

For non-developers, the web dashboard provides the same functionality with a visual interface. Paste any Solana wallet address and get instant behavioral analysis.

Architecture

MoltCope operates as a read-only analytics layer on top of Solana's transaction history. The system consists of three core components:

┌─────────────────────────────────────────────────────────┐
│                    MOLTCOPE ENGINE                        │
├──────────┬──────────────┬──────────────┬─────────────────┤
│ TX       │  BEHAVIORAL  │   SCORING    │    OUTPUT       │
│ PARSER   │  DETECTOR    │   ENGINE     │    LAYER        │
│          │              │              │                 │
│ Jupiter  │ 12+ pattern  │ Weighted     │ Dashboard       │
│ Raydium  │ classifiers  │ composite    │ API             │
│ Orca     │              │ scoring      │ Export          │
│ Meteora  │ Time-series  │              │ Webhooks        │
│ Pump.fun │ analysis     │ ML model     │ Alerts          │
└──────────┴──────────────┴──────────────┴─────────────────┘
      ▲                                        │
      │         Solana RPC / DAS API           │
      └────────────────────────────────────────┘
    

Cope Score™

The Cope Score is a 0-100 composite metric that quantifies emotional/irrational trading behavior. Higher scores indicate more cope-driven trading patterns.

Range	Classification	Meaning
`90-100`	MAXIMUM COPE	Extreme emotional trading. Revenge trades, denial bagholding, "still early" behavior.
`70-89`	HEAVY COPE	Frequent FOMO entries, panic sells, emotional position sizing.
`40-69`	MODERATE COPE	Occasional emotional decisions. Mostly rational but slips under pressure.
`0-39`	BASED	Disciplined, systematic trading. Clean entries/exits. No emotional patterns.

Behavioral Patterns

MoltCope detects 12 distinct trading behavior patterns. Each pattern has a weight that contributes positively or negatively to the overall Cope Score.

Behavior	Weight	Detection Method
Panic Sell	+15	Selling >50% position within 1hr of -20% price dump
FOMO Entry	+12	Buying after >100% pump within 24hrs window
Revenge Trade	+18	Immediate re-entry (<5min) after stop-loss triggered
Baghold	+10	Holding position at >80% loss for >7 days
Cope Holder	+16	Averaging down on losing positions 3+ times
Top Buyer	+13	Consistently buying at local/ATH price levels
Ape In	+14	Large position on unverified tokens, high slippage
Paper Hands	+8	Exiting profitable positions at <5% gain
Rug Survivor	+5	Multiple rug pull/honeypot exposures
Diamond Hands	-8	Holding through >30% drawdown and recovering
Sniper	-10	Consistent early entries with tight risk management
Bot Pattern	-5	Automated/systematic trading behavior detected

Scoring Model

The scoring formula starts with a baseline of 50 and adjusts based on detected behaviors, weighted by their severity:

cope_score = 50 + Σ(behavior_weight × severity_ratio)

where:
  behavior_weight = predefined weight per behavior type
  severity_ratio  = detected_count / expected_baseline (clamped 0-1)
  
final score is clamped to [0, 100]
    

Note

Scoring weights are calibrated against a dataset of 50,000+ Solana wallets. The model is updated monthly as new behavioral patterns emerge in the ecosystem.

DEX Sources

MoltCope parses transaction data from the following Solana DEXes and protocols:

Protocol	Program ID	Coverage
Jupiter	`JUP6LkbZbjS1jKKw...`	All swap routes, limit orders, DCA
Raydium	`675kPX9MHTjS2zt1q...`	AMM swaps, concentrated liquidity
Orca	`whirLbMiicVdio4qv...`	Whirlpool swaps, positions
Meteora	`LBUZKhRxPF3XUpBCjp...`	DLMM swaps, pools
Pump.fun	`6EF8rrecthR5Dkzon8...`	Token launches, bonding curve trades

API: scan()

POST https://api.moltcope.sh/v1/scan

Headers:
  Authorization: Bearer <api_key>
  Content-Type: application/json

Body:
{
  "wallet": "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU",
  "timeframe": "30d",       // 7d, 30d, 90d, all
  "dex_filter": ["all"],    // or specific DEXes
  "include_txs": true       // include raw tx data
}

Response:
{
  "wallet": "7xKXtg...",
  "cope_score": 73,
  "level": "HEAVY_COPE",
  "behaviors": [...],
  "profile": {...},
  "transactions": [...]
}
    

API: export()

GET https://api.moltcope.sh/v1/export/{wallet}

Query params:
  format = json | csv | pdf
  timeframe = 7d | 30d | 90d | all
    

Webhooks

Subscribe to real-time cope events for tracked wallets. Receive alerts when a wallet's behavior pattern changes or specific cope thresholds are crossed.

// Register webhook
await mc.webhook({
  wallet: '7xKXtg...',
  events: ['panic_sell', 'score_change'],
  url: 'https://your-server.com/moltcope-hook',
  threshold: 70  // only alert above this score
});
    

Custom Scoring Models

Premium users can define custom behavioral models with adjusted weights and additional pattern detectors:

const customModel = mc.createModel({
  name: 'pump-fun-degen',
  weights: {
    PANIC_SELL: 20,       // increase panic weight
    FOMO_ENTRY: 15,
    RUG_SURVIVOR: 25,    // heavy penalty for rug exposure
    SNIPER: -15,          // bigger reward for discipline
  },
  filters: {
    dex: ['Pump.fun'],    // only analyze pump.fun txs
    minTxCount: 10,
  }
});
    

$MCOPE Token

Disclaimer

$MCOPE is a utility token. Not financial advice. Do your own research. The irony of coping about a cope-scoring token is not lost on us.

The $MCOPE token powers the MoltCope protocol with the following utilities:

Staking: Stake $MCOPE for premium API access and higher rate limits
Governance: Vote on behavioral model updates and new pattern detectors
Revenue Share: API usage fees distributed to stakers
Custom Models: Create and publish custom scoring models (requires staking)

Roadmap

Phase	Target	Features
Phase 1	Q1 2026	Dashboard launch, basic wallet scoring, 5 DEX sources
Phase 2	Q2 2026	Public API, webhook alerts, export functionality, $MCOPE launch
Phase 3	Q3 2026	ML-powered scoring, custom models, Telegram bot, multi-chain expansion
Phase 4	Q4 2026	On-chain reputation system, DeFi integrations, institutional tier