@wzrd_sol/solana-agent-plugin 0.1.0

package/dist/actions/velocity.js

@@ -0,0 +1,118 @@
+/**
+ * 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
+ */
+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, 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 },
+        };
+    },
+};
+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';
+}
+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

@@ -0,0 +1,82 @@
+/**
+ * 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';
+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;
+}
+export declare class WzrdClient {
+    private readonly keypair;
+    private readonly apiUrl;
+    private token;
+    private tokenExpiresAt;
+    constructor(keypair: Keypair, apiUrl?: string);
+    get pubkey(): string;
+    private authenticate;
+    private getToken;
+    private authedFetch;
+    /** Fetch leaderboard — no auth required. */
+    getLeaderboard(limit?: number, platform?: string): Promise<WzrdLeaderboard>;
+    /** Fetch authenticated portfolio. */
+    getPortfolio(): Promise<WzrdPortfolio>;
+    /** Fetch claim data (proof + amounts). */
+    getClaims(): Promise<WzrdClaim>;
+    /** Execute gasless relay claim — server pays tx fees. */
+    claimRelay(): Promise<WzrdRelayResult>;
+    /** Fetch system health — no auth required. */
+    getHealth(): Promise<Record<string, unknown>>;
+}

package/dist/client.js

@@ -0,0 +1,131 @@
+/**
+ * WZRD API client — handles agent auth (Ed25519 challenge/verify),
+ * token caching, and all REST calls.
+ *
+ * Standalone: no framework dependency. Works with any Keypair holder.
+ */
+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) {
+    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;
+}
+// ── Client ──────────────────────────────────────────────
+export class WzrdClient {
+    keypair;
+    apiUrl;
+    token = null;
+    tokenExpiresAt = 0;
+    constructor(keypair, apiUrl = DEFAULT_API_URL) {
+        this.keypair = keypair;
+        this.apiUrl = apiUrl;
+    }
+    get pubkey() {
+        return this.keypair.publicKey.toBase58();
+    }
+    // ── Auth ────────────────────────────────────────────
+    async authenticate() {
+        // 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());
+        // 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());
+        this.token = token;
+        this.tokenExpiresAt = new Date(expires_at).getTime();
+    }
+    async getToken() {
+        if (!this.token ||
+            Date.now() > this.tokenExpiresAt - TOKEN_REFRESH_MARGIN_MS) {
+            await this.authenticate();
+        }
+        return this.token;
+    }
+    async authedFetch(path, init) {
+        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) {
+        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());
+    }
+    /** Fetch authenticated portfolio. */
+    async getPortfolio() {
+        const res = await this.authedFetch('/v1/portfolio');
+        if (!res.ok)
+            throw new Error(`Portfolio failed: ${res.status}`);
+        return (await res.json());
+    }
+    /** Fetch claim data (proof + amounts). */
+    async getClaims() {
+        const res = await this.authedFetch(`/v1/claims/${this.pubkey}`);
+        if (!res.ok)
+            throw new Error(`Claims failed: ${res.status}`);
+        return (await res.json());
+    }
+    /** Execute gasless relay claim — server pays tx fees. */
+    async claimRelay() {
+        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());
+    }
+    /** Fetch system health — no auth required. */
+    async getHealth() {
+        const res = await fetch(`${this.apiUrl}/health`);
+        if (!res.ok)
+            throw new Error(`Health failed: ${res.status}`);
+        return (await res.json());
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,297 @@
+/**
+ * @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';
+export declare const WZRD_ACTIONS: readonly [{
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        user: string;
+        content: {
+            text: string;
+        };
+    }[][];
+    validate: () => Promise<boolean>;
+    handler: (client: import("./client.js").WzrdClient, params: {
+        limit?: number;
+        platform?: string;
+    }) => Promise<{
+        success: boolean;
+        text: string;
+        data: import("./client.js").WzrdLeaderboard;
+    }>;
+}, {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        user: string;
+        content: {
+            text: string;
+        };
+    }[][];
+    validate: () => Promise<boolean>;
+    handler: (client: import("./client.js").WzrdClient) => Promise<{
+        success: boolean;
+        text: string;
+        data: import("./client.js").WzrdPortfolio;
+    }>;
+}, {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        user: string;
+        content: {
+            text: string;
+        };
+    }[][];
+    validate: (_client: import("./client.js").WzrdClient, params: import("./actions/deposit.js").DepositParams) => Promise<boolean>;
+    handler: (_client: import("./client.js").WzrdClient, params: import("./actions/deposit.js").DepositParams, connection: import("@solana/web3.js").Connection, wallet: import("@solana/web3.js").Keypair) => Promise<{
+        success: boolean;
+        text: string;
+        data?: undefined;
+    } | {
+        success: boolean;
+        text: string;
+        data: {
+            logs: string[] | undefined;
+            signature?: undefined;
+            market_id?: undefined;
+            amount_usdc?: undefined;
+            cu_used?: undefined;
+            elapsed_ms?: undefined;
+            explorer?: undefined;
+        };
+    } | {
+        success: boolean;
+        text: string;
+        data: {
+            signature: string;
+            market_id: number;
+            amount_usdc: number;
+            cu_used: number | undefined;
+            elapsed_ms: number;
+            explorer: string;
+            logs?: undefined;
+        };
+    }>;
+}, {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        user: string;
+        content: {
+            text: string;
+        };
+    }[][];
+    validate: () => Promise<boolean>;
+    handler: (client: import("./client.js").WzrdClient, params: {
+        execute?: boolean;
+    }) => Promise<{
+        success: boolean;
+        text: string;
+        data: import("./client.js").WzrdClaim;
+    } | {
+        success: boolean;
+        text: string;
+        data: {
+            claimable_before: number;
+            explorer: string;
+            root_seq: number;
+            cumulative_total: number;
+            tx_sig: string;
+        };
+    }>;
+}, {
+    name: string;
+    similes: string[];
+    description: string;
+    examples: {
+        user: string;
+        content: {
+            text: string;
+        };
+    }[][];
+    validate: () => Promise<boolean>;
+    handler: (client: import("./client.js").WzrdClient, params: {
+        platform?: string;
+        min_signal?: "BREAKOUT" | "MOMENTUM" | "EMERGING" | "STABLE" | "COOLING" | "WEAK";
+    }) => Promise<{
+        success: boolean;
+        text: string;
+        data: {
+            signals: never[];
+            median_velocity?: undefined;
+        };
+    } | {
+        success: boolean;
+        text: string;
+        data: {
+            signals: import("./actions/velocity.js").MarketSignal[];
+            median_velocity: number;
+        };
+    }>;
+}];
+/** Plugin metadata for framework registration. */
+export declare const WZRD_PLUGIN: {
+    name: string;
+    description: string;
+    actions: readonly [{
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            user: string;
+            content: {
+                text: string;
+            };
+        }[][];
+        validate: () => Promise<boolean>;
+        handler: (client: import("./client.js").WzrdClient, params: {
+            limit?: number;
+            platform?: string;
+        }) => Promise<{
+            success: boolean;
+            text: string;
+            data: import("./client.js").WzrdLeaderboard;
+        }>;
+    }, {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            user: string;
+            content: {
+                text: string;
+            };
+        }[][];
+        validate: () => Promise<boolean>;
+        handler: (client: import("./client.js").WzrdClient) => Promise<{
+            success: boolean;
+            text: string;
+            data: import("./client.js").WzrdPortfolio;
+        }>;
+    }, {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            user: string;
+            content: {
+                text: string;
+            };
+        }[][];
+        validate: (_client: import("./client.js").WzrdClient, params: import("./actions/deposit.js").DepositParams) => Promise<boolean>;
+        handler: (_client: import("./client.js").WzrdClient, params: import("./actions/deposit.js").DepositParams, connection: import("@solana/web3.js").Connection, wallet: import("@solana/web3.js").Keypair) => Promise<{
+            success: boolean;
+            text: string;
+            data?: undefined;
+        } | {
+            success: boolean;
+            text: string;
+            data: {
+                logs: string[] | undefined;
+                signature?: undefined;
+                market_id?: undefined;
+                amount_usdc?: undefined;
+                cu_used?: undefined;
+                elapsed_ms?: undefined;
+                explorer?: undefined;
+            };
+        } | {
+            success: boolean;
+            text: string;
+            data: {
+                signature: string;
+                market_id: number;
+                amount_usdc: number;
+                cu_used: number | undefined;
+                elapsed_ms: number;
+                explorer: string;
+                logs?: undefined;
+            };
+        }>;
+    }, {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            user: string;
+            content: {
+                text: string;
+            };
+        }[][];
+        validate: () => Promise<boolean>;
+        handler: (client: import("./client.js").WzrdClient, params: {
+            execute?: boolean;
+        }) => Promise<{
+            success: boolean;
+            text: string;
+            data: import("./client.js").WzrdClaim;
+        } | {
+            success: boolean;
+            text: string;
+            data: {
+                claimable_before: number;
+                explorer: string;
+                root_seq: number;
+                cumulative_total: number;
+                tx_sig: string;
+            };
+        }>;
+    }, {
+        name: string;
+        similes: string[];
+        description: string;
+        examples: {
+            user: string;
+            content: {
+                text: string;
+            };
+        }[][];
+        validate: () => Promise<boolean>;
+        handler: (client: import("./client.js").WzrdClient, params: {
+            platform?: string;
+            min_signal?: "BREAKOUT" | "MOMENTUM" | "EMERGING" | "STABLE" | "COOLING" | "WEAK";
+        }) => Promise<{
+            success: boolean;
+            text: string;
+            data: {
+                signals: never[];
+                median_velocity?: undefined;
+            };
+        } | {
+            success: boolean;
+            text: string;
+            data: {
+                signals: import("./actions/velocity.js").MarketSignal[];
+                median_velocity: number;
+            };
+        }>;
+    }];
+    version: string;
+};

package/dist/index.js

@@ -0,0 +1,44 @@
+/**
+ * @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 { 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,
+];
+/** 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',
+};