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.
Engine profits stream into three community vaults. Watch them fill — when a vault hits its goal, everyone eligible gets paid.
refreshes hourly
Type your $SQUDAI holdings — or tap a tier — and watch the blade take. Every feature below lights up the moment your bag unlocks it. Tap any one for the full detail.
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.
Discovers, scores and trades Solana launches with zero human intervention.
Every launch is scored 1–10 across website, socials and on-chain signals — only the strongest, with real volume behind them, get through the gates.
Every profit flows back to $SQUDAI holders — token airdrops today, more to come.
A 24/7 record of every token the engine analysed — score, entry, peak, outcome. Pulled live from the production database.
Every distribution the engine has ever made — lottery airdrops, wheel redemptions, game prizes, Elite payouts — is written to the ledger and kept permanently. This is the all-time board, ranked by what those tokens were worth at their peak.
| # | WALLET | HOLDER | TOKENS RECEIVED | TOP TOKEN | IN POTENTIAL | $SQUDAI HELD | HOLDING FOR |
|---|
Tokens received is the raw sum across every coin a wallet was airdropped, with the number of distinct coins beside it. In potential is what those tokens would have been worth at each coin’s peak market cap after we detected it — not what they were worth when they landed, and not what they are worth now. Top token is the biggest runner that wallet caught, measured from detection to peak. Holding period counts only continuous time above 1M $SQUDAI, capped in the display at >30d. Refreshed hourly from an append-only ledger that is retained indefinitely.
Five stages, fully autonomous. Every line below runs in production on Azure Functions, Solana RPC, and Cosmos DB — 24/7.
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}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}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}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)Every AI buy sets a share aside for holders, airdropped straight to winners drawn by weighted ticket lottery — one ticket per 1M $SQUDAI held, one win per wallet 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
}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
Four steps, running on their own. The exact splits are engine settings that get tuned as the system grows — what never changes is the direction of travel: revenue in, holders and the vaults out.
Every $SQUDAI trade on Pump.fun earns a creator fee. That revenue funds the engine and the team — no separate treasury raise, no token sales.
The AI scores new Solana launches around the clock and buys the ones that pass its gates.
Part of every buy is airdropped to eligible holders by weighted lottery, the moment the buy lands. The rest is traded by the sell engine.
Realised profit streams into the three community vaults above — Elite payouts, the XStocks Treasury, and Buy & Burn.
Engine profits will accumulate into a vault of tokenized stocks (XStocks). Every month, the community votes — and the vault pays its holders like dividends.
next community vote · 1st of every month · announced in Telegram ahead of time
A share of every profitable engine trade flows to the Treasury wallet. When the SOL goal is met, the vault buys 4–5 XStocks in equal parts.
On the 1st of each month, holders with 5M+ $SQUDAI held for 24h+ vote in Telegram. The holding-time rule stops wallet-hopping double votes.
If at least 20% of eligible voters take part, 20% of the vault's XStocks are distributed to every eligible holder — voted or not. Dividends, on-chain.
Live on Pump.fun. Copy the contract address below or jump straight to a trading link.
GurGmtPpqf3ghLjPBsbYJHdWZ6k7bDaB2sha9Ycspump
$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.