@wzrd_sol/solana-agent-plugin 0.1.0 → 0.1.2

package/src/actions/claim.ts

@@ -7,9 +7,73 @@
  * Flow: check claimable amount → relay claim → receive CCM.
  */
 
-import type { WzrdClient } from '../client.js';
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
 
-export const CLAIM_ACTION = {
+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:
@@ -22,77 +86,16 @@ export const CLAIM_ACTION = {
   examples: [
     [
       {
-        user: 'user',
-        content: { text: 'Claim my CCM rewards' },
-      },
-      {
-        user: 'assistant',
-        content: {
-          text: 'Claimed 100,000 CCM via gasless relay. ' +
-            'Cumulative total: 250,000 CCM. Tx: 2VKz...J39c',
-        },
-      },
-    ],
-    [
-      {
-        user: 'user',
-        content: { text: 'How much CCM can I claim?' },
-      },
-      {
-        user: 'assistant',
-        content: {
-          text: 'You have 100,000 CCM claimable (250,000 cumulative, 150,000 already claimed). ' +
-            'Shall I claim it now?',
+        input: { execute: false },
+        output: {
+          success: true,
+          claimable: 100000,
+          cumulative_total: 250000,
         },
+        explanation: 'Check how much CCM is available before triggering a relay claim.',
       },
     ],
   ],
-
-  validate: async () => true,
-
-  handler: async (client: WzrdClient, params: { execute?: boolean }) => {
-    // 1. Check claimable amount
-    const claims = await client.getClaims();
-    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,
-      };
-    }
-
-    // 2. If just checking (not executing), report the amount
-    if (params.execute === false) {
-      return {
-        success: true,
-        text:
-          `${claimable} CCM claimable ` +
-          `(${claims.cumulative_total} cumulative, ${claims.claimed_total} claimed). ` +
-          `Root seq: ${claims.root_seq}. Call with execute=true to claim.`,
-        data: claims,
-      };
-    }
-
-    // 3. Execute gasless relay claim
-    const result = await client.claimRelay();
-
-    return {
-      success: true,
-      text:
-        `Claimed CCM via gasless relay. ` +
-        `Cumulative total: ${result.cumulative_total}. ` +
-        `Root seq: ${result.root_seq}. ` +
-        `Tx: ${result.tx_sig.slice(0, 16)}...`,
-      data: {
-        ...result,
-        claimable_before: claimable,
-        explorer: `https://solscan.io/tx/${result.tx_sig}`,
-      },
-    };
-  },
+  schema: claimSchema,
+  handler: async (agent, input) => claimHandler(agent, claimSchema.parse(input)),
 };

package/src/actions/deposit.ts

@@ -9,189 +9,221 @@
  */
 
 import {
-  Connection,
-  Keypair,
   ComputeBudgetProgram,
   TransactionMessage,
   VersionedTransaction,
 } from '@solana/web3.js';
-import {
-  createDepositMarketIx,
-  fetchOnChainPosition,
-  fetchTokenBalance,
-  getAta,
-  TOKEN_PROGRAM_ID,
-} from '@wzrd_sol/sdk';
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
 
-import type { WzrdClient } from '../client.js';
+import { formatUsdc, getWalletPublicKey } from '../runtime.js';
 
 const USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
 const CONFIRM_TIMEOUT_MS = 60_000;
 
-export interface DepositParams {
-  market_id: number;
-  amount_usdc: number;
-  priority_fee?: number; // microLamports per CU, default 50_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' },
+    };
+  }
 
-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.',
+  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() },
+    };
+  }
 
-  examples: [
-    [
-      {
-        user: 'user',
-        content: { text: 'Deposit 0.01 USDC into market 10' },
-      },
-      {
-        user: 'assistant',
-        content: {
-          text: 'Deposited 0.01 USDC into Market #10 (Qwen 2.5 72B). ' +
-            'Received 10,000 vLOFI. Tx: X7FG...Cziv (772ms, 50687 CU)',
-        },
-      },
-    ],
-    [
-      {
-        user: 'user',
-        content: { text: 'Invest in the highest velocity market' },
-      },
-      {
-        user: 'assistant',
-        content: {
-          text: 'Looking up leaderboard... Top market is #16 (Qwen 3.5 35B) ' +
-            'with 804K velocity. Depositing 0.01 USDC...',
-        },
+  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(),
       },
-    ],
-  ],
-
-  validate: async (_client: WzrdClient, params: DepositParams) => {
-    if (!params.market_id || params.market_id < 1) return false;
-    if (!params.amount_usdc || params.amount_usdc <= 0) return false;
-    if (params.amount_usdc > 100) return false; // safety cap
-    return true;
-  },
-
-  handler: async (
-    _client: WzrdClient,
-    params: DepositParams,
-    connection: Connection,
-    wallet: Keypair,
-  ) => {
-    const { market_id, amount_usdc, priority_fee = 50_000 } = params;
-    const amountNative = BigInt(Math.round(amount_usdc * 1_000_000));
-    const t0 = Date.now();
-
-    // 1. Idempotency — check existing position
-    const existing = await fetchOnChainPosition(
-      connection,
-      wallet.publicKey,
-      market_id,
-    );
-    if (existing && existing.depositedAmount > 0n && !existing.settled) {
-      return {
-        success: false,
-        text: `Position already exists in market ${market_id} ` +
-          `(${existing.depositedAmount} deposited). Cannot double-deposit.`,
-      };
-    }
-
-    // 2. Balance checks
-    const { PublicKey } = await import('@solana/web3.js');
-    const usdcMint = new PublicKey(USDC_MINT);
-    const usdcAta = getAta(wallet.publicKey, usdcMint, TOKEN_PROGRAM_ID);
-    const usdcBalance = await fetchTokenBalance(connection, usdcAta);
-    if (usdcBalance < amountNative) {
-      return {
-        success: false,
-        text: `Insufficient USDC: have ${Number(usdcBalance) / 1e6}, need ${amount_usdc}`,
-      };
-    }
-
-    const solBalance = await connection.getBalance(wallet.publicKey);
-    if (solBalance < 10_000) {
-      return {
-        success: false,
-        text: `Insufficient SOL for tx fees: ${solBalance} lamports`,
-      };
-    }
+    };
+  }
 
-    // 3. Build deposit instructions
-    const ixs = await createDepositMarketIx(
-      connection,
-      wallet.publicKey,
-      market_id,
-      amountNative,
-    );
-
-    ixs.unshift(
-      ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
-      ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priority_fee }),
-    );
-
-    // 4. Simulate
-    const { blockhash, lastValidBlockHeight } =
-      await connection.getLatestBlockhash('confirmed');
-    const message = new TransactionMessage({
-      payerKey: wallet.publicKey,
-      recentBlockhash: blockhash,
-      instructions: ixs,
-    }).compileToV0Message();
-
-    const tx = new VersionedTransaction(message);
-    tx.sign([wallet]);
-
-    const sim = await connection.simulateTransaction(tx);
-    if (sim.value.err) {
+  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: `Simulation failed: ${JSON.stringify(sim.value.err)}`,
-        data: { logs: sim.value.logs?.slice(-5) },
+        text:
+          `Market ${market_id} does not have a live vault yet. ` +
+          'Choose a depositable market and retry.',
+        data: { market_id, reason: 'missing_vault' },
       };
     }
-
-    // 5. Send + confirm
-    const signature = await connection.sendTransaction(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,
-      ),
-    );
-
+    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]);
-    const elapsed = Date.now() - t0;
-
+  } catch (error) {
     return {
       success: true,
       text:
-        `Deposited ${amount_usdc} USDC into Market #${market_id}. ` +
-        `Tx: ${signature.slice(0, 16)}... (${elapsed}ms, ${sim.value.unitsConsumed} CU)`,
+        `Deposit transaction sent for Market #${market_id}, but confirmation timed out. ` +
+        `Tx: ${signature}`,
       data: {
         signature,
         market_id,
         amount_usdc,
-        cu_used: sim.value.unitsConsumed,
-        elapsed_ms: elapsed,
+        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,3 +1,4 @@
+export type { MarketSignal } from './velocity.js';
 export { LEADERBOARD_ACTION } from './leaderboard.js';
 export { PORTFOLIO_ACTION } from './portfolio.js';
 export { DEPOSIT_ACTION } from './deposit.js';

package/src/actions/leaderboard.ts

@@ -5,9 +5,39 @@
  * No auth required. Permissionless read.
  */
 
-import type { WzrdClient, WzrdMarket } from '../client.js';
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
 
-export const LEADERBOARD_ACTION = {
+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:
@@ -19,63 +49,16 @@ export const LEADERBOARD_ACTION = {
   examples: [
     [
       {
-        user: 'user',
-        content: { text: 'Show me the top attention markets' },
-      },
-      {
-        user: 'assistant',
-        content: {
-          text: 'Here are the top WZRD markets by velocity:\n' +
-            '1. Qwen 3.5 35B — 804K velocity (HuggingFace)\n' +
-            '2. Qwen 3.5 9B — 769K velocity (HuggingFace)\n' +
-            '3. Ollama — 104K velocity (GitHub)',
-        },
-      },
-    ],
-    [
-      {
-        user: 'user',
-        content: { text: 'What HuggingFace models are trending?' },
-      },
-      {
-        user: 'assistant',
-        content: {
-          text: 'Top HuggingFace models by attention velocity: ...',
+        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.',
       },
     ],
   ],
-
-  validate: async () => true,
-
-  handler: async (
-    client: WzrdClient,
-    params: { limit?: number; platform?: string },
-  ) => {
-    const data = await client.getLeaderboard(
-      params.limit ?? 10,
-      params.platform,
-    );
-
-    const lines = data.markets.map(
-      (m: WzrdMarket, i: number) =>
-        `${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,
-    };
-  },
+  schema: leaderboardSchema,
+  handler: async (agent, input) => leaderboardHandler(agent, leaderboardSchema.parse(input)),
 };
-
-function formatVelocity(v: number): string {
-  if (v >= 1_000_000) return `${(v / 1_000_000).toFixed(1)}M`;
-  if (v >= 1_000) return `${(v / 1_000).toFixed(0)}K`;
-  return v.toFixed(0);
-}