Engine live Buy $SQUDAI
SOLANA · PUMP.FUN

One token
to rule them all.

SQUDAI is an autonomous AI trading engine that discovers, analyses, buys and sells Solana tokens — then shares the winnings with its holders.

We empower every crypto trader in the world to sleep well at night.

Buy on Pump.fun Enter the vault
Our mission

While you sleep,
the engine works.

SQUDAI runs 24/7 so you don’t have to stay up staring at the charts at 4 AM. No panic-selling at the bottom. No missed entries. Hold the token — the engine does the rest.

01

Autonomous

Discovers, scores and trades Solana launches with zero human intervention.

02

Selective

Only launches scoring 8+/10 across website, on-chain activity and trust signals get through.

03

Shared

Every profit flows back to $SQUDAI holders — token airdrops today, more to come.

The engine · live

Every signal. Every catch.

A 24/7 record of every token the engine analysed — score, entry, peak, outcome. Pulled live from the production database.

live feed latest engine decisions · auto-streaming
TOKENS SCANNED — last 30 days
BUY SIGNALS — issued by AI
SUCCESS RATE — ≥ +5% from entry to ATH
AVG GAIN — rolling signal avg
TOP CATCH — 30-day record
Leaderboard · top 20 catches · last 30 days tap a row for full trade detail
— loading —
The formula

Three forces. One gem.

A serious crypto project needs utility, a catalyst, and an incentive. Where they align, a gem is born.

01 · UTILITY Live now

Holder airdrops

Each time the Buy Engine deploys capital, 50% is airdropped directly to 20 random holders with more than 1,000,000 $SQUDAI. Hold the token, wake up to new tokens in your wallet.

  • 20winners / trade
  • >1Mto qualify
  • Autoon-chain
02 · CATALYST Coming soon

Buy & Burn

A portion of every profitable trade flows into buying $SQUDAI on the open market and permanently burning it. Supply shrinks as the engine earns — deflation that compounds with every checkpoint.

  • Marketopen-market buys
  • Burnsupply removed
  • Phase 2activation ahead
03 · INCENTIVE Sealed

[ Classified ]

The third force stays sealed for now. Built for the most committed holders. When the engine has proven itself, the vault opens — and those inside win big.

encrypted · phase_03
Our tech

The engine, in code.

Five stages, fully autonomous. Every line below runs in production on Azure Functions, Solana RPC, and Cosmos DB — 24/7.

discovery / helius_client.py python
STAGE 01 · DISCOVERY

Stream new launches in real time.

Polls DexScreener for paid profiles (a $300 commitment that filters most scams), enriches with Helius DAS data on-chain.

async def discover_paid_launches(session, seen):
    """Stream new Solana tokens with paid DexScreener profiles."""
    profiles = await dex_paid_profiles(session, chain="solana")
    for p in profiles:
        if p["mint"] in seen: continue
        token = await helius_get_asset(session, p["mint"])
        if token.get("supply") and token.get("decimals"):
            yield {**p, **token}
triage / first_pass.py python
STAGE 02 · TRIAGE

Kill memes before they cost compute.

RDAP-checked domain age, real Twitter accounts (not posts), excluded-domain blocklist. Cheap pre-filter before the expensive AI call.

async def first_pass_triage(session, website, twitter):
    if not (website and twitter):
        return False, {"reason": "missing socials"}
    if not is_twitter_account_url(twitter):
        return False, {"reason": "twitter not an account"}
    domain = extract_domain(website)
    if not domain or is_excluded_domain(domain):
        return False, {"reason": "invalid domain"}
    age = await rdap_domain_age_days(session, domain)
    if age is None or not MIN_AGE <= age <= MAX_AGE:
        return False, {"reason": "domain age out of range"}
    return True, {"domain": domain, "age_days": age}
decision / mindshare.py python
STAGE 03 · DECISION

Score the noise into a number.

Mindshare is one of 20+ signals fed to Claude. Five components, each 0–2 points, normalised to a 1–10 mindshare score before the final BUY/PASS call.

def mindshare_score(tweets, user) -> dict:
    """Five components × 2 pts each → 1-10 mindshare."""
    followers = user.get("followers", 0)
    engagement = sum(t["likes"] + t["rts"] + t["replies"] for t in tweets)
    rate = engagement / max(followers, 1)
    score = 0
    score += 2 if followers >= TIER_HI else 1.5 if followers >= TIER_MID else 0
    score += 2 if rate >= ENG_HI else 1 if rate >= ENG_MID else 0
    # + reach, consistency, verified — each 0-2
    return {"score": min(round(score), 10), "rate": rate}
entry / jupiter_swap.py python
STAGE 04 · ENTRY

Round-trip simulate before sending.

The engine quotes both directions on Jupiter and rejects honeypots if the round-trip leaks more than the configured ceiling — zero lamports spent on traps.

async def execute_buy(client, mint, sol_amount):
    """Round-trip simulate before sending — kills honeypots."""
    quote_in  = await jupiter_quote(SOL, mint, sol_amount)
    quote_out = await jupiter_quote(mint, SOL, quote_in["outAmount"])
    leak = 1 - (quote_out["outAmount"] / quote_in["inAmount"])
    if leak > MAX_ROUNDTRIP_LOSS:
        return {"status": "honeypot_detected", "leak": leak}
    swap = await jupiter_swap(quote_in, payer=KEYPAIR, priority="auto")
    return await client.send_transaction(swap)
distribute / lottery.js javascript
STAGE 05 · DISTRIBUTE

Half of every buy goes to holders.

Each AI buy splits in two: half is airdropped directly to 20 random $SQUDAI holders via a weighted ticket lottery — bigger bags get more tickets, but each wallet can only win once per draw.

function selectLotteryWinners(holders, perTicket, winnerCount) {
  // Eligible: ≥ MIN_TOKENS $SQUDAI. Tickets = balance ÷ perTicket.
  const pool = [];
  holders
    .filter(h => h.token_balance >= MIN_TOKENS)
    .forEach(h => {
      const tickets = Math.floor(h.token_balance / perTicket);
      for (let i = 0; i < tickets; i++)
        pool.push({ wallet: h.wallet_address });
    });

  const winners = [], taken = new Set();
  while (winners.length < winnerCount && pool.length) {
    const drawn = pool.splice(Math.floor(Math.random() * pool.length), 1)[0];
    if (taken.has(drawn.wallet)) continue;
    winners.push(drawn); taken.add(drawn.wallet);
  }
  return winners; // 20 unique wallets, weighted by holdings
}
revmake / lease.js javascript
STAGE 06 · PROFIT

Trailing stops with optimistic concurrency.

Every position is monitored on a 10-second cadence with a Cosmos DB lease (etag-guarded) so two function instances never double-trade the same token.

async function acquireLease(token) {
  const fresh = await container.item(token.id, token.mint).read();
  if (fresh.revmake_stage === 'in_process'
      && Date.now() - new Date(fresh.lease_ts) < LEASE_TIMEOUT) return null;
  const entry = fresh.buy_decision_detection_mc;
  const next = {
    ...fresh,
    revmake_stage:     'in_process',
    revmake_state:     fresh.revmake_state ?? 'monitoring',
    revmake_ath_mc:    fresh.revmake_ath_mc ?? entry,
    revmake_stop_loss: fresh.revmake_stop_loss
      ?? Math.max(fresh.ai_stop_loss, entry * TRAIL_FLOOR),
    lease_ts: new Date().toISOString(),
  };
  return container.item(token.id, token.mint)
    .replace(next, { accessCondition: { type: 'IfMatch', condition: fresh._etag } });
}

live in production · solana rpc · helius · jupiter · claude

Where every lamport goes

The flow of value.

Three stages. Each AI buy decision splits revenue into rewards, fuel, and supply-shrinking pressure.

STAGE 01 Revenue split on every buy
SOURCE
Pump.fun creator fee

routes into the SQUDAI ecosystem

50%
Dev & Marketing

infrastructure · team · reach

terminal
50%
Buy Engine fuel

funds holder drops + AI positions

continues →
STAGE 02 Per-trade split from Buy Engine fuel
50%
Buy Engine fuel

capital after Stage 01

50%
Holder airdrops

20 random holders · >1M $SQUDAI

Phase 1 · live
50%
Smart Sell Engine

AI exits positions into profit

continues →
STAGE 03 Profit split from smart exits
50%
Smart Sell Engine

realised trading profit

50%
Buy & Burn $SQUDAI

open-market buy → permanent burn

Phase 2 · soon
50%
[ Classified ]

phase_03 · encrypted

sealed

Hold the token.
Sleep well at night.

Live on Pump.fun. Copy the contract address below or jump straight to a trading link.

CA: GurGmtPpqf3ghLjPBsbYJHdWZ6k7bDaB2sha9Ycspump
Pump.fun ↗ Telegram ↗ @squadaionsol ↗ DexScreener ↗
SQUDAI lockup
Important — please read.

$SQUDAI is a community-driven experiment deployed on Pump.fun. Distributions described on this page (token airdrops, buy & burn, and any future programs) are community benefits provided on a best-effort basis and are not guaranteed. Nothing on this site is financial advice. Cryptocurrency trading is extremely risky — you may lose 100% of what you put in. Always do your own research (DYOR), only commit what you can afford to lose, and never act on a single source. Past performance of engine signals does not predict future results.