@wzrd_sol/solana-agent-plugin 0.1.1 → 0.2.0

package/dist/actions/deposit.js

@@ -1,177 +0,0 @@
-/**
- * Action: wzrd_deposit
- *
- * Deposit USDC into a WZRD attention market → mint vLOFI tokens.
- * Requires: Keypair with USDC balance + SOL for tx fees.
- *
- * The agent picks a market_id (from leaderboard), specifies USDC amount,
- * and the handler builds + signs + sends the deposit transaction.
- */
-import { ComputeBudgetProgram, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
-import { z } from 'zod';
-import { formatUsdc, getWalletPublicKey } from '../runtime.js';
-const USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
-const CONFIRM_TIMEOUT_MS = 60_000;
-export const depositSchema = z.object({
-    market_id: z.number().int().min(1),
-    amount_usdc: z.number().positive().max(100),
-    priority_fee: z.number().int().positive().optional(),
-});
-export async function depositHandler(agent, input) {
-    const { market_id, amount_usdc, priority_fee = 50_000 } = input;
-    const connection = agent.connection;
-    const payer = getWalletPublicKey(agent);
-    const amountNative = BigInt(Math.round(amount_usdc * 1_000_000));
-    const t0 = Date.now();
-    const sdk = await loadSdk();
-    const { createDepositMarketIx, fetchMarketVault, fetchOnChainPosition, fetchTokenBalance, getAta, TOKEN_PROGRAM_ID, } = sdk;
-    const vault = await fetchMarketVault(connection, market_id);
-    if (!vault) {
-        return {
-            success: false,
-            text: `Market ${market_id} is listed but does not have an on-chain vault yet. ` +
-                'Pick a market with an initialized vault before depositing.',
-            data: { market_id, reason: 'missing_vault' },
-        };
-    }
-    const existing = await fetchOnChainPosition(connection, payer, market_id);
-    if (existing && existing.depositedAmount > 0n && !existing.settled) {
-        return {
-            success: false,
-            text: `Position already exists in market ${market_id} ` +
-                `(${formatUsdc(existing.depositedAmount)} USDC deposited). Cannot double-deposit.`,
-            data: { market_id, deposited_amount: existing.depositedAmount.toString() },
-        };
-    }
-    const usdcAta = getAta(payer, vault.depositMint, TOKEN_PROGRAM_ID);
-    const usdcBalance = await fetchTokenBalance(connection, usdcAta);
-    if (usdcBalance < amountNative) {
-        return {
-            success: false,
-            text: `Insufficient USDC: have ${formatUsdc(usdcBalance)}, need ${amount_usdc.toFixed(4)}`,
-            data: {
-                market_id,
-                required_native: amountNative.toString(),
-                balance_native: usdcBalance.toString(),
-            },
-        };
-    }
-    const solBalance = await connection.getBalance(payer);
-    if (solBalance < 10_000) {
-        return {
-            success: false,
-            text: `Insufficient SOL for tx fees: ${solBalance} lamports`,
-            data: { market_id, sol_balance_lamports: solBalance },
-        };
-    }
-    let ixs;
-    try {
-        ixs = await createDepositMarketIx(connection, payer, market_id, amountNative);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes('MarketVault not found')) {
-            return {
-                success: false,
-                text: `Market ${market_id} does not have a live vault yet. ` +
-                    'Choose a depositable market and retry.',
-                data: { market_id, reason: 'missing_vault' },
-            };
-        }
-        throw error;
-    }
-    ixs.unshift(ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priority_fee }));
-    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash('confirmed');
-    const message = new TransactionMessage({
-        payerKey: payer,
-        recentBlockhash: blockhash,
-        instructions: ixs,
-    }).compileToV0Message();
-    const tx = new VersionedTransaction(message);
-    const signedTx = await agent.wallet.signTransaction(tx);
-    const sim = await connection.simulateTransaction(signedTx);
-    if (sim.value.err) {
-        return {
-            success: false,
-            text: `Simulation failed: ${JSON.stringify(sim.value.err)}`,
-            data: { market_id, logs: sim.value.logs?.slice(-5) ?? [] },
-        };
-    }
-    const { signature } = await agent.wallet.signAndSendTransaction(tx, {
-        skipPreflight: true,
-        maxRetries: 3,
-    });
-    const confirmed = connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, 'confirmed');
-    const timeout = new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${CONFIRM_TIMEOUT_MS}ms`)), CONFIRM_TIMEOUT_MS));
-    try {
-        await Promise.race([confirmed, timeout]);
-    }
-    catch (error) {
-        return {
-            success: true,
-            text: `Deposit transaction sent for Market #${market_id}, but confirmation timed out. ` +
-                `Tx: ${signature}`,
-            data: {
-                signature,
-                market_id,
-                amount_usdc,
-                timed_out: true,
-                explorer: `https://solscan.io/tx/${signature}`,
-            },
-        };
-    }
-    const elapsed = Date.now() - t0;
-    return {
-        success: true,
-        text: `Deposited ${amount_usdc.toFixed(4)} USDC into Market #${market_id}. ` +
-            `Tx: ${signature.slice(0, 16)}... (${elapsed}ms, ${sim.value.unitsConsumed} CU)`,
-        data: {
-            signature,
-            market_id,
-            amount_usdc,
-            cu_used: sim.value.unitsConsumed,
-            elapsed_ms: elapsed,
-            explorer: `https://solscan.io/tx/${signature}`,
-        },
-    };
-}
-async function loadSdk() {
-    try {
-        return await import('@wzrd_sol/sdk');
-    }
-    catch (error) {
-        const fallbackUrl = new URL('../../../../sdk/dist/index.js', import.meta.url);
-        try {
-            return (await import(fallbackUrl.href));
-        }
-        catch {
-            throw error;
-        }
-    }
-}
-export const DEPOSIT_ACTION = {
-    name: 'wzrd_deposit',
-    similes: ['wzrd_invest', 'deposit_usdc', 'buy_attention', 'enter_market'],
-    description: 'Deposit USDC into a WZRD attention market to mint vLOFI tokens. ' +
-        'vLOFI represents your position in the market. As the underlying AI model ' +
-        'gains attention (downloads, stars), your multiplier increases and you earn ' +
-        'more CCM on each merkle root publication. ' +
-        'Requires: market_id (from leaderboard) and amount_usdc (e.g., 0.01). ' +
-        'The deposit is atomic — USDC is transferred and vLOFI is minted in one transaction.',
-    examples: [
-        [
-            {
-                input: { market_id: 10, amount_usdc: 0.01 },
-                output: {
-                    success: true,
-                    market_id: 10,
-                    amount_usdc: 0.01,
-                    signature: 'X7FG...',
-                },
-                explanation: 'Deposit 0.01 USDC into a known vaulted market and mint vLOFI.',
-            },
-        ],
-    ],
-    schema: depositSchema,
-    handler: async (agent, input) => depositHandler(agent, depositSchema.parse(input)),
-};

package/dist/actions/leaderboard.d.ts

@@ -1,20 +0,0 @@
-/**
- * Action: wzrd_leaderboard
- *
- * Fetch the WZRD attention market leaderboard — ranked by velocity EMA.
- * No auth required. Permissionless read.
- */
-import { z } from 'zod';
-import type { Action, SolanaAgentKit } from 'solana-agent-kit';
-export declare const leaderboardSchema: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodNumber>;
-    platform: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    limit?: number | undefined;
-    platform?: string | undefined;
-}, {
-    limit?: number | undefined;
-    platform?: string | undefined;
-}>;
-export declare function leaderboardHandler(agent: SolanaAgentKit, input: z.infer<typeof leaderboardSchema>): Promise<Record<string, unknown>>;
-export declare const LEADERBOARD_ACTION: Action;

package/dist/actions/leaderboard.js

@@ -1,47 +0,0 @@
-/**
- * Action: wzrd_leaderboard
- *
- * Fetch the WZRD attention market leaderboard — ranked by velocity EMA.
- * No auth required. Permissionless read.
- */
-import { z } from 'zod';
-import { formatVelocity, getLeaderboardData } from '../runtime.js';
-export const leaderboardSchema = z.object({
-    limit: z.number().int().min(1).max(50).optional(),
-    platform: z.string().min(1).optional(),
-});
-export async function leaderboardHandler(agent, input) {
-    const data = await getLeaderboardData(agent, input);
-    const lines = data.markets.map((m, i) => `${i + 1}. ${m.metric} — ${formatVelocity(m.velocity_ema)} velocity ` +
-        `(${m.platform}) | ${m.multiplier_bps / 10000}x multiplier | ` +
-        `${m.position_count} positions | market_id=${m.market_id}`);
-    return {
-        success: true,
-        text: `WZRD Leaderboard (${data.markets.length} markets, ` +
-            `root_seq=${data.root.root_seq}):\n${lines.join('\n')}`,
-        data,
-    };
-}
-export const LEADERBOARD_ACTION = {
-    name: 'wzrd_leaderboard',
-    similes: ['wzrd_markets', 'wzrd_trending', 'attention_markets', 'top_models'],
-    description: 'Fetch the WZRD attention market leaderboard. Shows AI models and open-source ' +
-        'projects ranked by real-time velocity (download/star momentum). Returns market IDs, ' +
-        'velocity EMA, multiplier, TVL, and platform (huggingface/github). ' +
-        'Use this to find the highest-attention markets before depositing.',
-    examples: [
-        [
-            {
-                input: { limit: 3 },
-                output: {
-                    success: true,
-                    root_seq: 1549,
-                    markets: ['#16 Qwen 3.5 35B', '#14 Qwen 3.5 9B', '#10 Qwen 2.5 72B'],
-                },
-                explanation: 'Fetch the top three WZRD markets without requiring auth.',
-            },
-        ],
-    ],
-    schema: leaderboardSchema,
-    handler: async (agent, input) => leaderboardHandler(agent, leaderboardSchema.parse(input)),
-};

package/dist/actions/portfolio.d.ts

@@ -1,11 +0,0 @@
-/**
- * Action: wzrd_portfolio
- *
- * Fetch the agent's WZRD portfolio — positions, USDC deposited, vLOFI held, CCM earned.
- * Requires auth (Ed25519 agent session).
- */
-import { z } from 'zod';
-import type { Action, SolanaAgentKit } from 'solana-agent-kit';
-export declare const portfolioSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare function portfolioHandler(agent: SolanaAgentKit, _input: z.infer<typeof portfolioSchema>): Promise<Record<string, unknown>>;
-export declare const PORTFOLIO_ACTION: Action;

package/dist/actions/portfolio.js

@@ -1,48 +0,0 @@
-/**
- * Action: wzrd_portfolio
- *
- * Fetch the agent's WZRD portfolio — positions, USDC deposited, vLOFI held, CCM earned.
- * Requires auth (Ed25519 agent session).
- */
-import { z } from 'zod';
-import { formatCcm, formatUsdc, getPortfolioData } from '../runtime.js';
-export const portfolioSchema = z.object({});
-export async function portfolioHandler(agent, _input) {
-    const portfolio = await getPortfolioData(agent);
-    const open = portfolio.positions.filter((p) => !p.is_settled);
-    const lines = open.map((p) => `• Market #${p.market_id} (${p.metric}): ` +
-        `${formatUsdc(p.usdc_deposited)} USDC, ` +
-        `${(p.multiplier_bps / 10_000).toFixed(1)}x multiplier` +
-        (p.is_settled ? ' [settled]' : ''));
-    return {
-        success: true,
-        text: `Your WZRD portfolio (${open.length} open positions):\n` +
-            `${lines.length ? lines.join('\n') : '(no positions)'}\n` +
-            `Total: ${formatUsdc(portfolio.total_deposited_usdc)} USDC deposited, ` +
-            `${formatCcm(portfolio.total_ccm_earned)} CCM earned`,
-        data: portfolio,
-    };
-}
-export const PORTFOLIO_ACTION = {
-    name: 'wzrd_portfolio',
-    similes: ['wzrd_positions', 'wzrd_balance', 'wzrd_holdings', 'my_positions'],
-    description: 'Fetch your WZRD portfolio — all open positions across attention markets. ' +
-        'Shows USDC deposited, vLOFI minted, multiplier, and settlement status per market. ' +
-        'Use this to check your exposure before depositing more or claiming CCM.',
-    examples: [
-        [
-            {
-                input: {},
-                output: {
-                    success: true,
-                    open_positions: 2,
-                    total_deposited_usdc: 20000,
-                    total_ccm_earned: 0,
-                },
-                explanation: 'Fetch the authenticated agent portfolio and summarize open exposure.',
-            },
-        ],
-    ],
-    schema: portfolioSchema,
-    handler: async (agent, input) => portfolioHandler(agent, portfolioSchema.parse(input)),
-};

package/dist/actions/velocity.d.ts

@@ -1,37 +0,0 @@
-/**
- * Action: wzrd_velocity
- *
- * Analyze attention velocity across markets — classify signal strength.
- * No auth required. Pure analytics over leaderboard data.
- *
- * Signal tiers:
- *   BREAKOUT  — top 10% velocity (p90+)
- *   MOMENTUM  — p70-90
- *   EMERGING  — new market (<300 snapshots) with above-median velocity
- *   STABLE    — p40-70
- *   COOLING   — p20-40
- *   WEAK      — below p20
- */
-import { z } from 'zod';
-import type { Action, SolanaAgentKit } from 'solana-agent-kit';
-import { type SignalTier } from '../runtime.js';
-export interface MarketSignal {
-    market_id: number;
-    metric: string;
-    platform: string;
-    velocity_ema: number;
-    signal: SignalTier;
-    percentile: number;
-}
-export declare const velocitySchema: z.ZodObject<{
-    platform: z.ZodOptional<z.ZodString>;
-    min_signal: z.ZodOptional<z.ZodEnum<["BREAKOUT", "MOMENTUM", "EMERGING", "STABLE", "COOLING", "WEAK"]>>;
-}, "strip", z.ZodTypeAny, {
-    platform?: string | undefined;
-    min_signal?: "BREAKOUT" | "MOMENTUM" | "EMERGING" | "STABLE" | "COOLING" | "WEAK" | undefined;
-}, {
-    platform?: string | undefined;
-    min_signal?: "BREAKOUT" | "MOMENTUM" | "EMERGING" | "STABLE" | "COOLING" | "WEAK" | undefined;
-}>;
-export declare function velocityHandler(agent: SolanaAgentKit, input: z.infer<typeof velocitySchema>): Promise<Record<string, unknown>>;
-export declare const VELOCITY_ACTION: Action;

package/dist/actions/velocity.js

@@ -1,110 +0,0 @@
-/**
- * Action: wzrd_velocity
- *
- * Analyze attention velocity across markets — classify signal strength.
- * No auth required. Pure analytics over leaderboard data.
- *
- * Signal tiers:
- *   BREAKOUT  — top 10% velocity (p90+)
- *   MOMENTUM  — p70-90
- *   EMERGING  — new market (<300 snapshots) with above-median velocity
- *   STABLE    — p40-70
- *   COOLING   — p20-40
- *   WEAK      — below p20
- */
-import { z } from 'zod';
-import { formatVelocity, getLeaderboardData } from '../runtime.js';
-export const velocitySchema = z.object({
-    platform: z.string().min(1).optional(),
-    min_signal: z
-        .enum(['BREAKOUT', 'MOMENTUM', 'EMERGING', 'STABLE', 'COOLING', 'WEAK'])
-        .optional(),
-});
-export async function velocityHandler(agent, input) {
-    const data = await getLeaderboardData(agent, { limit: 50, platform: input.platform });
-    const markets = data.markets;
-    if (markets.length === 0) {
-        return { success: true, text: 'No markets found.', data: { signals: [] } };
-    }
-    const sorted = [...markets].sort((a, b) => a.velocity_ema - b.velocity_ema);
-    const signals = markets.map((m) => {
-        const rank = sorted.findIndex((s) => s.market_id === m.market_id);
-        const percentile = ((rank + 1) / sorted.length) * 100;
-        const signal = classify(m, percentile);
-        return {
-            market_id: m.market_id,
-            metric: m.metric,
-            platform: m.platform,
-            velocity_ema: m.velocity_ema,
-            signal,
-            percentile: Math.round(percentile),
-        };
-    });
-    const tierOrder = ['BREAKOUT', 'MOMENTUM', 'EMERGING', 'STABLE', 'COOLING', 'WEAK'];
-    const minIdx = input.min_signal
-        ? tierOrder.indexOf(input.min_signal)
-        : tierOrder.length;
-    const filtered = minIdx < tierOrder.length
-        ? signals.filter((s) => tierOrder.indexOf(s.signal) <= minIdx)
-        : signals;
-    const grouped = new Map();
-    for (const s of filtered) {
-        const arr = grouped.get(s.signal) ?? [];
-        arr.push(s);
-        grouped.set(s.signal, arr);
-    }
-    const lines = [];
-    for (const tier of tierOrder) {
-        const group = grouped.get(tier);
-        if (!group?.length)
-            continue;
-        lines.push(`${tier}:`);
-        for (const s of group) {
-            lines.push(`  • ${s.metric} (${formatVelocity(s.velocity_ema)} velocity, p${s.percentile}) [${s.platform}]`);
-        }
-    }
-    const medianIdx = Math.floor(sorted.length / 2);
-    const medianVelocity = sorted[medianIdx]?.velocity_ema ?? 0;
-    return {
-        success: true,
-        text: `Velocity analysis (${markets.length} markets, ` +
-            `median ${formatVelocity(medianVelocity)}):\n${lines.join('\n')}`,
-        data: { signals: filtered, median_velocity: medianVelocity },
-    };
-}
-export const VELOCITY_ACTION = {
-    name: 'wzrd_velocity',
-    similes: ['wzrd_signal', 'attention_signal', 'market_analysis', 'velocity_check'],
-    description: 'Analyze attention velocity across WZRD markets. Classifies each market into ' +
-        'signal tiers: BREAKOUT (top 10%), MOMENTUM (70-90th percentile), EMERGING ' +
-        '(new + above median), STABLE, COOLING, WEAK. ' +
-        'Use this to find the best deposit opportunities — BREAKOUT and MOMENTUM ' +
-        'markets have the strongest attention momentum.',
-    examples: [
-        [
-            {
-                input: { min_signal: 'MOMENTUM' },
-                output: {
-                    success: true,
-                    signals: ['BREAKOUT: Qwen 3.5 35B', 'MOMENTUM: Qwen 2.5 72B'],
-                },
-                explanation: 'Classify the current leaderboard into signal tiers for deposit decisions.',
-            },
-        ],
-    ],
-    schema: velocitySchema,
-    handler: async (agent, input) => velocityHandler(agent, velocitySchema.parse(input)),
-};
-function classify(m, percentile) {
-    if (percentile >= 90)
-        return 'BREAKOUT';
-    if (percentile >= 70)
-        return 'MOMENTUM';
-    if (m.snapshot_count < 300 && percentile >= 50)
-        return 'EMERGING';
-    if (percentile >= 40)
-        return 'STABLE';
-    if (percentile >= 20)
-        return 'COOLING';
-    return 'WEAK';
-}

package/examples/hello-wzrd.mjs

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-/**
- * WZRD "Hello World" — prove an agent can interact in 30 seconds.
- *
- * What this does:
- *   1. Read the leaderboard (no auth, 2 seconds)
- *   2. Authenticate with Ed25519 (no browser, 1 second)
- *   3. Check portfolio (what do I hold?)
- *   4. Check claimable CCM (any rewards ready?)
- *
- * Usage:
- *   SOLANA_RPC_URL=https://... WZRD_KEYPAIR_PATH=~/.config/solana/id.json node hello-wzrd.mjs
- *
- * Or generate a fresh keypair:
- *   solana-keygen new -o /tmp/agent.json --no-bip39-passphrase
- *   SOLANA_RPC_URL=https://... WZRD_KEYPAIR_PATH=/tmp/agent.json node hello-wzrd.mjs
- */
-
-import { readFileSync } from 'node:fs';
-import { Keypair } from '@solana/web3.js';
-import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
-
-const KEYPAIR_PATH = process.env.WZRD_KEYPAIR_PATH;
-if (!KEYPAIR_PATH) {
-  console.log('Usage: WZRD_KEYPAIR_PATH=/path/to/keypair.json node hello-wzrd.mjs');
-  console.log('Generate one: solana-keygen new -o /tmp/agent.json --no-bip39-passphrase');
-  process.exit(1);
-}
-
-const raw = readFileSync(KEYPAIR_PATH, 'utf8');
-const wallet = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(raw)));
-const client = new WzrdClient(wallet);
-
-console.log(`\n=== WZRD Hello World ===`);
-console.log(`Agent: ${wallet.publicKey.toBase58()}\n`);
-
-// 1. Leaderboard (public, no auth)
-console.log('→ Fetching leaderboard...');
-const board = await client.getLeaderboard(5);
-console.log(`  ${board.markets.length} markets, root_seq=${board.root.root_seq}`);
-for (const m of board.markets) {
-  const vel = m.velocity_ema >= 1000 ? `${(m.velocity_ema/1000).toFixed(0)}K` : m.velocity_ema.toFixed(0);
-  console.log(`  #${m.market_id} ${m.metric} — ${vel} velocity (${m.platform})`);
-}
-
-// 2. Portfolio (auth required — triggers challenge/verify automatically)
-console.log('\n→ Authenticating + fetching portfolio...');
-try {
-  const portfolio = await client.getPortfolio();
-  const open = portfolio.positions.filter(p => !p.is_settled);
-  console.log(`  ${open.length} open positions, ${(portfolio.total_deposited_usdc / 1e6).toFixed(4)} USDC total`);
-  for (const p of open) {
-    console.log(`  • Market #${p.market_id}: ${(p.usdc_deposited / 1e6).toFixed(4)} USDC, ${(p.multiplier_bps / 10000).toFixed(1)}x`);
-  }
-} catch (e) {
-  console.log(`  No portfolio yet (${e instanceof Error ? e.message : e})`);
-  console.log('  → First-time agent? You got auto-funded 0.003 SOL + 1000 CCM signup bonus!');
-}
-
-// 3. Claims check
-console.log('\n→ Checking claimable CCM...');
-try {
-  const claims = await client.getClaims();
-  const claimable = claims.cumulative_total - claims.claimed_total;
-  console.log(`  Cumulative: ${claims.cumulative_total}, Claimed: ${claims.claimed_total}`);
-  console.log(`  Claimable now: ${claimable > 0 ? claimable : 'none'}`);
-  if (claimable > 0) {
-    console.log('  → Run with --claim to harvest via gasless relay');
-  }
-} catch (e) {
-  console.log(`  No claims data yet (${e instanceof Error ? e.message : e})`);
-}
-
-console.log('\n=== Done ===');
-console.log('Next steps:');
-console.log('  1. Fund your wallet with USDC (even 0.01 is enough)');
-console.log('  2. Use wzrd_deposit to enter a market');
-console.log('  3. Wait ~10 min for scoring cycle');
-console.log('  4. Use wzrd_claim to harvest CCM (gasless — no SOL needed)');

package/src/actions/claim.ts

@@ -1,101 +0,0 @@
-/**
- * Action: wzrd_claim
- *
- * Claim accrued CCM tokens via the gasless relay.
- * Server pays tx fees — agent doesn't need SOL to claim.
- *
- * Flow: check claimable amount → relay claim → receive CCM.
- */
-
-import { z } from 'zod';
-import type { Action, SolanaAgentKit } from 'solana-agent-kit';
-
-import { formatCcm, getClaimsData, getClientForAgent } from '../runtime.js';
-
-export const claimSchema = z.object({
-  execute: z.boolean().optional(),
-});
-
-export async function claimHandler(
-  agent: SolanaAgentKit,
-  input: z.infer<typeof claimSchema>,
-): Promise<Record<string, unknown>> {
-  const claims = await getClaimsData(agent);
-  const claimable = claims.cumulative_total - claims.claimed_total;
-
-  if (claimable <= 0) {
-    return {
-      success: true,
-      text:
-        `No CCM to claim. Cumulative: ${claims.cumulative_total}, ` +
-        `already claimed: ${claims.claimed_total}. ` +
-        `Deposit into markets and wait for the next scoring cycle.`,
-      data: claims,
-    };
-  }
-
-  if (input.execute === false) {
-    return {
-      success: true,
-      text:
-        `${formatCcm(claimable)} CCM claimable ` +
-        `(${formatCcm(claims.cumulative_total)} cumulative, ` +
-        `${formatCcm(claims.claimed_total)} claimed). ` +
-        `Root seq: ${claims.root_seq}. Call with execute=true to claim.`,
-      data: claims,
-    };
-  }
-
-  const result = await getClientForAgent(agent).claimRelay();
-
-  if (result.status === 'already_claimed') {
-    return {
-      success: true,
-      text:
-        `Already claimed through root ${result.root_seq}. ` +
-        `Claimed total: ${formatCcm(result.claimed_total ?? claims.claimed_total)} CCM.`,
-      data: result,
-    };
-  }
-
-  return {
-    success: true,
-    text:
-      `Claimed CCM via gasless relay. ` +
-      `Cumulative total: ${formatCcm(result.cumulative_total)}. ` +
-      `Root seq: ${result.root_seq}. ` +
-      `Tx: ${result.tx_sig?.slice(0, 16)}...`,
-    data: {
-      ...result,
-      claimable_before: claimable,
-      explorer: result.tx_sig ? `https://solscan.io/tx/${result.tx_sig}` : null,
-    },
-  };
-}
-
-export const CLAIM_ACTION: Action = {
-  name: 'wzrd_claim',
-  similes: ['wzrd_harvest', 'claim_ccm', 'redeem_rewards', 'collect_yield'],
-  description:
-    'Claim accrued CCM tokens from your WZRD positions. Uses the gasless relay — ' +
-    'the server pays transaction fees, so you don\'t need SOL to claim. ' +
-    'CCM accrues based on your velocity multiplier and is distributed via ' +
-    'merkle proofs published on-chain every ~10 minutes. ' +
-    'Call this periodically to harvest your earned CCM.',
-
-  examples: [
-    [
-      {
-        input: { execute: false },
-        output: {
-          success: true,
-          claimable: 100000,
-          cumulative_total: 250000,
-        },
-        explanation: 'Check how much CCM is available before triggering a relay claim.',
-      },
-    ],
-  ],
-  schema: claimSchema,
-  handler: async (agent, input) => claimHandler(agent, claimSchema.parse(input)),
-};