@wzrd_sol/solana-agent-plugin 0.1.0 → 0.1.2

package/dist/actions/leaderboard.js

@@ -4,6 +4,24 @@
  * 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'],
@@ -14,50 +32,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, params) => {
-        const data = await client.getLeaderboard(params.limit ?? 10, params.platform);
-        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,
-        };
-    },
+    schema: leaderboardSchema,
+    handler: async (agent, input) => leaderboardHandler(agent, leaderboardSchema.parse(input)),
 };
-function formatVelocity(v) {
-    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);
-}

package/dist/actions/portfolio.d.ts

@@ -4,21 +4,8 @@
  * Fetch the agent's WZRD portfolio — positions, USDC deposited, vLOFI held, CCM earned.
  * Requires auth (Ed25519 agent session).
  */
-import type { WzrdClient } from '../client.js';
-export declare const PORTFOLIO_ACTION: {
-    name: string;
-    similes: string[];
-    description: string;
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: () => Promise<boolean>;
-    handler: (client: WzrdClient) => Promise<{
-        success: boolean;
-        text: string;
-        data: import("../client.js").WzrdPortfolio;
-    }>;
-};
+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

@@ -4,6 +4,25 @@
  * 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'],
@@ -13,36 +32,17 @@ export const PORTFOLIO_ACTION = {
     examples: [
         [
             {
-                user: 'user',
-                content: { text: 'Show my WZRD positions' },
-            },
-            {
-                user: 'assistant',
-                content: {
-                    text: 'Your WZRD portfolio:\n' +
-                        '• Market #10 (Qwen 2.5 72B): 0.01 USDC, 5.0x multiplier\n' +
-                        '• Market #8 (Ollama): 0.01 USDC, 5.0x multiplier\n' +
-                        'Total: 0.02 USDC deposited, 0 CCM earned',
+                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.',
             },
         ],
     ],
-    validate: async () => true,
-    handler: async (client) => {
-        const portfolio = await client.getPortfolio();
-        const open = portfolio.positions.filter((p) => !p.is_settled);
-        const lines = open.map((p) => `• Market #${p.market_id} (${p.metric}): ` +
-            `${(p.usdc_deposited / 1_000_000).toFixed(4)} USDC, ` +
-            `${(p.multiplier_bps / 10_000).toFixed(1)}x multiplier` +
-            (p.is_settled ? ' [settled]' : ''));
-        const totalUsdc = portfolio.total_deposited_usdc / 1_000_000;
-        const totalCcm = portfolio.total_ccm_earned / 1_000_000;
-        return {
-            success: true,
-            text: `Your WZRD portfolio (${open.length} open positions):\n` +
-                `${lines.length ? lines.join('\n') : '(no positions)'}\n` +
-                `Total: ${totalUsdc.toFixed(4)} USDC deposited, ${totalCcm.toFixed(4)} CCM earned`,
-            data: portfolio,
-        };
-    },
+    schema: portfolioSchema,
+    handler: async (agent, input) => portfolioHandler(agent, portfolioSchema.parse(input)),
 };

package/dist/actions/velocity.d.ts

@@ -12,8 +12,9 @@
  *   COOLING   — p20-40
  *   WEAK      — below p20
  */
-import type { WzrdClient } from '../client.js';
-type SignalTier = 'BREAKOUT' | 'MOMENTUM' | 'EMERGING' | 'STABLE' | 'COOLING' | 'WEAK';
+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;
@@ -22,34 +23,15 @@ export interface MarketSignal {
     signal: SignalTier;
     percentile: number;
 }
-export declare const VELOCITY_ACTION: {
-    name: string;
-    similes: string[];
-    description: string;
-    examples: {
-        user: string;
-        content: {
-            text: string;
-        };
-    }[][];
-    validate: () => Promise<boolean>;
-    handler: (client: WzrdClient, params: {
-        platform?: string;
-        min_signal?: SignalTier;
-    }) => Promise<{
-        success: boolean;
-        text: string;
-        data: {
-            signals: never[];
-            median_velocity?: undefined;
-        };
-    } | {
-        success: boolean;
-        text: string;
-        data: {
-            signals: MarketSignal[];
-            median_velocity: number;
-        };
-    }>;
-};
-export {};
+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

@@ -12,6 +12,66 @@
  *   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'],
@@ -23,78 +83,17 @@ export const VELOCITY_ACTION = {
     examples: [
         [
             {
-                user: 'user',
-                content: { text: 'What markets have breakout velocity?' },
-            },
-            {
-                user: 'assistant',
-                content: {
-                    text: 'BREAKOUT signals:\n' +
-                        '• Qwen 3.5 35B (804K velocity, p95)\n' +
-                        'MOMENTUM signals:\n' +
-                        '• Qwen 3.5 9B (769K velocity, p85)\n' +
-                        '• Qwen 2.5 72B (378K velocity, p72)',
+                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.',
             },
         ],
     ],
-    validate: async () => true,
-    handler: async (client, params) => {
-        const data = await client.getLeaderboard(50, params.platform);
-        const markets = data.markets;
-        if (markets.length === 0) {
-            return { success: true, text: 'No markets found.', data: { signals: [] } };
-        }
-        // Sort by velocity for percentile calculation
-        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),
-            };
-        });
-        // Filter by minimum signal if requested
-        const tierOrder = ['BREAKOUT', 'MOMENTUM', 'EMERGING', 'STABLE', 'COOLING', 'WEAK'];
-        const minIdx = params.min_signal
-            ? tierOrder.indexOf(params.min_signal)
-            : tierOrder.length;
-        const filtered = minIdx < tierOrder.length
-            ? signals.filter((s) => tierOrder.indexOf(s.signal) <= minIdx)
-            : signals;
-        // Group by signal tier
-        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}]`);
-            }
-        }
-        // Median velocity
-        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 },
-        };
-    },
+    schema: velocitySchema,
+    handler: async (agent, input) => velocityHandler(agent, velocitySchema.parse(input)),
 };
 function classify(m, percentile) {
     if (percentile >= 90)
@@ -109,10 +108,3 @@ function classify(m, percentile) {
         return 'COOLING';
     return 'WEAK';
 }
-function formatVelocity(v) {
-    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);
-}

package/dist/client.d.ts

@@ -2,9 +2,16 @@
  * WZRD API client — handles agent auth (Ed25519 challenge/verify),
  * token caching, and all REST calls.
  *
- * Standalone: no framework dependency. Works with any Keypair holder.
+ * Standalone: no framework dependency. Works with a Keypair or any wallet
+ * implementation that supports `publicKey` + `signMessage()`.
  */
-import { Keypair } from '@solana/web3.js';
+import { Keypair, type PublicKey } from '@solana/web3.js';
+export declare const DEFAULT_API_URL = "https://api.twzrd.xyz";
+export interface WzrdSigner {
+    publicKey: PublicKey;
+    signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+    secretKey?: Uint8Array;
+}
 export interface WzrdMarket {
     market_id: number;
     channel_id: string;
@@ -18,6 +25,7 @@ export interface WzrdMarket {
     status: string;
     snapshot_count: number;
     last_scored_at: string;
+    depositable: boolean;
 }
 export interface WzrdLeaderboard {
     markets: WzrdMarket[];
@@ -57,15 +65,20 @@ export interface WzrdClaim {
 export interface WzrdRelayResult {
     root_seq: number;
     cumulative_total: number;
-    tx_sig: string;
+    claimed_total?: number;
+    tx_sig?: string;
+    status?: 'already_claimed';
 }
 export declare class WzrdClient {
-    private readonly keypair;
+    private readonly signer;
     private readonly apiUrl;
     private token;
     private tokenExpiresAt;
-    constructor(keypair: Keypair, apiUrl?: string);
+    constructor(signer: WzrdSigner | Keypair, apiUrl?: string);
     get pubkey(): string;
+    private isWalletSigner;
+    private hasSecretKey;
+    private signAuthMessage;
     private authenticate;
     private getToken;
     private authedFetch;

package/dist/client.js

@@ -2,9 +2,11 @@
  * WZRD API client — handles agent auth (Ed25519 challenge/verify),
  * token caching, and all REST calls.
  *
- * Standalone: no framework dependency. Works with any Keypair holder.
+ * Standalone: no framework dependency. Works with a Keypair or any wallet
+ * implementation that supports `publicKey` + `signMessage()`.
  */
-const DEFAULT_API_URL = 'https://api.twzrd.xyz';
+import { Keypair } from '@solana/web3.js';
+export const DEFAULT_API_URL = 'https://api.twzrd.xyz';
 const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000;
 // ── Base58 encoder (zero-dependency) ────────────────────
 const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
@@ -34,16 +36,32 @@ function toBase58(bytes) {
 }
 // ── Client ──────────────────────────────────────────────
 export class WzrdClient {
-    keypair;
+    signer;
     apiUrl;
     token = null;
     tokenExpiresAt = 0;
-    constructor(keypair, apiUrl = DEFAULT_API_URL) {
-        this.keypair = keypair;
+    constructor(signer, apiUrl = DEFAULT_API_URL) {
+        this.signer = signer;
         this.apiUrl = apiUrl;
     }
     get pubkey() {
-        return this.keypair.publicKey.toBase58();
+        return this.signer.publicKey.toBase58();
+    }
+    isWalletSigner(signer) {
+        return typeof signer.signMessage === 'function';
+    }
+    hasSecretKey(signer) {
+        return signer instanceof Keypair || signer.secretKey instanceof Uint8Array;
+    }
+    async signAuthMessage(message) {
+        if (this.isWalletSigner(this.signer)) {
+            return this.signer.signMessage(message);
+        }
+        if (this.hasSecretKey(this.signer)) {
+            const { default: nacl } = await import('tweetnacl');
+            return nacl.sign.detached(message, this.signer.secretKey);
+        }
+        throw new Error('WzrdClient requires a signer with signMessage() or an Ed25519 secretKey');
     }
     // ── Auth ────────────────────────────────────────────
     async authenticate() {
@@ -54,8 +72,7 @@ export class WzrdClient {
         const { nonce } = (await cr.json());
         // 2. Sign with Ed25519
         const message = `wzrd-agent-auth v1 | wallet:${this.pubkey} | nonce:${nonce}`;
-        const { default: nacl } = await import('tweetnacl');
-        const sig = nacl.sign.detached(new TextEncoder().encode(message), this.keypair.secretKey);
+        const sig = await this.signAuthMessage(new TextEncoder().encode(message));
         // 3. Verify
         const vr = await fetch(`${this.apiUrl}/v1/agent/verify`, {
             method: 'POST',