@wzrd_sol/solana-agent-plugin 0.1.1 → 0.2.0

package/src/actions/deposit.ts

@@ -1,229 +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 type { Action, SolanaAgentKit } from 'solana-agent-kit';
-
-import { formatUsdc, getWalletPublicKey } from '../runtime.js';
-
-const USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
-const CONFIRM_TIMEOUT_MS = 60_000;
-
-type WzrdSdk = typeof import('@wzrd_sol/sdk');
-
-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: SolanaAgentKit,
-  input: z.infer<typeof depositSchema>,
-): Promise<Record<string, unknown>> {
-  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<never>((_, 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(): Promise<WzrdSdk> {
-  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)) as WzrdSdk;
-    } catch {
-      throw error;
-    }
-  }
-}
-
-export const DEPOSIT_ACTION: 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/src/actions/index.ts

@@ -1,6 +0,0 @@
-export type { MarketSignal } from './velocity.js';
-export { LEADERBOARD_ACTION } from './leaderboard.js';
-export { PORTFOLIO_ACTION } from './portfolio.js';
-export { DEPOSIT_ACTION } from './deposit.js';
-export { CLAIM_ACTION } from './claim.js';
-export { VELOCITY_ACTION } from './velocity.js';

package/src/actions/leaderboard.ts

@@ -1,64 +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';
-
-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: SolanaAgentKit,
-  input: z.infer<typeof leaderboardSchema>,
-): Promise<Record<string, unknown>> {
-  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: 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/src/actions/portfolio.ts

@@ -1,64 +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';
-
-import { formatCcm, formatUsdc, getPortfolioData } from '../runtime.js';
-
-export const portfolioSchema = z.object({});
-
-export async function portfolioHandler(
-  agent: SolanaAgentKit,
-  _input: z.infer<typeof portfolioSchema>,
-): Promise<Record<string, unknown>> {
-  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: 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/src/actions/velocity.ts

@@ -1,136 +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 { WzrdMarket } from '../client.js';
-
-import { formatVelocity, getLeaderboardData, type SignalTier } from '../runtime.js';
-
-export interface MarketSignal {
-  market_id: number;
-  metric: string;
-  platform: string;
-  velocity_ema: number;
-  signal: SignalTier;
-  percentile: number;
-}
-
-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: SolanaAgentKit,
-  input: z.infer<typeof velocitySchema>,
-): Promise<Record<string, unknown>> {
-  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: MarketSignal[] = markets.map((m: WzrdMarket) => {
-    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: SignalTier[] = ['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<SignalTier, MarketSignal[]>();
-  for (const s of filtered) {
-    const arr = grouped.get(s.signal) ?? [];
-    arr.push(s);
-    grouped.set(s.signal, arr);
-  }
-
-  const lines: string[] = [];
-  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: 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: WzrdMarket, percentile: number): SignalTier {
-  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';
-}