@wzrd_sol/eliza-plugin 0.1.2 → 0.2.0

package/dist/actions/claim.d.ts

@@ -1,9 +1,6 @@
 /**
- * ELIZA Action: WZRD_CLAIM — claim accrued CCM via gasless relay (auth).
- *
- * Agents can check current APR before deciding whether to claim or hold:
- *   WzrdClient.getMarketApr(marketId) — projected_total_apr_bps shows current yield rate.
- *   WzrdClient.getMarketPreview(marketId) — projected_multiplier_bps for live attention signal.
+ * WZRD_CLAIM — Claim accrued CCM via gasless relay.
+ * Server pays all transaction fees. Agent needs 0 SOL.
  */
 import type { Action } from '@elizaos/core';
 export declare const claimAction: Action;

package/dist/actions/claim.js

@@ -1,45 +1,48 @@
-import { getWzrdClient } from '../client.js';
+import { getWzrdClient } from '../client-factory.js';
 export const claimAction = {
     name: 'WZRD_CLAIM',
-    similes: ['WZRD_HARVEST', 'CLAIM_CCM', 'COLLECT_YIELD'],
-    description: 'Claim accrued CCM tokens via gasless relay. Server pays tx fees.',
-    examples: [[
+    similes: ['WZRD_HARVEST', 'CLAIM_CCM', 'COLLECT_REWARDS'],
+    description: 'Claim accrued CCM tokens via gasless relay. Server pays tx fees — agent needs 0 SOL.',
+    examples: [
+        [
             { name: '{{user1}}', content: { text: 'Claim my WZRD rewards' } },
-            { name: '{{agentName}}', content: { text: 'Claimed CCM via gasless relay. Tx: 5S7L...' } },
-        ]],
+            { name: '{{agentName}}', content: { text: 'Claimed 142.5 CCM via gasless relay. Tx: 5S7L...' } },
+        ],
+    ],
     validate: async () => true,
     handler: async (runtime, _msg, _state, _opt, callback) => {
         const client = getWzrdClient(runtime);
-        let claims;
         try {
-            claims = await client.getClaims();
+            // Check if there's anything to claim
+            const status = await client.getClaimStatus();
+            if (status.claimable <= 0) {
+                const text = `No CCM to claim right now.\n` +
+                    `Cumulative: ${(status.cumulative_total / 1e9).toFixed(2)} CCM\n` +
+                    `Already claimed: ${(status.claimed_total / 1e9).toFixed(2)} CCM\n` +
+                    `Run WZRD_EARN first to accrue rewards.`;
+                await callback?.({ text });
+                return { success: true, data: status };
+            }
+            const result = await client.claimRelay();
+            if (result.status === 'already_claimed') {
+                await callback?.({ text: `Already claimed through root ${result.root_seq}.` });
+                return { success: true, data: result };
+            }
+            const text = `Claimed CCM via gasless relay.\n` +
+                `Amount: ${(result.cumulative_total / 1e9).toFixed(2)} CCM (cumulative)\n` +
+                `Root: ${result.root_seq}\n` +
+                `Tx: ${result.tx_sig?.slice(0, 20)}...`;
+            await callback?.({ text });
+            return { success: true, data: result };
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             if (msg.includes('404')) {
-                const text = 'No claims found. Deposit into a market first to start accruing CCM.';
-                await callback?.({ text });
-                return { success: true, text };
+                await callback?.({ text: 'No claims found yet. Run WZRD_EARN to start accruing CCM.' });
+                return { success: true, data: {} };
             }
-            const text = `Failed to fetch claims: ${msg}`;
-            await callback?.({ text });
-            return { success: false, error: text };
-        }
-        const claimable = claims.cumulative_total - claims.claimed_total;
-        if (claimable <= 0) {
-            const text = `No CCM to claim. Cumulative: ${claims.cumulative_total}, claimed: ${claims.claimed_total}.`;
-            await callback?.({ text });
-            return { success: true, text, data: claims };
-        }
-        const result = await client.claimRelay();
-        if (result.status === 'already_claimed') {
-            const text = `Already claimed through root ${result.root_seq}.`;
-            await callback?.({ text });
-            return { success: true, text, data: result };
+            await callback?.({ text: `Claim failed: ${msg}` });
+            return { success: false, error: msg };
         }
-        const text = `Claimed CCM via relay. Cumulative: ${(result.cumulative_total / 1e6).toFixed(4)} CCM. ` +
-            `Root: ${result.root_seq}. Tx: ${result.tx_sig?.slice(0, 16)}...`;
-        await callback?.({ text });
-        return { success: true, text, data: result };
     },
 };

package/dist/actions/earn.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WZRD_EARN — Full earn cycle: infer → report → check rewards.
+ *
+ * Single action that runs the complete server-witnessed earn loop.
+ * For agents that want one-shot earning without managing execution_ids.
+ */
+import type { Action } from '@elizaos/core';
+export declare const earnAction: Action;

package/dist/actions/earn.js

@@ -0,0 +1,83 @@
+import { getWzrdClient } from '../client-factory.js';
+const EVAL_PROMPTS = {
+    code: [
+        'Write a Python function that checks if a binary tree is balanced. Include time complexity analysis.',
+        'Implement a thread-safe LRU cache in Rust with O(1) get and put operations.',
+        'Write a TypeScript generic function that deep-merges two objects, handling arrays and nested objects.',
+    ],
+    chat: [
+        'Explain the difference between TCP and UDP to someone who has never programmed before.',
+        'What are the tradeoffs between microservices and monolithic architecture?',
+        'Describe how consensus works in proof-of-stake blockchains.',
+    ],
+    reasoning: [
+        'A farmer has a fox, a chicken, and a bag of grain. He must cross a river in a boat that can only carry him and one item. How does he do it?',
+        'If it takes 5 machines 5 minutes to make 5 widgets, how long does it take 100 machines to make 100 widgets?',
+        'Three people check into a hotel room that costs $30. They each pay $10. The manager realizes the room should cost $25 and gives $5 to the bellboy to return. The bellboy keeps $2 and gives $1 back to each person. So each person paid $9 (total $27) plus the bellboy kept $2 (total $29). Where is the missing dollar?',
+    ],
+};
+function pickPrompt(taskType) {
+    const prompts = EVAL_PROMPTS[taskType] || EVAL_PROMPTS.chat;
+    return prompts[Math.floor(Math.random() * prompts.length)];
+}
+export const earnAction = {
+    name: 'WZRD_EARN',
+    similes: ['WZRD_EARN_CCM', 'EARN_REWARDS', 'RUN_EARN_LOOP'],
+    description: 'Run the full WZRD earn cycle: pick a prompt, run server-witnessed inference, ' +
+        'report the outcome, and check pending rewards. One action, complete loop.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Earn some CCM on WZRD' } },
+            {
+                name: '{{agentName}}',
+                content: {
+                    text: 'Earn cycle complete. Model: gemini-2.5-flash, quality: 0.85, verified. Pending: 142.5 CCM.',
+                },
+            },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = message.content;
+        const taskType = content.task_type || 'code';
+        const prompt = content.prompt || pickPrompt(taskType);
+        const client = getWzrdClient(runtime);
+        const steps = [];
+        try {
+            // Step 1: Pick model + Infer
+            steps.push('→ Picking model from leaderboard...');
+            const model = await client.pickModel(taskType);
+            steps.push(`→ Running inference: ${model} (${taskType})...`);
+            const infer = await client.infer(prompt, model, taskType);
+            steps.push(`✓ Inference: ${infer.executed_model} (${infer.provider}), quality ${infer.quality_score.toFixed(2)}, ${infer.latency_ms}ms`);
+            // Step 2: Report with execution_id
+            steps.push('→ Reporting outcome...');
+            const report = await client.report({
+                model_id: infer.requested_model,
+                execution_id: infer.execution_id,
+                task_type: taskType,
+                quality_score: infer.quality_score,
+                latency_ms: infer.latency_ms,
+            });
+            steps.push(`✓ Reported: ${report.verification_state}, contribution #${report.contribution_id}, pending ${(report.pending_ccm / 1e9).toFixed(2)} CCM`);
+            // Step 3: Check rewards
+            steps.push('→ Checking rewards...');
+            const rewards = await client.getRewards();
+            steps.push(`✓ Rewards: ${(rewards.pending_ccm / 1e9).toFixed(2)} CCM pending, ` +
+                `${(rewards.total_rewarded_ccm / 1e9).toFixed(2)} CCM lifetime` +
+                (rewards.rank ? `, rank #${rewards.rank}` : ''));
+            const text = `Earn cycle complete:\n${steps.join('\n')}`;
+            await callback?.({ text });
+            return {
+                success: true,
+                data: { infer, report, rewards },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            steps.push(`✗ Failed: ${msg}`);
+            await callback?.({ text: `Earn cycle failed:\n${steps.join('\n')}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/infer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WZRD_INFER — Server-witnessed inference through WZRD.
+ *
+ * WZRD calls the AI provider (Gemini/Nous/OpenRouter), grades the response,
+ * and returns an execution_id receipt. Pass this to WZRD_REPORT for verified rewards.
+ */
+import type { Action } from '@elizaos/core';
+export declare const inferAction: Action;

package/dist/actions/infer.js

@@ -0,0 +1,41 @@
+import { getWzrdClient } from '../client-factory.js';
+export const inferAction = {
+    name: 'WZRD_INFER',
+    similes: ['WZRD_RUN_INFERENCE', 'ASK_MODEL', 'RUN_MODEL'],
+    description: 'Run inference through WZRD. The server calls the AI provider, grades quality, ' +
+        'and returns an execution receipt. Use the execution_id with WZRD_REPORT to earn CCM.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Run inference through WZRD: explain quicksort in Python' } },
+            { name: '{{agentName}}', content: { text: 'Inference complete. Model: gemini-2.5-flash, quality: 0.85. execution_id: abc-123...' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = message.content;
+        const prompt = content.prompt || content.text || '';
+        if (!prompt) {
+            await callback?.({ text: 'No prompt provided. Include a prompt or text to run inference.' });
+            return { success: false, error: 'No prompt' };
+        }
+        const taskType = content.task_type || 'chat';
+        const model = content.model;
+        const client = getWzrdClient(runtime);
+        try {
+            const result = await client.infer(prompt, model, taskType);
+            const text = `Inference complete.\n` +
+                `Model: ${result.executed_model} (${result.provider})\n` +
+                `Quality: ${result.quality_score.toFixed(2)}\n` +
+                `Latency: ${result.latency_ms}ms\n` +
+                `execution_id: ${result.execution_id}\n\n` +
+                `Response: ${result.response_preview}`;
+            await callback?.({ text });
+            return { success: true, data: result };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Inference failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/report.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WZRD_REPORT — Report a model pick with execution receipt for verified CCM rewards.
+ *
+ * Must be called after WZRD_INFER. Pass the execution_id from the infer result
+ * to get server-verified status and quality-weighted rewards.
+ */
+import type { Action } from '@elizaos/core';
+export declare const reportAction: Action;

package/dist/actions/report.js

@@ -0,0 +1,45 @@
+import { getWzrdClient } from '../client-factory.js';
+export const reportAction = {
+    name: 'WZRD_REPORT',
+    similes: ['WZRD_REPORT_OUTCOME', 'REPORT_MODEL_PICK', 'SUBMIT_SIGNAL'],
+    description: 'Report a model pick to WZRD with an execution_id from WZRD_INFER. ' +
+        'Verified reports earn CCM rewards with quality multiplier.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'Report the inference result to earn CCM' } },
+            { name: '{{agentName}}', content: { text: 'Reported. Verification: verified, contribution #4521.' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, message, _state, _opt, callback) => {
+        const content = message.content;
+        if (!content.execution_id || !content.model_id) {
+            await callback?.({
+                text: 'Missing required: execution_id and model_id. Run WZRD_INFER first to get an execution receipt.',
+            });
+            return { success: false, error: 'Missing execution_id or model_id' };
+        }
+        const client = getWzrdClient(runtime);
+        try {
+            const result = await client.report({
+                model_id: content.model_id,
+                execution_id: content.execution_id,
+                task_type: content.task_type,
+                quality_score: content.quality_score,
+                latency_ms: content.latency_ms,
+            });
+            const text = `Reported to WZRD.\n` +
+                `Verification: ${result.verification_state}\n` +
+                `Contribution: #${result.contribution_id}\n` +
+                `Pending CCM: ${(result.pending_ccm / 1e9).toFixed(2)}\n` +
+                `Pipeline: ${result.pipeline_state}`;
+            await callback?.({ text });
+            return { success: true, data: result };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Report failed: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/actions/rewards.d.ts

@@ -0,0 +1,5 @@
+/**
+ * WZRD_REWARDS — Check pending and lifetime CCM rewards.
+ */
+import type { Action } from '@elizaos/core';
+export declare const rewardsAction: Action;

package/dist/actions/rewards.js

@@ -0,0 +1,31 @@
+import { getWzrdClient } from '../client-factory.js';
+export const rewardsAction = {
+    name: 'WZRD_REWARDS',
+    similes: ['WZRD_BALANCE', 'CHECK_REWARDS', 'MY_CCM'],
+    description: 'Check your pending CCM rewards, lifetime total, rank, and contribution count.',
+    examples: [
+        [
+            { name: '{{user1}}', content: { text: 'How much CCM have I earned?' } },
+            { name: '{{agentName}}', content: { text: 'Pending: 142.5 CCM. Lifetime: 326,000 CCM. Rank #3.' } },
+        ],
+    ],
+    validate: async () => true,
+    handler: async (runtime, _msg, _state, _opt, callback) => {
+        const client = getWzrdClient(runtime);
+        try {
+            const rewards = await client.getRewards();
+            const text = `WZRD Rewards:\n` +
+                `Pending: ${(rewards.pending_ccm / 1e9).toFixed(2)} CCM\n` +
+                `Lifetime: ${(rewards.total_rewarded_ccm / 1e9).toFixed(2)} CCM\n` +
+                `Contributions: ${rewards.contribution_count}\n` +
+                (rewards.rank ? `Rank: #${rewards.rank}` : 'Rank: unranked');
+            await callback?.({ text });
+            return { success: true, data: rewards };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            await callback?.({ text: `Failed to fetch rewards: ${msg}` });
+            return { success: false, error: msg };
+        }
+    },
+};

package/dist/client-factory.d.ts

@@ -0,0 +1,5 @@
+import { WzrdClient } from './client.js';
+import type { IAgentRuntime } from '@elizaos/core';
+export declare function getWzrdClient(runtime: IAgentRuntime): WzrdClient;
+/** Reset client cache — useful for tests. */
+export declare function clearClientCache(): void;

package/dist/client-factory.js

@@ -0,0 +1,20 @@
+/** Extract keypair from ElizaOS runtime, return cached WzrdClient. */
+import { Keypair } from '@solana/web3.js';
+import { WzrdClient } from './client.js';
+const cache = new Map();
+export function getWzrdClient(runtime) {
+    const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
+    if (!sk)
+        throw new Error('SOLANA_PRIVATE_KEY not configured in ElizaOS runtime');
+    const kp = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(String(sk))));
+    const pub = kp.publicKey.toBase58();
+    if (!cache.has(pub)) {
+        const apiUrl = runtime.getSetting('WZRD_API_URL');
+        cache.set(pub, new WzrdClient(kp, typeof apiUrl === 'string' ? apiUrl : undefined));
+    }
+    return cache.get(pub);
+}
+/** Reset client cache — useful for tests. */
+export function clearClientCache() {
+    cache.clear();
+}

package/dist/client.d.ts

@@ -1,3 +1,90 @@
-import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
-import type { IAgentRuntime } from '@elizaos/core';
-export declare function getWzrdClient(runtime: IAgentRuntime): WzrdClient;
+/**
+ * Standalone WZRD API client for ElizaOS agents.
+ * No external dependencies beyond @solana/web3.js for Ed25519 signing.
+ *
+ * Auth flow: challenge → sign → verify → Bearer token (24h TTL)
+ * Earn flow: infer → report(execution_id) → claim
+ */
+import { Keypair } from '@solana/web3.js';
+export interface InferResult {
+    execution_id: string;
+    executed_model: string;
+    requested_model: string;
+    provider: string;
+    quality_score: number;
+    response_preview: string;
+    latency_ms: number;
+    cost_usd?: number;
+}
+export interface ReportResult {
+    contribution_id: number;
+    verification_state: string;
+    lifetime_contributions: number;
+    pending_ccm: number;
+    pipeline_state: string;
+    idempotent: boolean;
+    provider_receipt_present: boolean;
+}
+export interface RewardsBalance {
+    pending_ccm: number;
+    total_rewarded_ccm: number;
+    rank: number | null;
+    contribution_count: number;
+}
+export interface ClaimResult {
+    tx_sig: string | null;
+    root_seq: number;
+    cumulative_total: number;
+    status: string;
+}
+export interface LeaderboardResult {
+    market_count: number;
+    total_tvl: number;
+    root: {
+        root_seq: number;
+    };
+    markets: Array<{
+        market_id: number;
+        metric: string;
+        platform: string;
+        velocity_ema: number;
+        multiplier_bps: number;
+        snapshot_count: number;
+    }>;
+}
+export declare class WzrdClient {
+    private keypair;
+    private apiUrl;
+    private token;
+    private tokenExpiry;
+    constructor(keypair: Keypair, apiUrl?: string);
+    get pubkey(): string;
+    /** Ed25519 challenge → sign → verify → Bearer token */
+    private authenticate;
+    /** Authenticated fetch helper */
+    private authedFetch;
+    /** Pick a model from the momentum signal — returns top model's channel_id */
+    pickModel(taskType?: string): Promise<string>;
+    /** Server-witnessed inference — WZRD calls the provider, grades quality */
+    infer(prompt: string, model?: string, taskType?: string): Promise<InferResult>;
+    /** Report model pick with execution_id for verified rewards */
+    report(params: {
+        model_id: string;
+        execution_id: string;
+        task_type?: string;
+        quality_score?: number;
+        latency_ms?: number;
+    }): Promise<ReportResult>;
+    /** Check pending + total rewards (flattens nested /v1/agent/earned response) */
+    getRewards(): Promise<RewardsBalance>;
+    /** Gasless CCM claim via server relay */
+    claimRelay(): Promise<ClaimResult>;
+    /** Public: fetch leaderboard (no auth) */
+    getLeaderboard(limit?: number): Promise<LeaderboardResult>;
+    /** Public: fetch claims status */
+    getClaimStatus(): Promise<{
+        cumulative_total: number;
+        claimed_total: number;
+        claimable: number;
+    }>;
+}

package/dist/client.js

@@ -1,17 +1,134 @@
-/** Shared helper: extract wallet from ELIZA runtime, return cached WzrdClient. */
-import { Keypair } from '@solana/web3.js';
-import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
-const DEFAULT_API_URL = 'https://api.twzrd.xyz';
-const cache = new Map();
-export function getWzrdClient(runtime) {
-    const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
-    if (!sk)
-        throw new Error('SOLANA_PRIVATE_KEY not configured in ELIZA runtime');
-    const kp = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(String(sk))));
-    const pub = kp.publicKey.toBase58();
-    if (!cache.has(pub)) {
-        const apiUrl = runtime.getSetting('WZRD_API_URL');
-        cache.set(pub, new WzrdClient(kp, (typeof apiUrl === 'string' ? apiUrl : undefined) || DEFAULT_API_URL));
-    }
-    return cache.get(pub);
+import nacl from 'tweetnacl';
+import bs58 from 'bs58';
+const DEFAULT_API = 'https://api.twzrd.xyz';
+export class WzrdClient {
+    keypair;
+    apiUrl;
+    token = null;
+    tokenExpiry = 0;
+    constructor(keypair, apiUrl) {
+        this.keypair = keypair;
+        this.apiUrl = apiUrl || DEFAULT_API;
+    }
+    get pubkey() {
+        return this.keypair.publicKey.toBase58();
+    }
+    /** Ed25519 challenge → sign → verify → Bearer token */
+    async authenticate() {
+        if (this.token && Date.now() < this.tokenExpiry)
+            return this.token;
+        // 1. Get challenge
+        const challengeRes = await fetch(`${this.apiUrl}/v1/agent/challenge?pubkey=${this.pubkey}`);
+        if (!challengeRes.ok)
+            throw new Error(`Challenge failed: ${challengeRes.status}`);
+        const { nonce } = await challengeRes.json();
+        // 2. Construct message locally (must match server's agent_auth_message format)
+        const message = `wzrd-agent-auth v1 | wallet:${this.pubkey} | nonce:${nonce}`;
+        const messageBytes = new TextEncoder().encode(message);
+        const signature = nacl.sign.detached(messageBytes, this.keypair.secretKey);
+        // 3. Verify — signature must be base58-encoded (Solana Signature format)
+        const verifyRes = await fetch(`${this.apiUrl}/v1/agent/verify`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                pubkey: this.pubkey,
+                nonce,
+                signature: bs58.encode(signature),
+            }),
+        });
+        if (!verifyRes.ok)
+            throw new Error(`Verify failed: ${verifyRes.status}`);
+        const { token } = await verifyRes.json();
+        this.token = token;
+        this.tokenExpiry = Date.now() + 23 * 60 * 60 * 1000; // refresh 1h before 24h expiry
+        return token;
+    }
+    /** Authenticated fetch helper */
+    async authedFetch(path, init) {
+        const token = await this.authenticate();
+        const headers = new Headers(init?.headers);
+        headers.set('Authorization', `Bearer ${token}`);
+        headers.set('Content-Type', 'application/json');
+        return fetch(`${this.apiUrl}${path}`, { ...init, headers });
+    }
+    /** Pick a model from the momentum signal — returns top model's channel_id */
+    async pickModel(taskType) {
+        const res = await fetch(`${this.apiUrl}/v1/signals/momentum?limit=10&trending=true`);
+        if (!res.ok)
+            throw new Error(`Momentum fetch failed: ${res.status}`);
+        const data = await res.json();
+        if (!data.models?.length)
+            throw new Error('No models available in momentum feed');
+        // Return the top-ranked model's channel_id (e.g. "moonshotai/Kimi-K2.5")
+        return data.models[0].model;
+    }
+    /** Server-witnessed inference — WZRD calls the provider, grades quality */
+    async infer(prompt, model, taskType) {
+        const resolvedModel = model || await this.pickModel(taskType);
+        const res = await this.authedFetch('/v1/agent/infer', {
+            method: 'POST',
+            body: JSON.stringify({ model: resolvedModel, prompt, task_type: taskType || 'chat' }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Infer failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Report model pick with execution_id for verified rewards */
+    async report(params) {
+        const res = await this.authedFetch('/v1/agent/report', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Report failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Check pending + total rewards (flattens nested /v1/agent/earned response) */
+    async getRewards() {
+        const res = await this.authedFetch('/v1/agent/earned');
+        if (!res.ok)
+            throw new Error(`Rewards check failed: ${res.status}`);
+        const data = await res.json();
+        const economy = data.economy;
+        const routing = data.routing;
+        return {
+            pending_ccm: Number(economy?.pending_ccm ?? 0),
+            total_rewarded_ccm: Number(economy?.earned_ccm ?? 0),
+            rank: null, // rank not in this endpoint
+            contribution_count: Number(routing?.lifetime_contributions ?? 0),
+        };
+    }
+    /** Gasless CCM claim via server relay */
+    async claimRelay() {
+        const res = await this.authedFetch(`/v1/claims/${this.pubkey}/relay`, {
+            method: 'POST',
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Claim relay failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Public: fetch leaderboard (no auth) */
+    async getLeaderboard(limit = 20) {
+        const res = await fetch(`${this.apiUrl}/v1/leaderboard?limit=${limit}`);
+        if (!res.ok)
+            throw new Error(`Leaderboard failed: ${res.status}`);
+        return res.json();
+    }
+    /** Public: fetch claims status */
+    async getClaimStatus() {
+        const res = await this.authedFetch(`/v1/claims/${this.pubkey}`);
+        if (!res.ok) {
+            if (res.status === 404)
+                return { cumulative_total: 0, claimed_total: 0, claimable: 0 };
+            throw new Error(`Claim status failed: ${res.status}`);
+        }
+        const data = await res.json();
+        return { ...data, claimable: data.cumulative_total - data.claimed_total };
+    }
 }

package/dist/index.d.ts

@@ -1,16 +1,22 @@
 /**
- * @wzrd_sol/eliza-plugin — WZRD Liquid Attention Protocol for ElizaOS.
- * Thin adapter wrapping @wzrd_sol/solana-agent-plugin's WzrdClient.
+ * @wzrd_sol/eliza-plugin — WZRD Earn Loop for ElizaOS
  *
- * Config (runtime.getSetting): SOLANA_PRIVATE_KEY (required), WZRD_API_URL, SOLANA_RPC_URL
+ * Server-witnessed inference: infer → report → earn CCM → claim.
+ * No external dependencies beyond @solana/web3.js + tweetnacl.
+ *
+ * Config (runtime.getSetting):
+ *   SOLANA_PRIVATE_KEY  — required, JSON array of secret key bytes
+ *   WZRD_API_URL        — optional, defaults to https://api.twzrd.xyz
  */
 import type { Plugin } from '@elizaos/core';
-import { leaderboardAction } from './actions/leaderboard.js';
-import { portfolioAction } from './actions/portfolio.js';
+import { inferAction } from './actions/infer.js';
+import { reportAction } from './actions/report.js';
+import { earnAction } from './actions/earn.js';
 import { claimAction } from './actions/claim.js';
-import { depositAction } from './actions/deposit.js';
-import { velocityAction } from './actions/velocity.js';
+import { rewardsAction } from './actions/rewards.js';
 export declare const wzrdPlugin: Plugin;
 export default wzrdPlugin;
-export { leaderboardAction, portfolioAction, claimAction, depositAction, velocityAction };
-export { getWzrdClient } from './client.js';
+export { earnAction, inferAction, reportAction, claimAction, rewardsAction };
+export { getWzrdClient, clearClientCache } from './client-factory.js';
+export { WzrdClient } from './client.js';
+export type { InferResult, ReportResult, RewardsBalance, ClaimResult } from './client.js';

package/dist/index.js

@@ -1,14 +1,15 @@
-import { leaderboardAction } from './actions/leaderboard.js';
-import { portfolioAction } from './actions/portfolio.js';
+import { inferAction } from './actions/infer.js';
+import { reportAction } from './actions/report.js';
+import { earnAction } from './actions/earn.js';
 import { claimAction } from './actions/claim.js';
-import { depositAction } from './actions/deposit.js';
-import { velocityAction } from './actions/velocity.js';
+import { rewardsAction } from './actions/rewards.js';
 export const wzrdPlugin = {
     name: 'wzrd',
-    description: 'WZRD Liquid Attention Protocol — deposit USDC into AI attention markets, ' +
-        'earn CCM yield based on model velocity.',
-    actions: [leaderboardAction, portfolioAction, claimAction, depositAction, velocityAction],
+    description: 'WZRD Liquid Attention Protocol — earn CCM on Solana via server-witnessed inference. ' +
+        'Infer through WZRD, report outcomes, claim rewards via gasless relay.',
+    actions: [earnAction, inferAction, reportAction, claimAction, rewardsAction],
 };
 export default wzrdPlugin;
-export { leaderboardAction, portfolioAction, claimAction, depositAction, velocityAction };
-export { getWzrdClient } from './client.js';
+export { earnAction, inferAction, reportAction, claimAction, rewardsAction };
+export { getWzrdClient, clearClientCache } from './client-factory.js';
+export { WzrdClient } from './client.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wzrd_sol/eliza-plugin",
-  "version": "0.1.2",
-  "description": "WZRD Liquid Attention Protocol plugin for ElizaOS — leaderboard, portfolio, deposit, claim, velocity",
+  "version": "0.2.0",
+  "description": "WZRD earn loop for ElizaOS — server-witnessed inference, verified CCM rewards, gasless claims",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,12 +14,13 @@
   },
   "scripts": {
     "build": "tsc",
+    "test": "node --test dist/test/*.js",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@wzrd_sol/solana-agent-plugin": "^0.1.0",
-    "@wzrd_sol/sdk": "^0.1.1",
-    "@solana/web3.js": "^1.95.0"
+    "@solana/web3.js": "^1.95.0",
+    "bs58": "^5.0.0",
+    "tweetnacl": "^1.0.3"
   },
   "peerDependencies": {
     "@elizaos/core": "^1.0.0"
@@ -38,9 +39,11 @@
     "eliza",
     "elizaos",
     "wzrd",
-    "attention",
-    "defi",
-    "ai-agent"
+    "ccm",
+    "inference",
+    "earn",
+    "ai-agent",
+    "mcp"
   ],
   "license": "MIT",
   "publishConfig": {
@@ -48,7 +51,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/twzrd-sol/wzrd-final.git",
+    "url": "git+https://github.com/twzrd-sol/wzrd-velocity.git",
     "directory": "agents/eliza-plugin"
   },
   "files": [

package/dist/actions/deposit.d.ts

@@ -1,2 +0,0 @@
-import type { Action } from '@elizaos/core';
-export declare const depositAction: Action;

package/dist/actions/deposit.js

@@ -1,79 +0,0 @@
-/**
- * ELIZA Action: WZRD_DEPOSIT — deposit USDC into attention market, mint vLOFI (auth + keypair).
- *
- * Before depositing, agents can check expected returns via the APR endpoint:
- *   GET /v1/markets/:id/apr  — returns base_apr_bps, attention_multiplier_bps,
- *                              projected_total_apr_bps, tvl_usdc, and the yield formula.
- *   GET /v1/markets/:id/preview — returns projected_multiplier_bps and freshness_secs
- *                                  for a live multiplier snapshot before committing capital.
- * Use WzrdClient.getMarketApr(marketId) or WzrdClient.getMarketPreview(marketId).
- */
-import { Keypair, ComputeBudgetProgram, TransactionMessage, VersionedTransaction, Connection } from '@solana/web3.js';
-export const depositAction = {
-    name: 'WZRD_DEPOSIT',
-    similes: ['DEPOSIT_USDC', 'BUY_ATTENTION', 'ENTER_MARKET'],
-    description: 'Deposit USDC into a WZRD attention market to mint vLOFI. Requires market_id and amount_usdc in message content.',
-    examples: [[
-            { name: '{{user1}}', content: { text: 'Deposit 0.01 USDC into WZRD market 10' } },
-            { name: '{{agentName}}', content: { text: 'Deposited 0.0100 USDC into Market #10. Tx: X7FG...' } },
-        ]],
-    validate: async () => true,
-    handler: async (runtime, message, _state, _opt, callback) => {
-        const { market_id: marketId, amount_usdc: amountUsdc, priority_fee = 50_000 } = message.content;
-        if (!marketId || !amountUsdc || amountUsdc > 100) {
-            const text = !marketId || !amountUsdc
-                ? 'Missing required: market_id and amount_usdc.' : 'Max 100 USDC per deposit.';
-            await callback?.({ text });
-            return { success: false, text };
-        }
-        const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
-        if (!sk)
-            throw new Error('SOLANA_PRIVATE_KEY not configured');
-        const kp = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(String(sk))));
-        const payer = kp.publicKey;
-        const amt = BigInt(Math.round(amountUsdc * 1e6));
-        const rpcSetting = runtime.getSetting('SOLANA_RPC_URL');
-        const rpc = (typeof rpcSetting === 'string' ? rpcSetting : undefined) || 'https://api.mainnet-beta.solana.com';
-        const conn = new Connection(rpc, 'confirmed');
-        const sdk = await import('@wzrd_sol/sdk');
-        const vault = await sdk.fetchMarketVault(conn, marketId);
-        if (!vault) {
-            await callback?.({ text: `Market ${marketId} has no vault.` });
-            return { success: false };
-        }
-        const pos = await sdk.fetchOnChainPosition(conn, payer, marketId);
-        if (pos && pos.depositedAmount > 0n && !pos.settled) {
-            await callback?.({ text: `Position exists in market ${marketId}.` });
-            return { success: false };
-        }
-        const bal = await sdk.fetchTokenBalance(conn, sdk.getAta(payer, vault.depositMint, sdk.TOKEN_PROGRAM_ID));
-        if (bal < amt) {
-            await callback?.({ text: `Insufficient USDC.` });
-            return { success: false };
-        }
-        const ixs = await sdk.createDepositMarketIx(conn, payer, marketId, amt);
-        ixs.unshift(ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priority_fee }));
-        const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash('confirmed');
-        const tx = new VersionedTransaction(new TransactionMessage({ payerKey: payer, recentBlockhash: blockhash, instructions: ixs }).compileToV0Message());
-        tx.sign([kp]);
-        const sim = await conn.simulateTransaction(tx);
-        if (sim.value.err) {
-            await callback?.({ text: `Sim failed: ${JSON.stringify(sim.value.err)}` });
-            return { success: false };
-        }
-        const sig = await conn.sendTransaction(tx, { skipPreflight: true, maxRetries: 3 });
-        try {
-            await Promise.race([
-                conn.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, 'confirmed'),
-                new Promise((_, rej) => setTimeout(() => rej(new Error('Timeout')), 60_000)),
-            ]);
-        }
-        catch {
-            await callback?.({ text: `Deposit sent, confirmation timed out. Tx: ${sig}` });
-            return { success: true, data: { signature: sig, timed_out: true } };
-        }
-        const text = `Deposited ${amountUsdc.toFixed(4)} USDC into Market #${marketId}. Tx: ${sig.slice(0, 16)}...`;
-        await callback?.({ text });
-        return { success: true, text, data: { signature: sig, market_id: marketId, amount_usdc: amountUsdc } };
-    },
-};

package/dist/actions/leaderboard.d.ts

@@ -1,3 +0,0 @@
-/** ELIZA Action: WZRD_LEADERBOARD — fetch attention market leaderboard (no auth). */
-import type { Action } from '@elizaos/core';
-export declare const leaderboardAction: Action;

package/dist/actions/leaderboard.js

@@ -1,25 +0,0 @@
-import { getWzrdClient } from '../client.js';
-export const leaderboardAction = {
-    name: 'WZRD_LEADERBOARD',
-    similes: ['WZRD_MARKETS', 'WZRD_TRENDING', 'TOP_MODELS'],
-    description: 'Fetch the WZRD attention market leaderboard ranked by velocity EMA.',
-    examples: [[
-            { name: '{{user1}}', content: { text: 'Show me the top WZRD markets' } },
-            { name: '{{agentName}}', content: { text: 'Here are the top WZRD attention markets...' } },
-        ]],
-    validate: async () => true,
-    handler: async (runtime, _msg, _state, _opt, callback) => {
-        const result = await getWzrdClient(runtime).getLeaderboard(10);
-        const lines = result.markets.map((m, i) => `${i + 1}. ${m.metric} — ${fmtV(m.velocity_ema)} velocity (${m.platform}) | ${m.multiplier_bps / 10_000}x | id=${m.market_id}`);
-        const text = `WZRD Leaderboard (${result.markets.length} markets, root_seq=${result.root.root_seq}):\n${lines.join('\n')}`;
-        await callback?.({ text });
-        return { success: true, data: result };
-    },
-};
-function fmtV(v) {
-    if (v >= 1e6)
-        return `${(v / 1e6).toFixed(1)}M`;
-    if (v >= 1e3)
-        return `${(v / 1e3).toFixed(0)}K`;
-    return v.toFixed(0);
-}

package/dist/actions/portfolio.d.ts

@@ -1,3 +0,0 @@
-/** ELIZA Action: WZRD_PORTFOLIO — fetch agent's positions + CCM earned (auth). */
-import type { Action } from '@elizaos/core';
-export declare const portfolioAction: Action;

package/dist/actions/portfolio.js

@@ -1,20 +0,0 @@
-import { getWzrdClient } from '../client.js';
-export const portfolioAction = {
-    name: 'WZRD_PORTFOLIO',
-    similes: ['WZRD_POSITIONS', 'WZRD_BALANCE', 'MY_POSITIONS'],
-    description: 'Fetch your WZRD portfolio — open positions, USDC deposited, CCM earned.',
-    examples: [[
-            { name: '{{user1}}', content: { text: 'Show my WZRD portfolio' } },
-            { name: '{{agentName}}', content: { text: 'Your WZRD portfolio has 2 open positions...' } },
-        ]],
-    validate: async () => true,
-    handler: async (runtime, _msg, _state, _opt, callback) => {
-        const p = await getWzrdClient(runtime).getPortfolio();
-        const open = p.positions.filter((x) => !x.is_settled);
-        const lines = open.map((x) => `Market #${x.market_id} (${x.metric}): ${(x.usdc_deposited / 1e6).toFixed(4)} USDC, ${(x.multiplier_bps / 1e4).toFixed(1)}x`);
-        const text = `Portfolio (${open.length} open):\n${lines.length ? lines.join('\n') : '(none)'}\n` +
-            `Total: ${(p.total_deposited_usdc / 1e6).toFixed(4)} USDC, ${(p.total_ccm_earned / 1e6).toFixed(4)} CCM`;
-        await callback?.({ text });
-        return { success: true, data: p };
-    },
-};

package/dist/actions/velocity.d.ts

@@ -1,3 +0,0 @@
-/** ELIZA Action: WZRD_VELOCITY — classify attention signal strength (no auth). */
-import type { Action } from '@elizaos/core';
-export declare const velocityAction: Action;

package/dist/actions/velocity.js

@@ -1,57 +0,0 @@
-import { getWzrdClient } from '../client.js';
-export const velocityAction = {
-    name: 'WZRD_VELOCITY',
-    similes: ['WZRD_SIGNAL', 'ATTENTION_SIGNAL', 'VELOCITY_CHECK'],
-    description: 'Analyze velocity across WZRD markets. Classifies into BREAKOUT/MOMENTUM/EMERGING/STABLE/COOLING/WEAK.',
-    examples: [[
-            { name: '{{user1}}', content: { text: 'Analyze WZRD velocity signals' } },
-            { name: '{{agentName}}', content: { text: 'BREAKOUT: Qwen 3.5 35B (450K velocity, p95)...' } },
-        ]],
-    validate: async () => true,
-    handler: async (runtime, _msg, _state, _opt, callback) => {
-        const { markets } = await getWzrdClient(runtime).getLeaderboard(50);
-        if (!markets.length) {
-            await callback?.({ text: 'No markets found.' });
-            return { success: true, data: { signals: [] } };
-        }
-        const sorted = [...markets].sort((a, b) => a.velocity_ema - b.velocity_ema);
-        const signals = markets.map((m) => {
-            const pct = ((sorted.findIndex((s) => s.market_id === m.market_id) + 1) / sorted.length) * 100;
-            return { market_id: m.market_id, metric: m.metric, platform: m.platform,
-                velocity_ema: m.velocity_ema, signal: classify(m, pct), percentile: Math.round(pct) };
-        });
-        const tiers = ['BREAKOUT', 'MOMENTUM', 'EMERGING', 'STABLE', 'COOLING', 'WEAK'];
-        const lines = [];
-        for (const t of tiers) {
-            const g = signals.filter((s) => s.signal === t);
-            if (!g.length)
-                continue;
-            lines.push(`${t}:`);
-            g.forEach((s) => lines.push(`  ${s.metric} (${fmtV(s.velocity_ema)}, p${s.percentile}) [${s.platform}]`));
-        }
-        const median = sorted[Math.floor(sorted.length / 2)]?.velocity_ema ?? 0;
-        const text = `Velocity analysis (${markets.length} markets, median ${fmtV(median)}):\n${lines.join('\n')}`;
-        await callback?.({ text });
-        return { success: true, data: { signals, median_velocity: median } };
-    },
-};
-function classify(m, p) {
-    if (p >= 90)
-        return 'BREAKOUT';
-    if (p >= 70)
-        return 'MOMENTUM';
-    if (m.snapshot_count < 300 && p >= 50)
-        return 'EMERGING';
-    if (p >= 40)
-        return 'STABLE';
-    if (p >= 20)
-        return 'COOLING';
-    return 'WEAK';
-}
-function fmtV(v) {
-    if (v >= 1e6)
-        return `${(v / 1e6).toFixed(1)}M`;
-    if (v >= 1e3)
-        return `${(v / 1e3).toFixed(0)}K`;
-    return v.toFixed(0);
-}