@wzrd_sol/solana-agent-plugin 0.1.0

package/src/actions/velocity.ts

@@ -0,0 +1,143 @@
+/**
+ * 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 type { WzrdClient, WzrdMarket } from '../client.js';
+
+type SignalTier = 'BREAKOUT' | 'MOMENTUM' | 'EMERGING' | 'STABLE' | 'COOLING' | 'WEAK';
+
+export interface MarketSignal {
+  market_id: number;
+  metric: string;
+  platform: string;
+  velocity_ema: number;
+  signal: SignalTier;
+  percentile: number;
+}
+
+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: [
+    [
+      {
+        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)',
+        },
+      },
+    ],
+  ],
+
+  validate: async () => true,
+
+  handler: async (
+    client: WzrdClient,
+    params: { platform?: string; min_signal?: SignalTier },
+  ) => {
+    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: 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),
+      };
+    });
+
+    // Filter by minimum signal if requested
+    const tierOrder: SignalTier[] = ['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<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}]`,
+        );
+      }
+    }
+
+    // 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 },
+    };
+  },
+};
+
+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';
+}
+
+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);
+}

package/src/client.ts

@@ -0,0 +1,207 @@
+/**
+ * WZRD API client — handles agent auth (Ed25519 challenge/verify),
+ * token caching, and all REST calls.
+ *
+ * Standalone: no framework dependency. Works with any Keypair holder.
+ */
+
+import { Keypair } from '@solana/web3.js';
+
+const DEFAULT_API_URL = 'https://api.twzrd.xyz';
+const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000;
+
+// ── Base58 encoder (zero-dependency) ────────────────────
+
+const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+function toBase58(bytes: Uint8Array): string {
+  const digits = [0];
+  for (const byte of bytes) {
+    let carry = byte;
+    for (let j = 0; j < digits.length; j++) {
+      carry += digits[j] << 8;
+      digits[j] = carry % 58;
+      carry = (carry / 58) | 0;
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = (carry / 58) | 0;
+    }
+  }
+  let out = '';
+  for (const b of bytes) {
+    if (b !== 0) break;
+    out += '1';
+  }
+  for (let i = digits.length - 1; i >= 0; i--) out += B58[digits[i]];
+  return out;
+}
+
+// ── Types ───────────────────────────────────────────────
+
+export interface WzrdMarket {
+  market_id: number;
+  channel_id: string;
+  platform: string;
+  metric: string;
+  velocity_ema: number;
+  multiplier_bps: number;
+  position_count: number;
+  tvl_usdc: number;
+  rank: number;
+  status: string;
+  snapshot_count: number;
+  last_scored_at: string;
+}
+
+export interface WzrdLeaderboard {
+  markets: WzrdMarket[];
+  root: { root_seq: number; root_hash: string; published_slot: number };
+  total_positions: number;
+  total_tvl_usdc: number;
+  total_snapshots: number;
+  updated_at: string;
+}
+
+export interface WzrdPosition {
+  market_id: number;
+  metric: string;
+  usdc_deposited: number;
+  vlofi_minted: number;
+  multiplier_bps: number;
+  status: string;
+  is_settled: boolean;
+}
+
+export interface WzrdPortfolio {
+  positions: WzrdPosition[];
+  total_deposited_usdc: number;
+  total_vlofi: number;
+  total_ccm_earned: number;
+}
+
+export interface WzrdClaim {
+  root_seq: number;
+  cumulative_total: number;
+  claimed_total: number;
+  leaf_index: number;
+  proof: string[];
+  accounts: Record<string, string>;
+}
+
+export interface WzrdRelayResult {
+  root_seq: number;
+  cumulative_total: number;
+  tx_sig: string;
+}
+
+// ── Client ──────────────────────────────────────────────
+
+export class WzrdClient {
+  private token: string | null = null;
+  private tokenExpiresAt = 0;
+
+  constructor(
+    private readonly keypair: Keypair,
+    private readonly apiUrl: string = DEFAULT_API_URL,
+  ) {}
+
+  get pubkey(): string {
+    return this.keypair.publicKey.toBase58();
+  }
+
+  // ── Auth ────────────────────────────────────────────
+
+  private async authenticate(): Promise<void> {
+    // 1. Challenge
+    const cr = await fetch(`${this.apiUrl}/v1/agent/challenge`);
+    if (!cr.ok) throw new Error(`Challenge failed: ${cr.status}`);
+    const { nonce } = (await cr.json()) as { nonce: string };
+
+    // 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,
+    );
+
+    // 3. Verify
+    const vr = await fetch(`${this.apiUrl}/v1/agent/verify`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        pubkey: this.pubkey,
+        nonce,
+        signature: toBase58(sig),
+      }),
+    });
+    if (!vr.ok) throw new Error(`Verify failed: ${vr.status} ${await vr.text()}`);
+
+    const { token, expires_at } = (await vr.json()) as {
+      token: string;
+      expires_at: string;
+    };
+    this.token = token;
+    this.tokenExpiresAt = new Date(expires_at).getTime();
+  }
+
+  private async getToken(): Promise<string> {
+    if (
+      !this.token ||
+      Date.now() > this.tokenExpiresAt - TOKEN_REFRESH_MARGIN_MS
+    ) {
+      await this.authenticate();
+    }
+    return this.token!;
+  }
+
+  private async authedFetch(path: string, init?: RequestInit): Promise<Response> {
+    const token = await this.getToken();
+    return fetch(`${this.apiUrl}${path}`, {
+      ...init,
+      headers: { ...init?.headers, Authorization: `Bearer ${token}` },
+    });
+  }
+
+  // ── Public API ──────────────────────────────────────
+
+  /** Fetch leaderboard — no auth required. */
+  async getLeaderboard(limit = 20, platform?: string): Promise<WzrdLeaderboard> {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (platform) params.set('platform', platform);
+    const res = await fetch(`${this.apiUrl}/v1/leaderboard?${params}`);
+    if (!res.ok) throw new Error(`Leaderboard failed: ${res.status}`);
+    return (await res.json()) as WzrdLeaderboard;
+  }
+
+  /** Fetch authenticated portfolio. */
+  async getPortfolio(): Promise<WzrdPortfolio> {
+    const res = await this.authedFetch('/v1/portfolio');
+    if (!res.ok) throw new Error(`Portfolio failed: ${res.status}`);
+    return (await res.json()) as WzrdPortfolio;
+  }
+
+  /** Fetch claim data (proof + amounts). */
+  async getClaims(): Promise<WzrdClaim> {
+    const res = await this.authedFetch(`/v1/claims/${this.pubkey}`);
+    if (!res.ok) throw new Error(`Claims failed: ${res.status}`);
+    return (await res.json()) as WzrdClaim;
+  }
+
+  /** Execute gasless relay claim — server pays tx fees. */
+  async claimRelay(): Promise<WzrdRelayResult> {
+    const res = await this.authedFetch(`/v1/claims/${this.pubkey}/relay`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+    });
+    if (!res.ok) throw new Error(`Relay claim failed: ${res.status} ${await res.text()}`);
+    return (await res.json()) as WzrdRelayResult;
+  }
+
+  /** Fetch system health — no auth required. */
+  async getHealth(): Promise<Record<string, unknown>> {
+    const res = await fetch(`${this.apiUrl}/health`);
+    if (!res.ok) throw new Error(`Health failed: ${res.status}`);
+    return (await res.json()) as Record<string, unknown>;
+  }
+}

package/src/index.ts

@@ -0,0 +1,64 @@
+/**
+ * @wzrd_sol/solana-agent-plugin
+ *
+ * WZRD Liquid Attention Protocol plugin for autonomous Solana agents.
+ *
+ * 5 actions:
+ *   wzrd_leaderboard — browse attention markets (no auth)
+ *   wzrd_velocity    — classify signal strength (no auth)
+ *   wzrd_portfolio   — view positions + CCM earned (auth)
+ *   wzrd_deposit     — deposit USDC → mint vLOFI (auth + keypair)
+ *   wzrd_claim       — claim CCM via gasless relay (auth)
+ *
+ * Works with:
+ *   - Solana Agent Kit (SendAI) — register as plugin
+ *   - ElizaOS — wrap actions as ElizaOS Actions
+ *   - Standalone — use WzrdClient directly
+ *
+ * Quick start:
+ *   import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
+ *   const client = new WzrdClient(keypair);
+ *   const leaderboard = await client.getLeaderboard();
+ */
+
+export { WzrdClient } from './client.js';
+export type {
+  WzrdMarket,
+  WzrdLeaderboard,
+  WzrdPosition,
+  WzrdPortfolio,
+  WzrdClaim,
+  WzrdRelayResult,
+} from './client.js';
+
+export {
+  LEADERBOARD_ACTION,
+  PORTFOLIO_ACTION,
+  DEPOSIT_ACTION,
+  CLAIM_ACTION,
+  VELOCITY_ACTION,
+} from './actions/index.js';
+
+// ── Convenience: all actions as array ────────────────────
+
+import { LEADERBOARD_ACTION } from './actions/leaderboard.js';
+import { PORTFOLIO_ACTION } from './actions/portfolio.js';
+import { DEPOSIT_ACTION } from './actions/deposit.js';
+import { CLAIM_ACTION } from './actions/claim.js';
+import { VELOCITY_ACTION } from './actions/velocity.js';
+
+export const WZRD_ACTIONS = [
+  LEADERBOARD_ACTION,
+  PORTFOLIO_ACTION,
+  DEPOSIT_ACTION,
+  CLAIM_ACTION,
+  VELOCITY_ACTION,
+] as const;
+
+/** Plugin metadata for framework registration. */
+export const WZRD_PLUGIN = {
+  name: 'wzrd',
+  description: 'WZRD Liquid Attention Protocol — deposit USDC into AI attention markets, earn CCM yield',
+  actions: WZRD_ACTIONS,
+  version: '0.1.0',
+};

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}