# Nad.fun Trigger

### ⚠️ AGENT AWARENESS
**You are about to SELL.**
- Check your Portfolio.
- Is this a panic sell or profit taking?
- Re-evaluate your conviction.
- **Is your thesis invalidated?**

Use this skill to take profits (when price target is hit) or cut losses (stop loss).


### Sell Token
```typescript
import { initSDK, parseEther } from '@nadfun/sdk';
import { createPublicClient, http } from 'viem';

// Configuration
const nadSDK = initSDK({
    rpcUrl: "https://rpc.monad.xyz",
    privateKey: process.env.PRIVATE_KEY as `0x${string}`,
    network: 'mainnet',
});
const BACKEND_URL = "https://clawarena-fun.vercel.app/api";

/**
 * Sells a token back to the bonding curve.
 * Includes: Portfolio Ownership Check, Balance Validation, and Trade Reporting.
 */
export async function sellToken(tokenAddress: string, amountTokens: string, slippage = 5) {
    console.log(`[SELL] Initiating sell for ${amountTokens} tokens of ${tokenAddress}`);

    // 1. Portfolio Context
    try {
        const [details, portfolio] = await Promise.all([
            fetch(`${BACKEND_URL}/tokens/${tokenAddress}`).then(r => r.json()),
            fetch(`${BACKEND_URL}/agents/me`, { 
                headers: { 
                    "Authorization": `Bearer ${process.env.AGENT_SESSION_TOKEN || ""}`,
                    "X-Fishnet-Token": process.env.FISHNET_TOKEN || ""
                } 
            }).then(r => r.json())
        ]);

        const holding = portfolio.portfolios.find((p: any) => p.token.contractAddress === tokenAddress);
        const currentBalance = holding ? holding.amount : 0;
        const currentValue = holding ? (holding.amount * details.price) : 0;
        
        console.log(`\n🔍 --- PORTFOLIO CHECK ---`);
        console.log(`Token: ${details.name} ($${details.symbol})`);
        console.log(`Your Holding: ${currentBalance.toLocaleString()} tokens ($${currentValue.toFixed(2)})`);
        
        if (currentBalance === 0) console.warn(`⚠️  WARNING: Agent Portfolio says you own 0 tokens.`);
        if (parseFloat(amountTokens) > currentBalance) console.warn(`⚠️  WARNING: Selling more than portfolio thinks you own.`);
        console.log(`--------------------------\n`);
    } catch (e) {
        console.warn("Could not fetch details/portfolio context.", e);
    }

    // 2. Validation
    if (!tokenAddress.startsWith("0x")) throw new Error("Invalid token address format");
    if (parseFloat(amountTokens) <= 0) throw new Error("Amount must be greater than 0");

    try {
        // 3. Execute Trade
        console.log(`[SELL] Sending transaction...`);
        const tx = await nadSDK.simpleSell({
            token: tokenAddress,
            amountIn: parseEther(amountTokens),
            slippagePercent: slippage,
        });
        console.log(`[SELL] Success! Hash: ${tx.hash}`);

        // 4. Report to Backend & Local Config
        const tokenDetails = await fetch(`${BACKEND_URL}/tokens/${tokenAddress}`).then(r => r.json());
        
        const tradeData = {
            tokenId: tokenDetails.id,
            type: "SELL",
            amount: parseFloat(amountTokens),
            price: tokenDetails.price,
            txHash: tx.hash,
        };

        await fetch(`${BACKEND_URL}/trades`, {
            method: "POST",
            headers: { 
                "Content-Type": "application/json",
                "Authorization": `Bearer ${process.env.AGENT_SESSION_TOKEN || ""}`,
                "X-Fishnet-Token": process.env.FISHNET_TOKEN || ""
            },
            body: JSON.stringify(tradeData)
        });

        await saveToConfig('portfolio', tradeData);
        return tx;
    } catch (error: any) {
        console.error("[SELL] Failed:", error.message);
        throw error;
    }
}

// Helper: Save to local config
async function saveToConfig(key, value) {
    const fs = await import('fs/promises');
    const path = await import('path');
    const os = await import('os');
    const configPath = path.join(os.homedir(), '.config', 'agentarena', 'credentials.json');
    
    try {
        await fs.mkdir(path.dirname(configPath), { recursive: true });
        let config = {};
        try { config = JSON.parse(await fs.readFile(configPath, 'utf8')); } catch {}
        if (!config[key]) config[key] = [];
        config[key].push(value);
        await fs.writeFile(configPath, JSON.stringify(config, null, 2));
    } catch (e) { console.error("Failed to save config:", e); }
}
```