@wzrd_sol/solana-agent-plugin 0.1.2 → 0.2.0

package/README.md

@@ -1,6 +1,8 @@
 # @wzrd_sol/solana-agent-plugin
 
-WZRD Liquid Attention Protocol plugin for autonomous Solana agents. Provides 5 actions for interacting with WZRD attention markets: browse the leaderboard, classify velocity signals, view portfolio positions, deposit USDC to mint vLOFI, and claim CCM yield via gasless relay.
+WZRD Liquid Attention Protocol plugin for autonomous Solana agents. Provides 5 actions for the server-witnessed inference earn loop: run inference, report the outcome for verified CCM rewards, check rewards, and claim CCM via gasless relay — no deposit, no SOL required.
+
+WZRD witnesses inference (the server calls the AI provider and grades quality), issues an execution receipt, and rewards verified contributions in CCM. Claims are gasless via a server relay.
 
 Works standalone, with [Solana Agent Kit](https://github.com/sendAI/solana-agent-kit), or as a base for ElizaOS action wrappers.
 
@@ -10,17 +12,17 @@ No Solana Agent Kit dependency is required for the first smoke test. The package
 
 ```bash
 mkdir wzrd-agent && cd wzrd-agent
-printf '{\"name\":\"wzrd-agent\",\"type\":\"module\",\"private\":true}\n' > package.json
+printf '{"name":"wzrd-agent","type":"module","private":true}\n' > package.json
 npm install @wzrd_sol/solana-agent-plugin @solana/web3.js
-curl -O https://raw.githubusercontent.com/twzrd-sol/wzrd-final/main/agents/solana-agent-kit-plugin/examples/hello-wzrd.mjs
+curl -O https://raw.githubusercontent.com/twzrd-sol/wzrd-velocity/main/agents/solana-agent-kit-plugin/examples/hello-wzrd.mjs
 solana-keygen new -o /tmp/agent.json --no-bip39-passphrase
 WZRD_KEYPAIR_PATH=/tmp/agent.json node hello-wzrd.mjs
 ```
 
 What you should see:
-- top markets
+- the top markets
 - successful Ed25519 agent auth
-- portfolio or signup-bonus path
+- pending CCM rewards
 - claimable CCM state
 
 ## Install
@@ -49,10 +51,16 @@ const client = new WzrdClient(keypair);
 const leaderboard = await client.getLeaderboard();
 console.log(leaderboard.markets.map(m => `${m.channel_id}: ${m.velocity_ema}`));
 
-// Authenticated endpoints (auto-handles challenge/verify flow)
-const portfolio = await client.getPortfolio();
-const claims = await client.getClaims();
-const result = await client.claimRelay(); // gasless CCM claim
+// Earn loop (auth is handled automatically: challenge -> sign -> verify -> Bearer)
+const infer = await client.infer('Write a Python quicksort'); // server-witnessed inference
+const report = await client.report({              // verified report -> CCM
+  model_id: infer.model,
+  execution_id: infer.execution_id,
+  quality_score: infer.quality_score,
+  latency_ms: infer.latency_ms,
+});
+const rewards = await client.getRewards();        // pending + lifetime CCM
+const claim = await client.claimRelay();          // gasless CCM claim
 ```
 
 ## Solana Agent Kit
@@ -69,44 +77,52 @@ agent.use(WZRD_PLUGIN);
 
 ## Actions
 
-The plugin exports 5 actions that follow the Solana Agent Kit action interface:
+The plugin exports 5 actions that follow the Solana Agent Kit action interface. All earn-loop actions authenticate with the agent keypair (Ed25519 challenge/verify); none of them spend funds or sign a deposit.
 
-| Action | Auth | Description |
-|--------|------|-------------|
-| `LEADERBOARD_ACTION` | No | Fetch ranked attention markets |
-| `VELOCITY_ACTION` | No | Classify signal strength (BREAKOUT / MOMENTUM / EMERGING / STABLE / COOLING / WEAK) |
-| `PORTFOLIO_ACTION` | Yes | View portfolio positions |
-| `DEPOSIT_ACTION` | Yes | Deposit USDC into a market, receive vLOFI |
-| `CLAIM_ACTION` | Yes | Claim CCM via server-paid gasless relay |
+| Action | Description |
+|--------|-------------|
+| `EARN_ACTION` (`wzrd_earn`) | Full earn cycle in one call: pick a model, run server-witnessed inference, report, and check rewards |
+| `INFER_ACTION` (`wzrd_infer`) | Run server-witnessed inference; returns an `execution_id` receipt |
+| `REPORT_ACTION` (`wzrd_report`) | Report a pick with an `execution_id` for quality-weighted CCM rewards |
+| `REWARDS_ACTION` (`wzrd_rewards`) | Check pending + lifetime CCM and contribution count |
+| `CLAIM_ACTION` (`wzrd_claim`) | Claim CCM via server-paid gasless relay (agent needs 0 SOL) |
 
 ```typescript
 import { WZRD_ACTIONS, WZRD_PLUGIN } from '@wzrd_sol/solana-agent-plugin';
 
-// Register all actions with Solana Agent Kit
-// WZRD_PLUGIN.actions contains all 5 actions
+// WZRD_ACTIONS is the array of all 5 actions.
+// WZRD_PLUGIN.actions contains the same set for direct registration.
 ```
 
 ## API
 
-### `new WzrdClient(keypair: Keypair, apiUrl?: string)`
+### `new WzrdClient(signer: Keypair | WzrdSigner, apiUrl?: string)`
 
-Creates a client instance. The keypair is used for Ed25519 agent authentication. Default API URL is `https://api.twzrd.xyz`.
+Creates a client instance. Accepts a `Keypair`, or any `WzrdSigner` with a `publicKey` plus either `signMessage()` or an Ed25519 `secretKey`. The signer is used for Ed25519 agent authentication. Default API URL is `https://api.twzrd.xyz` (override with the `apiUrl` arg or the `WZRD_API_URL` environment variable).
 
 ### Methods
 
-- `getLeaderboard(limit?: number, platform?: string)` -- no auth
-- `getPortfolio()` -- authenticated
-- `getClaims()` -- authenticated
-- `claimRelay()` -- authenticated, gasless
-- `getHealth()` -- no auth
+- `getLeaderboard(limit?: number)` — no auth; ranked attention markets
+- `pickModel()` — no auth; returns the top market's `channel_id` (the server-resolvable model id)
+- `infer(prompt: string, model?: string, taskType?: string)` — authenticated; server-witnessed inference. If `model` is omitted, `pickModel()` is used. `taskType` (`code` / `chat` / `reasoning`) steers the provider cascade.
+- `report(params)` — authenticated; submit `{ model_id, execution_id, task_type?, quality_score?, latency_ms? }` for verified rewards
+- `getRewards()` — authenticated; pending + lifetime CCM and contribution count
+- `getClaimStatus()` — authenticated; cumulative / claimed / claimable CCM
+- `claimRelay()` — authenticated, gasless
 
-Auth is handled automatically: the client requests a challenge nonce, signs it with the keypair, and caches the bearer token (24h TTL, auto-refreshes).
+Auth is handled automatically: the client requests a challenge nonce, signs it, and caches the bearer token (24h TTL, auto-refreshes 1h before expiry).
 
 For an end-to-end smoke test, use [`examples/hello-wzrd.mjs`](./examples/hello-wzrd.mjs). It works with just:
 - `@wzrd_sol/solana-agent-plugin`
 - `@solana/web3.js`
 - `WZRD_KEYPAIR_PATH=/path/to/keypair.json`
 
+## Protocol
+
+WZRD measures which open-source AI models are gaining developer attention. Verified inference against high-attention models earns more CCM. The oracle is live on Solana mainnet.
+
+- **CCM Mint**: `Dxk8mAb3C7AM8JN6tAJfVuSja5yidhZM5sEKW3SRX2BM` (Token-2022, 9 decimals)
+
 ## License
 
 MIT

package/dist/actions/claim.d.ts

@@ -3,17 +3,9 @@
  *
  * Claim accrued CCM tokens via the gasless relay.
  * Server pays tx fees — agent doesn't need SOL to claim.
- *
- * Flow: check claimable amount → relay claim → receive CCM.
  */
 import { z } from 'zod';
 import type { Action, SolanaAgentKit } from 'solana-agent-kit';
-export declare const claimSchema: z.ZodObject<{
-    execute: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    execute?: boolean | undefined;
-}, {
-    execute?: boolean | undefined;
-}>;
-export declare function claimHandler(agent: SolanaAgentKit, input: z.infer<typeof claimSchema>): Promise<Record<string, unknown>>;
+export declare const claimSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function claimHandler(agent: SolanaAgentKit, _input: z.infer<typeof claimSchema>): Promise<Record<string, unknown>>;
 export declare const CLAIM_ACTION: Action;

package/dist/actions/claim.js

@@ -3,76 +3,61 @@
  *
  * Claim accrued CCM tokens via the gasless relay.
  * Server pays tx fees — agent doesn't need SOL to claim.
- *
- * Flow: check claimable amount → relay claim → receive CCM.
  */
 import { z } from 'zod';
-import { formatCcm, getClaimsData, getClientForAgent } from '../runtime.js';
-export const claimSchema = z.object({
-    execute: z.boolean().optional(),
-});
-export async function claimHandler(agent, input) {
-    const claims = await getClaimsData(agent);
-    const claimable = claims.cumulative_total - claims.claimed_total;
-    if (claimable <= 0) {
-        return {
-            success: true,
-            text: `No CCM to claim. Cumulative: ${claims.cumulative_total}, ` +
-                `already claimed: ${claims.claimed_total}. ` +
-                `Deposit into markets and wait for the next scoring cycle.`,
-            data: claims,
-        };
-    }
-    if (input.execute === false) {
+import { formatCcm, getClientForAgent } from '../runtime.js';
+export const claimSchema = z.object({});
+export async function claimHandler(agent, _input) {
+    const client = getClientForAgent(agent);
+    // Check if there's anything to claim
+    const status = await client.getClaimStatus();
+    if (status.claimable <= 0) {
         return {
             success: true,
-            text: `${formatCcm(claimable)} CCM claimable ` +
-                `(${formatCcm(claims.cumulative_total)} cumulative, ` +
-                `${formatCcm(claims.claimed_total)} claimed). ` +
-                `Root seq: ${claims.root_seq}. Call with execute=true to claim.`,
-            data: claims,
+            text: `No CCM to claim right now. ` +
+                `Cumulative: ${formatCcm(status.cumulative_total)} CCM, ` +
+                `already claimed: ${formatCcm(status.claimed_total)} CCM. ` +
+                `Run wzrd_earn first to accrue rewards.`,
+            data: status,
         };
     }
-    const result = await getClientForAgent(agent).claimRelay();
+    const result = await client.claimRelay();
     if (result.status === 'already_claimed') {
         return {
             success: true,
-            text: `Already claimed through root ${result.root_seq}. ` +
-                `Claimed total: ${formatCcm(result.claimed_total ?? claims.claimed_total)} CCM.`,
+            text: `Already claimed through root ${result.root_seq}.`,
             data: result,
         };
     }
     return {
         success: true,
         text: `Claimed CCM via gasless relay. ` +
-            `Cumulative total: ${formatCcm(result.cumulative_total)}. ` +
+            `Cumulative: ${formatCcm(result.cumulative_total)} CCM. ` +
             `Root seq: ${result.root_seq}. ` +
             `Tx: ${result.tx_sig?.slice(0, 16)}...`,
         data: {
             ...result,
-            claimable_before: claimable,
-            explorer: result.tx_sig ? `https://solscan.io/tx/${result.tx_sig}` : null,
+            claimable_before: status.claimable,
+            explorer: result.tx_sig ? `https://orbmarkets.io/tx/${result.tx_sig}` : null,
         },
     };
 }
 export const CLAIM_ACTION = {
     name: 'wzrd_claim',
-    similes: ['wzrd_harvest', 'claim_ccm', 'redeem_rewards', 'collect_yield'],
-    description: 'Claim accrued CCM tokens from your WZRD positions. Uses the gasless relay — ' +
-        'the server pays transaction fees, so you don\'t need SOL to claim. ' +
-        'CCM accrues based on your velocity multiplier and is distributed via ' +
-        'merkle proofs published on-chain every ~10 minutes. ' +
-        'Call this periodically to harvest your earned CCM.',
+    similes: ['wzrd_harvest', 'claim_ccm', 'collect_rewards'],
+    description: 'Claim accrued CCM tokens via gasless relay. The server pays transaction fees — ' +
+        'no SOL needed. CCM accrues from verified inference reports (wzrd_earn/wzrd_report). ' +
+        'Call this periodically to harvest earned CCM to your wallet.',
     examples: [
         [
             {
-                input: { execute: false },
+                input: {},
                 output: {
                     success: true,
-                    claimable: 100000,
-                    cumulative_total: 250000,
+                    cumulative_total: 250000000000,
+                    tx_sig: '5S7L...',
                 },
-                explanation: 'Check how much CCM is available before triggering a relay claim.',
+                explanation: 'Claim accrued CCM via gasless relay.',
             },
         ],
     ],

package/dist/actions/earn.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Action: wzrd_earn
+ *
+ * Full earn cycle: infer → report → check rewards.
+ * Single action that runs the complete server-witnessed earn loop.
+ */
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
+export declare const earnSchema: z.ZodObject<{
+    task_type: z.ZodOptional<z.ZodEnum<["code", "chat", "reasoning"]>>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    task_type?: "chat" | "code" | "reasoning" | undefined;
+    prompt?: string | undefined;
+}, {
+    task_type?: "chat" | "code" | "reasoning" | undefined;
+    prompt?: string | undefined;
+}>;
+export declare function earnHandler(agent: SolanaAgentKit, input: z.infer<typeof earnSchema>): Promise<Record<string, unknown>>;
+export declare const EARN_ACTION: Action;

package/dist/actions/earn.js

@@ -0,0 +1,107 @@
+/**
+ * Action: wzrd_earn
+ *
+ * Full earn cycle: infer → report → check rewards.
+ * Single action that runs the complete server-witnessed earn loop.
+ */
+import { z } from 'zod';
+import { formatCcm, getClientForAgent } from '../runtime.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 earnSchema = z.object({
+    task_type: z.enum(['code', 'chat', 'reasoning']).optional(),
+    prompt: z.string().optional(),
+});
+export async function earnHandler(agent, input) {
+    const client = getClientForAgent(agent);
+    const taskType = input.task_type || 'code';
+    const prompt = input.prompt || pickPrompt(taskType);
+    const steps = [];
+    // Step 1: Pick model + Infer
+    steps.push('-> Picking model from leaderboard...');
+    const model = await client.pickModel();
+    steps.push(`-> Running inference: ${model} (${taskType})...`);
+    const infer = await client.infer(prompt, model, taskType);
+    steps.push(`OK Inference: ${infer.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.model,
+        execution_id: infer.execution_id,
+        task_type: taskType,
+        quality_score: infer.quality_score,
+        latency_ms: infer.latency_ms,
+    });
+    steps.push(`OK Reported: ${report.verification_state}, contribution #${report.contribution_id}`);
+    // Step 3: Check rewards
+    steps.push('-> Checking rewards...');
+    const rewards = await client.getRewards();
+    steps.push(`OK Rewards: ${formatCcm(rewards.pending_ccm)} CCM pending, ` +
+        `${formatCcm(rewards.total_rewarded_ccm)} CCM lifetime`);
+    return {
+        success: true,
+        text: `Earn cycle complete:\n${steps.join('\n')}`,
+        data: {
+            infer: {
+                execution_id: infer.execution_id,
+                model: infer.model,
+                provider: infer.provider,
+                quality_score: infer.quality_score,
+                latency_ms: infer.latency_ms,
+            },
+            report: {
+                contribution_id: report.contribution_id,
+                verification_state: report.verification_state,
+            },
+            rewards: {
+                pending_ccm: rewards.pending_ccm,
+                total_rewarded_ccm: rewards.total_rewarded_ccm,
+                contribution_count: rewards.contribution_count,
+            },
+        },
+    };
+}
+export const EARN_ACTION = {
+    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. ' +
+        'Earns verified CCM rewards on Solana.',
+    examples: [
+        [
+            {
+                input: { task_type: 'code' },
+                output: {
+                    success: true,
+                    model: 'gemini-2.5-flash',
+                    quality_score: 0.85,
+                    verification_state: 'verified',
+                    pending_ccm: 142500000000,
+                },
+                explanation: 'Run the full earn cycle: infer through WZRD, report outcome, check rewards.',
+            },
+        ],
+    ],
+    schema: earnSchema,
+    handler: async (agent, input) => earnHandler(agent, earnSchema.parse(input)),
+};

package/dist/actions/index.d.ts

@@ -1,6 +1,5 @@
-export type { MarketSignal } from './velocity.js';
-export { LEADERBOARD_ACTION } from './leaderboard.js';
-export { PORTFOLIO_ACTION } from './portfolio.js';
-export { DEPOSIT_ACTION } from './deposit.js';
+export { EARN_ACTION } from './earn.js';
+export { INFER_ACTION } from './infer.js';
+export { REPORT_ACTION } from './report.js';
 export { CLAIM_ACTION } from './claim.js';
-export { VELOCITY_ACTION } from './velocity.js';
+export { REWARDS_ACTION } from './rewards.js';

package/dist/actions/index.js

@@ -1,5 +1,5 @@
-export { LEADERBOARD_ACTION } from './leaderboard.js';
-export { PORTFOLIO_ACTION } from './portfolio.js';
-export { DEPOSIT_ACTION } from './deposit.js';
+export { EARN_ACTION } from './earn.js';
+export { INFER_ACTION } from './infer.js';
+export { REPORT_ACTION } from './report.js';
 export { CLAIM_ACTION } from './claim.js';
-export { VELOCITY_ACTION } from './velocity.js';
+export { REWARDS_ACTION } from './rewards.js';

package/dist/actions/infer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Action: wzrd_infer
+ *
+ * Server-witnessed inference through WZRD.
+ * Returns execution_id receipt for use with wzrd_report.
+ */
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
+export declare const inferSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    task_type: z.ZodOptional<z.ZodEnum<["code", "chat", "reasoning"]>>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    task_type?: "chat" | "code" | "reasoning" | undefined;
+    model?: string | undefined;
+}, {
+    prompt: string;
+    task_type?: "chat" | "code" | "reasoning" | undefined;
+    model?: string | undefined;
+}>;
+export declare function inferHandler(agent: SolanaAgentKit, input: z.infer<typeof inferSchema>): Promise<Record<string, unknown>>;
+export declare const INFER_ACTION: Action;

package/dist/actions/infer.js

@@ -0,0 +1,56 @@
+/**
+ * Action: wzrd_infer
+ *
+ * Server-witnessed inference through WZRD.
+ * Returns execution_id receipt for use with wzrd_report.
+ */
+import { z } from 'zod';
+import { getClientForAgent } from '../runtime.js';
+export const inferSchema = z.object({
+    prompt: z.string().min(1),
+    model: z.string().optional(),
+    task_type: z.enum(['code', 'chat', 'reasoning']).optional(),
+});
+export async function inferHandler(agent, input) {
+    const client = getClientForAgent(agent);
+    const taskType = input.task_type || 'chat';
+    const result = await client.infer(input.prompt, input.model, taskType);
+    return {
+        success: true,
+        text: `Inference complete. Model: ${result.model} (${result.provider}), ` +
+            `quality: ${result.quality_score.toFixed(2)}, ${result.latency_ms}ms. ` +
+            `execution_id: ${result.execution_id}`,
+        data: {
+            execution_id: result.execution_id,
+            model: result.model,
+            provider: result.provider,
+            quality_score: result.quality_score,
+            latency_ms: result.latency_ms,
+            response_preview: result.response.slice(0, 300),
+        },
+    };
+}
+export const INFER_ACTION = {
+    name: 'wzrd_infer',
+    similes: ['wzrd_run_inference', 'ask_model', 'run_model'],
+    description: 'Run server-witnessed inference through WZRD. The server calls the AI provider, ' +
+        'grades quality, and returns an execution receipt (execution_id). ' +
+        'Use the execution_id with wzrd_report to earn verified CCM rewards. ' +
+        'If no model is specified, picks the top model from the leaderboard.',
+    examples: [
+        [
+            {
+                input: { prompt: 'Write a Python function to check if a binary tree is balanced', task_type: 'code' },
+                output: {
+                    success: true,
+                    execution_id: 'abc-123',
+                    model: 'gemini-2.5-flash',
+                    quality_score: 0.85,
+                },
+                explanation: 'Run inference through WZRD to get an execution receipt for verified rewards.',
+            },
+        ],
+    ],
+    schema: inferSchema,
+    handler: async (agent, input) => inferHandler(agent, inferSchema.parse(input)),
+};

package/dist/actions/report.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Action: 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.
+ */
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
+export declare const reportSchema: z.ZodObject<{
+    model_id: z.ZodString;
+    execution_id: z.ZodString;
+    task_type: z.ZodOptional<z.ZodEnum<["code", "chat", "reasoning"]>>;
+    quality_score: z.ZodOptional<z.ZodNumber>;
+    latency_ms: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    execution_id: string;
+    model_id: string;
+    task_type?: "chat" | "code" | "reasoning" | undefined;
+    quality_score?: number | undefined;
+    latency_ms?: number | undefined;
+}, {
+    execution_id: string;
+    model_id: string;
+    task_type?: "chat" | "code" | "reasoning" | undefined;
+    quality_score?: number | undefined;
+    latency_ms?: number | undefined;
+}>;
+export declare function reportHandler(agent: SolanaAgentKit, input: z.infer<typeof reportSchema>): Promise<Record<string, unknown>>;
+export declare const REPORT_ACTION: Action;

package/dist/actions/report.js

@@ -0,0 +1,59 @@
+/**
+ * Action: 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.
+ */
+import { z } from 'zod';
+import { getClientForAgent } from '../runtime.js';
+export const reportSchema = z.object({
+    model_id: z.string().min(1),
+    execution_id: z.string().min(1),
+    task_type: z.enum(['code', 'chat', 'reasoning']).optional(),
+    quality_score: z.number().min(0).max(1).optional(),
+    latency_ms: z.number().int().positive().optional(),
+});
+export async function reportHandler(agent, input) {
+    const client = getClientForAgent(agent);
+    const result = await client.report({
+        model_id: input.model_id,
+        execution_id: input.execution_id,
+        task_type: input.task_type,
+        quality_score: input.quality_score,
+        latency_ms: input.latency_ms,
+    });
+    return {
+        success: true,
+        text: `Reported to WZRD. Verification: ${result.verification_state}, ` +
+            `contribution #${result.contribution_id}, model: ${result.model_id}` +
+            (result.quality_score != null ? `, quality: ${result.quality_score.toFixed(2)}` : ''),
+        data: {
+            contribution_id: result.contribution_id,
+            verification_state: result.verification_state,
+            quality_score: result.quality_score,
+            model_id: result.model_id,
+        },
+    };
+}
+export const REPORT_ACTION = {
+    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 a quality multiplier. ' +
+        'Requires: model_id and execution_id (both from wzrd_infer result).',
+    examples: [
+        [
+            {
+                input: { model_id: 'gemini-2.5-flash', execution_id: 'abc-123', task_type: 'code', quality_score: 0.85 },
+                output: {
+                    success: true,
+                    verification_state: 'verified',
+                    contribution_id: 4521,
+                },
+                explanation: 'Report an inference outcome with execution receipt for verified CCM rewards.',
+            },
+        ],
+    ],
+    schema: reportSchema,
+    handler: async (agent, input) => reportHandler(agent, reportSchema.parse(input)),
+};

package/dist/actions/rewards.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Action: wzrd_rewards
+ *
+ * Check pending and lifetime CCM rewards.
+ */
+import { z } from 'zod';
+import type { Action, SolanaAgentKit } from 'solana-agent-kit';
+export declare const rewardsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare function rewardsHandler(agent: SolanaAgentKit, _input: z.infer<typeof rewardsSchema>): Promise<Record<string, unknown>>;
+export declare const REWARDS_ACTION: Action;

package/dist/actions/rewards.js

@@ -0,0 +1,48 @@
+/**
+ * Action: wzrd_rewards
+ *
+ * Check pending and lifetime CCM rewards.
+ */
+import { z } from 'zod';
+import { formatCcm, getClientForAgent } from '../runtime.js';
+export const rewardsSchema = z.object({});
+export async function rewardsHandler(agent, _input) {
+    const client = getClientForAgent(agent);
+    const rewards = await client.getRewards();
+    return {
+        success: true,
+        text: `WZRD Rewards: ` +
+            `${formatCcm(rewards.pending_ccm)} CCM pending, ` +
+            `${formatCcm(rewards.total_rewarded_ccm)} CCM lifetime, ` +
+            `${rewards.contribution_count} contributions` +
+            (rewards.rank ? `, rank #${rewards.rank}` : ''),
+        data: {
+            pending_ccm: rewards.pending_ccm,
+            total_rewarded_ccm: rewards.total_rewarded_ccm,
+            contribution_count: rewards.contribution_count,
+            rank: rewards.rank,
+        },
+    };
+}
+export const REWARDS_ACTION = {
+    name: 'wzrd_rewards',
+    similes: ['wzrd_balance', 'check_rewards', 'my_ccm'],
+    description: 'Check your pending CCM rewards, lifetime total, and contribution count. ' +
+        'Use this to see how much you have earned from WZRD inference before claiming.',
+    examples: [
+        [
+            {
+                input: {},
+                output: {
+                    success: true,
+                    pending_ccm: 142500000000,
+                    total_rewarded_ccm: 326000000000,
+                    contribution_count: 47,
+                },
+                explanation: 'Check pending and lifetime CCM rewards.',
+            },
+        ],
+    ],
+    schema: rewardsSchema,
+    handler: async (agent, input) => rewardsHandler(agent, rewardsSchema.parse(input)),
+};