@wzrd_sol/goat-plugin 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -18,25 +16,17 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   ClaimParameters: () => ClaimParameters,
-  DepositParameters: () => DepositParameters,
-  GetLeaderboardParameters: () => GetLeaderboardParameters,
-  GetPortfolioParameters: () => GetPortfolioParameters,
-  GetVelocitySignalParameters: () => GetVelocitySignalParameters,
-  WzrdApiClient: () => WzrdApiClient,
+  EarnParameters: () => EarnParameters,
+  InferParameters: () => InferParameters,
+  ReportParameters: () => ReportParameters,
+  RewardsParameters: () => RewardsParameters,
+  WzrdClient: () => WzrdClient,
   WzrdPlugin: () => WzrdPlugin,
   wzrd: () => wzrd
 });
@@ -45,29 +35,55 @@ module.exports = __toCommonJS(index_exports);
 // src/wzrd.plugin.ts
 var import_core7 = require("@goat-sdk/core");
 
-// src/wzrd.service.ts
-var DEFAULT_API_URL = "https://api.twzrd.xyz";
-var TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1e3;
-var WzrdApiClient = class {
+// src/client.ts
+var DEFAULT_API = "https://api.twzrd.xyz";
+var TOKEN_REFRESH_MARGIN_MS = 60 * 60 * 1e3;
+var 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;
+}
+__name(toBase58, "toBase58");
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+__name(hexToBytes, "hexToBytes");
+var WzrdClient = class {
   static {
-    __name(this, "WzrdApiClient");
+    __name(this, "WzrdClient");
   }
   apiUrl;
-  // Cache auth tokens per wallet address to avoid re-auth on every tool call
+  // Cache auth tokens per wallet address
   tokenCache = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.apiUrl = options?.apiUrl?.trim() || process.env.WZRD_API_URL?.trim() || DEFAULT_API_URL;
-  }
-  /**
-  * Authenticate with the WZRD API using the GOAT wallet client.
-  *
-  * Flow:
-  *   1. GET /v1/agent/challenge — receive nonce
-  *   2. Sign canonical message with wallet's signMessage()
-  *   3. POST /v1/agent/verify — receive bearer token (24h TTL)
-  *
-  * Returns a cached bearer token if still valid.
-  */
+    this.apiUrl = options?.apiUrl?.trim() || process.env.WZRD_API_URL?.trim() || DEFAULT_API;
+  }
+  /** Ed25519 challenge → sign → verify → Bearer token */
   async authenticate(walletClient) {
     const address = walletClient.getAddress();
     const cached = this.tokenCache.get(address);
@@ -100,99 +116,171 @@ var WzrdApiClient = class {
     const { token, expires_at } = await verifyRes.json();
     this.tokenCache.set(address, {
       token,
-      expiresAt: new Date(expires_at).getTime()
+      expiresAt: expires_at ? new Date(expires_at).getTime() : Date.now() + 23 * 60 * 60 * 1e3
     });
     return token;
   }
-};
-var 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;
+  /** Authenticated fetch helper */
+  async authedFetch(walletClient, path, init) {
+    const token = await this.authenticate(walletClient);
+    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 name */
+  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 data.models[0].model;
+  }
+  /** Server-witnessed inference — WZRD calls the provider, grades quality */
+  async infer(walletClient, prompt, model, taskType) {
+    const resolvedModel = model || await this.pickModel(taskType);
+    const res = await this.authedFetch(walletClient, "/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}`);
     }
-    while (carry > 0) {
-      digits.push(carry % 58);
-      carry = carry / 58 | 0;
+    return res.json();
+  }
+  /** Report model pick with execution_id for verified rewards */
+  async report(walletClient, params) {
+    const res = await this.authedFetch(walletClient, "/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();
   }
-  let out = "";
-  for (const b of bytes) {
-    if (b !== 0) break;
-    out += "1";
+  /** Check pending + total rewards */
+  async getRewards(walletClient) {
+    const res = await this.authedFetch(walletClient, "/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,
+      contribution_count: Number(routing?.lifetime_contributions ?? 0)
+    };
   }
-  for (let i = digits.length - 1; i >= 0; i--) out += B58[digits[i]];
-  return out;
-}
-__name(toBase58, "toBase58");
-function hexToBytes(hex) {
-  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-  const bytes = new Uint8Array(clean.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
+  /** Gasless CCM claim via server relay */
+  async claimRelay(walletClient) {
+    const pubkey = walletClient.getAddress();
+    const res = await this.authedFetch(walletClient, `/v1/claims/${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();
   }
-  return bytes;
-}
-__name(hexToBytes, "hexToBytes");
+  /** Check claims status */
+  async getClaimStatus(walletClient) {
+    const pubkey = walletClient.getAddress();
+    const res = await this.authedFetch(walletClient, `/v1/claims/${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
+    };
+  }
+  /** 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();
+  }
+};
 
-// src/tools/leaderboard.ts
+// src/tools/infer.ts
 var import_core2 = require("@goat-sdk/core");
+var import_wallet_solana = require("@goat-sdk/wallet-solana");
 
 // src/parameters.ts
 var import_core = require("@goat-sdk/core");
 var import_zod = require("zod");
-var GetLeaderboardParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
-  limit: import_zod.z.number().int().min(1).max(50).optional().describe("Number of markets to return (default 20, max 50)"),
-  platform: import_zod.z.string().optional().describe("Filter by platform: 'huggingface', 'github', or omit for all")
+var InferParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
+  prompt: import_zod.z.string().describe("The prompt to send for inference"),
+  model: import_zod.z.string().optional().describe("Specific model to use (e.g. 'gemini-2.5-flash'). If omitted, picks the top model from the leaderboard."),
+  task_type: import_zod.z.enum([
+    "code",
+    "chat",
+    "reasoning"
+  ]).optional().describe("Task type for prompt classification: 'code', 'chat', or 'reasoning'. Default: 'chat'.")
 })) {
   static {
-    __name(this, "GetLeaderboardParameters");
+    __name(this, "InferParameters");
   }
 };
-var GetVelocitySignalParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
-  platform: import_zod.z.string().optional().describe("Filter by platform: 'huggingface', 'github'"),
-  min_signal: import_zod.z.enum([
-    "BREAKOUT",
-    "MOMENTUM",
-    "EMERGING",
-    "STABLE",
-    "COOLING",
-    "WEAK"
-  ]).optional().describe("Minimum signal tier to include. BREAKOUT is strongest, WEAK is lowest. Only markets at or above this tier are returned.")
+var ReportParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
+  model_id: import_zod.z.string().describe("Model ID from the infer result (e.g. 'gemini-2.5-flash')"),
+  execution_id: import_zod.z.string().describe("Execution receipt from WZRD_INFER \u2014 required for verified rewards"),
+  task_type: import_zod.z.enum([
+    "code",
+    "chat",
+    "reasoning"
+  ]).optional().describe("Task type matching the inference request"),
+  quality_score: import_zod.z.number().min(0).max(1).optional().describe("Quality score from the infer result (0-1)"),
+  latency_ms: import_zod.z.number().int().positive().optional().describe("Latency in ms from the infer result")
 })) {
   static {
-    __name(this, "GetVelocitySignalParameters");
+    __name(this, "ReportParameters");
   }
 };
-var GetPortfolioParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({})) {
+var EarnParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
+  task_type: import_zod.z.enum([
+    "code",
+    "chat",
+    "reasoning"
+  ]).optional().describe("Task type for the eval prompt: 'code', 'chat', or 'reasoning'. Default: 'code'."),
+  prompt: import_zod.z.string().optional().describe("Custom prompt to use for inference. If omitted, a random eval prompt is selected.")
+})) {
   static {
-    __name(this, "GetPortfolioParameters");
+    __name(this, "EarnParameters");
   }
 };
-var DepositParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
-  market_id: import_zod.z.number().int().min(1).describe("Market ID to deposit into (get from wzrd_get_leaderboard)"),
-  amount_usdc: import_zod.z.number().positive().max(100).describe("Amount of USDC to deposit (e.g. 0.01). Max 100 per deposit."),
-  priority_fee: import_zod.z.number().int().positive().optional().describe("Priority fee in micro-lamports (default 50000). Higher = faster inclusion.")
-})) {
+var ClaimParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({})) {
   static {
-    __name(this, "DepositParameters");
+    __name(this, "ClaimParameters");
   }
 };
-var ClaimParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({
-  execute: import_zod.z.boolean().optional().describe("If false, only check claimable amount without executing. Default true.")
-})) {
+var RewardsParameters = class extends (0, import_core.createToolParameters)(import_zod.z.object({})) {
   static {
-    __name(this, "ClaimParameters");
+    __name(this, "RewardsParameters");
   }
 };
 
-// src/tools/leaderboard.ts
+// src/tools/infer.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -204,56 +292,44 @@ function _ts_metadata(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata, "_ts_metadata");
-var LeaderboardTools = class {
+var InferTools = class {
   static {
-    __name(this, "LeaderboardTools");
+    __name(this, "InferTools");
   }
-  api;
-  constructor(api) {
-    this.api = api;
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async wzrd_get_leaderboard(parameters) {
-    const limit = parameters.limit ?? 20;
-    const params = new URLSearchParams({
-      limit: String(limit)
-    });
-    if (parameters.platform) params.set("platform", parameters.platform);
-    const res = await fetch(`${this.api.apiUrl}/v1/leaderboard?${params}`);
-    if (!res.ok) {
-      throw new Error(`Leaderboard request failed: ${res.status}`);
-    }
-    const data = await res.json();
-    const markets = data.markets ?? [];
-    const summary = markets.map((m, i) => `${i + 1}. ${m.metric} \u2014 ${formatVelocity(m.velocity_ema)} velocity (${m.platform}) | ${m.multiplier_bps / 1e4}x multiplier | ${m.position_count} positions | market_id=${m.market_id}`).join("\n");
+  async wzrd_infer(walletClient, parameters) {
+    const { prompt, model, task_type } = parameters;
+    const taskType = task_type || "chat";
+    const result = await this.client.infer(walletClient, prompt, model, taskType);
     return {
-      summary: `WZRD Leaderboard (${markets.length} markets, root_seq=${data.root?.root_seq ?? "N/A"}):
-${summary}`,
-      markets,
-      root: data.root,
-      total_positions: data.total_positions,
-      total_tvl_usdc: data.total_tvl_usdc
+      summary: `Inference complete. Model: ${result.model} (${result.provider}), quality: ${result.quality_score.toFixed(2)}, ${result.latency_ms}ms. execution_id: ${result.execution_id}`,
+      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)
     };
   }
 };
 _ts_decorate([
   (0, import_core2.Tool)({
-    description: "Fetch the WZRD attention market leaderboard. Shows AI models and open-source projects ranked by real-time velocity (download/star momentum). Returns market IDs, velocity EMA, multiplier, TVL, and platform. Use this to find the highest-attention markets before depositing."
+    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."
   }),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof GetLeaderboardParameters === "undefined" ? Object : GetLeaderboardParameters
+    typeof import_wallet_solana.SolanaWalletClient === "undefined" ? Object : import_wallet_solana.SolanaWalletClient,
+    typeof InferParameters === "undefined" ? Object : InferParameters
   ]),
   _ts_metadata("design:returntype", Promise)
-], LeaderboardTools.prototype, "wzrd_get_leaderboard", null);
-function formatVelocity(v) {
-  if (v >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
-  if (v >= 1e3) return `${(v / 1e3).toFixed(0)}K`;
-  return v.toFixed(0);
-}
-__name(formatVelocity, "formatVelocity");
+], InferTools.prototype, "wzrd_infer", null);
 
-// src/tools/velocity.ts
+// src/tools/report.ts
 var import_core3 = require("@goat-sdk/core");
+var import_wallet_solana2 = require("@goat-sdk/wallet-solana");
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -265,110 +341,46 @@ function _ts_metadata2(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata2, "_ts_metadata");
-var VelocityTools = class {
+var ReportTools = class {
   static {
-    __name(this, "VelocityTools");
+    __name(this, "ReportTools");
   }
-  api;
-  constructor(api) {
-    this.api = api;
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async wzrd_get_velocity_signal(parameters) {
-    const params = new URLSearchParams({
-      limit: "50"
-    });
-    if (parameters.platform) params.set("platform", parameters.platform);
-    const res = await fetch(`${this.api.apiUrl}/v1/leaderboard?${params}`);
-    if (!res.ok) {
-      throw new Error(`Leaderboard request failed: ${res.status}`);
-    }
-    const data = await res.json();
-    const markets = data.markets ?? [];
-    if (markets.length === 0) {
-      return {
-        summary: "No markets found.",
-        signals: []
-      };
-    }
-    const sorted = [
-      ...markets
-    ].sort((a, b) => a.velocity_ema - b.velocity_ema);
-    const signals = markets.map((m) => {
-      const rank = sorted.findIndex((s) => s.market_id === m.market_id);
-      const percentile = (rank + 1) / sorted.length * 100;
-      return {
-        market_id: m.market_id,
-        metric: m.metric,
-        platform: m.platform,
-        velocity_ema: m.velocity_ema,
-        signal: classify(m, percentile),
-        percentile: Math.round(percentile)
-      };
+  async wzrd_report(walletClient, parameters) {
+    const result = await this.client.report(walletClient, {
+      model_id: parameters.model_id,
+      execution_id: parameters.execution_id,
+      task_type: parameters.task_type,
+      quality_score: parameters.quality_score,
+      latency_ms: parameters.latency_ms
     });
-    const tierOrder = [
-      "BREAKOUT",
-      "MOMENTUM",
-      "EMERGING",
-      "STABLE",
-      "COOLING",
-      "WEAK"
-    ];
-    const minIdx = parameters.min_signal ? tierOrder.indexOf(parameters.min_signal) : tierOrder.length;
-    const filtered = minIdx < tierOrder.length ? signals.filter((s) => tierOrder.indexOf(s.signal) <= minIdx) : signals;
-    const grouped = /* @__PURE__ */ 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} (${formatVelocity2(s.velocity_ema)} velocity, p${s.percentile}) [${s.platform}]`);
-      }
-    }
-    const medianIdx = Math.floor(sorted.length / 2);
-    const medianVelocity = sorted[medianIdx]?.velocity_ema ?? 0;
     return {
-      summary: `Velocity analysis (${markets.length} markets, median ${formatVelocity2(medianVelocity)}):
-${lines.join("\n")}`,
-      signals: filtered,
-      median_velocity: medianVelocity
+      summary: `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)}` : ""),
+      contribution_id: result.contribution_id,
+      verification_state: result.verification_state,
+      quality_score: result.quality_score,
+      model_id: result.model_id
     };
   }
 };
 _ts_decorate2([
   (0, import_core3.Tool)({
-    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 \u2014 BREAKOUT and MOMENTUM markets have the strongest attention momentum."
+    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)."
   }),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof GetVelocitySignalParameters === "undefined" ? Object : GetVelocitySignalParameters
+    typeof import_wallet_solana2.SolanaWalletClient === "undefined" ? Object : import_wallet_solana2.SolanaWalletClient,
+    typeof ReportParameters === "undefined" ? Object : ReportParameters
   ]),
   _ts_metadata2("design:returntype", Promise)
-], VelocityTools.prototype, "wzrd_get_velocity_signal", null);
-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";
-}
-__name(classify, "classify");
-function formatVelocity2(v) {
-  if (v >= 1e6) return `${(v / 1e6).toFixed(1)}M`;
-  if (v >= 1e3) return `${(v / 1e3).toFixed(0)}K`;
-  return v.toFixed(0);
-}
-__name(formatVelocity2, "formatVelocity");
+], ReportTools.prototype, "wzrd_report", null);
 
-// src/tools/portfolio.ts
+// src/tools/earn.ts
 var import_core4 = require("@goat-sdk/core");
-var import_wallet_solana = require("@goat-sdk/wallet-solana");
+var import_wallet_solana3 = require("@goat-sdk/wallet-solana");
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -380,63 +392,94 @@ function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata3, "_ts_metadata");
-var PortfolioTools = class {
+var 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)];
+}
+__name(pickPrompt, "pickPrompt");
+var EarnTools = class {
   static {
-    __name(this, "PortfolioTools");
+    __name(this, "EarnTools");
   }
-  api;
-  constructor(api) {
-    this.api = api;
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async wzrd_get_portfolio(walletClient, parameters) {
-    const token = await this.api.authenticate(walletClient);
-    const res = await fetch(`${this.api.apiUrl}/v1/portfolio`, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
+  async wzrd_earn(walletClient, parameters) {
+    const taskType = parameters.task_type || "code";
+    const prompt = parameters.prompt || pickPrompt(taskType);
+    const steps = [];
+    steps.push("-> Picking model from leaderboard...");
+    const model = await this.client.pickModel(taskType);
+    steps.push(`-> Running inference: ${model} (${taskType})...`);
+    const infer = await this.client.infer(walletClient, prompt, model, taskType);
+    steps.push(`OK Inference: ${infer.model} (${infer.provider}), quality ${infer.quality_score.toFixed(2)}, ${infer.latency_ms}ms`);
+    steps.push("-> Reporting outcome...");
+    const report = await this.client.report(walletClient, {
+      model_id: infer.model,
+      execution_id: infer.execution_id,
+      task_type: taskType,
+      quality_score: infer.quality_score,
+      latency_ms: infer.latency_ms
     });
-    if (!res.ok) {
-      throw new Error(`Portfolio request failed: ${res.status}`);
-    }
-    const portfolio = await res.json();
-    const positions = portfolio.positions ?? [];
-    const lines = positions.map((p) => `Market #${p.market_id} (${p.metric}): ${formatUsdc(p.usdc_deposited)} USDC, ${formatUsdc(p.vlofi_minted)} vLOFI, ${p.multiplier_bps / 1e4}x multiplier` + (p.is_settled ? " [SETTLED]" : ""));
+    steps.push(`OK Reported: ${report.verification_state}, contribution #${report.contribution_id}`);
+    steps.push("-> Checking rewards...");
+    const rewards = await this.client.getRewards(walletClient);
+    steps.push(`OK Rewards: ${(rewards.pending_ccm / 1e9).toFixed(2)} CCM pending, ${(rewards.total_rewarded_ccm / 1e9).toFixed(2)} CCM lifetime`);
     return {
-      summary: `Portfolio (${positions.length} positions):
-${lines.join("\n")}
-Total: ${formatUsdc(portfolio.total_deposited_usdc)} USDC deposited, ${formatUsdc(portfolio.total_vlofi)} vLOFI, ${formatCcm(portfolio.total_ccm_earned)} CCM earned`,
-      positions,
-      total_deposited_usdc: portfolio.total_deposited_usdc,
-      total_vlofi: portfolio.total_vlofi,
-      total_ccm_earned: portfolio.total_ccm_earned
+      summary: `Earn cycle complete:
+${steps.join("\n")}`,
+      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
+      }
     };
   }
 };
 _ts_decorate3([
   (0, import_core4.Tool)({
-    description: "View your WZRD portfolio \u2014 all positions, vLOFI balances, and CCM earned. Shows each market you're deposited in, your multiplier, settlement status, and aggregate totals. Use this to decide when to claim or deposit more."
+    description: "Run the full WZRD earn cycle: pick a prompt, run server-witnessed inference, report the outcome, and check pending rewards. One tool call, complete loop. Earns verified CCM rewards on Solana. Use task_type to control prompt category (code/chat/reasoning) or provide a custom prompt."
   }),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
-    typeof import_wallet_solana.SolanaWalletClient === "undefined" ? Object : import_wallet_solana.SolanaWalletClient,
-    typeof GetPortfolioParameters === "undefined" ? Object : GetPortfolioParameters
+    typeof import_wallet_solana3.SolanaWalletClient === "undefined" ? Object : import_wallet_solana3.SolanaWalletClient,
+    typeof EarnParameters === "undefined" ? Object : EarnParameters
   ]),
   _ts_metadata3("design:returntype", Promise)
-], PortfolioTools.prototype, "wzrd_get_portfolio", null);
-function formatUsdc(nativeAmount) {
-  return (Number(nativeAmount) / 1e6).toFixed(4);
-}
-__name(formatUsdc, "formatUsdc");
-function formatCcm(nativeAmount) {
-  return (Number(nativeAmount) / 1e6).toFixed(4);
-}
-__name(formatCcm, "formatCcm");
+], EarnTools.prototype, "wzrd_earn", null);
 
-// src/tools/deposit.ts
+// src/tools/claim.ts
 var import_core5 = require("@goat-sdk/core");
-var import_wallet_solana2 = require("@goat-sdk/wallet-solana");
-var import_web3 = require("@solana/web3.js");
-var import_meta = {};
+var import_wallet_solana4 = require("@goat-sdk/wallet-solana");
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -448,127 +491,64 @@ function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata4, "_ts_metadata");
-var DepositTools = class {
+var ClaimTools = class {
   static {
-    __name(this, "DepositTools");
-  }
-  api;
-  constructor(api) {
-    this.api = api;
-  }
-  async wzrd_deposit(walletClient, parameters) {
-    const { market_id, amount_usdc, priority_fee = 5e4 } = parameters;
-    const connection = walletClient.getConnection();
-    const payer = new import_web3.PublicKey(walletClient.getAddress());
-    const amountNative = BigInt(Math.round(amount_usdc * 1e6));
-    const t0 = Date.now();
-    const sdk = await loadSdk();
-    const { createDepositMarketIx, fetchMarketVault, fetchOnChainPosition, fetchTokenBalance, getAta, TOKEN_PROGRAM_ID } = sdk;
-    const vault = await fetchMarketVault(connection, market_id);
-    if (!vault) {
-      return {
-        success: false,
-        error: `Market ${market_id} is listed but does not have an on-chain vault yet. Pick a market with an initialized vault before depositing.`,
-        market_id,
-        reason: "missing_vault"
-      };
-    }
-    const existing = await fetchOnChainPosition(connection, payer, market_id);
-    if (existing && existing.depositedAmount > 0n && !existing.settled) {
-      return {
-        success: false,
-        error: `Position already exists in market ${market_id}. Cannot double-deposit.`,
-        market_id,
-        deposited_amount: existing.depositedAmount.toString()
-      };
-    }
-    const usdcAta = getAta(payer, vault.depositMint, TOKEN_PROGRAM_ID);
-    const usdcBalance = await fetchTokenBalance(connection, usdcAta);
-    if (usdcBalance < amountNative) {
+    __name(this, "ClaimTools");
+  }
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async wzrd_claim(walletClient, _parameters) {
+    const status = await this.client.getClaimStatus(walletClient);
+    if (status.claimable <= 0) {
       return {
-        success: false,
-        error: `Insufficient USDC: have ${formatUsdc2(usdcBalance)}, need ${amount_usdc.toFixed(4)}`,
-        market_id,
-        required_native: amountNative.toString(),
-        balance_native: usdcBalance.toString()
+        success: true,
+        summary: `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.`,
+        claimable: 0,
+        cumulative_total: status.cumulative_total,
+        claimed_total: status.claimed_total
       };
     }
-    const solBalance = await connection.getBalance(payer);
-    if (solBalance < 1e4) {
+    const result = await this.client.claimRelay(walletClient);
+    if (result.status === "already_claimed") {
       return {
-        success: false,
-        error: `Insufficient SOL for tx fees: ${solBalance} lamports`,
-        market_id,
-        sol_balance_lamports: solBalance
+        success: true,
+        summary: `Already claimed through root ${result.root_seq}.`,
+        already_claimed: true,
+        root_seq: result.root_seq
       };
     }
-    let ixs;
-    try {
-      ixs = await createDepositMarketIx(connection, payer, market_id, amountNative);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("MarketVault not found")) {
-        return {
-          success: false,
-          error: `Market ${market_id} vault not found on-chain.`,
-          market_id,
-          reason: "missing_vault"
-        };
-      }
-      throw error;
-    }
-    ixs.unshift(import_web3.ComputeBudgetProgram.setComputeUnitLimit({
-      units: 3e5
-    }), import_web3.ComputeBudgetProgram.setComputeUnitPrice({
-      microLamports: priority_fee
-    }));
-    const { hash } = await walletClient.sendTransaction({
-      instructions: ixs
-    });
-    const elapsed = Date.now() - t0;
     return {
       success: true,
-      summary: `Deposited ${amount_usdc.toFixed(4)} USDC into Market #${market_id}. Tx: ${hash.slice(0, 16)}... (${elapsed}ms)`,
-      signature: hash,
-      market_id,
-      amount_usdc,
-      elapsed_ms: elapsed,
-      explorer: `https://solscan.io/tx/${hash}`
+      summary: `Claimed CCM via gasless relay. Cumulative: ${formatCcm(result.cumulative_total)} CCM. Root seq: ${result.root_seq}. Tx: ${result.tx_sig?.slice(0, 16)}...`,
+      cumulative_total: result.cumulative_total,
+      root_seq: result.root_seq,
+      tx_sig: result.tx_sig,
+      claimable_before: status.claimable,
+      explorer: result.tx_sig ? `https://orbmarkets.io/tx/${result.tx_sig}` : null
     };
   }
 };
 _ts_decorate4([
   (0, import_core5.Tool)({
-    description: "Deposit USDC into a WZRD attention market to mint vLOFI tokens. vLOFI represents your position in the market. As the underlying AI model gains attention (downloads, stars), your multiplier increases and you earn more CCM on each merkle root publication. Requires: market_id (from wzrd_get_leaderboard) and amount_usdc. The deposit is atomic \u2014 USDC is transferred and vLOFI is minted in one transaction."
+    description: "Claim accrued CCM tokens via gasless relay. The server pays transaction fees \u2014 no SOL needed. CCM accrues from verified inference reports (wzrd_earn/wzrd_report). Call this periodically to harvest earned CCM to your wallet."
   }),
   _ts_metadata4("design:type", Function),
   _ts_metadata4("design:paramtypes", [
-    typeof import_wallet_solana2.SolanaWalletClient === "undefined" ? Object : import_wallet_solana2.SolanaWalletClient,
-    typeof DepositParameters === "undefined" ? Object : DepositParameters
+    typeof import_wallet_solana4.SolanaWalletClient === "undefined" ? Object : import_wallet_solana4.SolanaWalletClient,
+    typeof ClaimParameters === "undefined" ? Object : ClaimParameters
   ]),
   _ts_metadata4("design:returntype", Promise)
-], DepositTools.prototype, "wzrd_deposit", null);
-async function loadSdk() {
-  try {
-    return await import("@wzrd_sol/sdk");
-  } catch (error) {
-    const fallbackUrl = new URL("../../../../../sdk/dist/index.js", import_meta.url);
-    try {
-      return await import(fallbackUrl.href);
-    } catch {
-      throw error;
-    }
-  }
-}
-__name(loadSdk, "loadSdk");
-function formatUsdc2(nativeAmount) {
-  return (Number(nativeAmount) / 1e6).toFixed(4);
+], ClaimTools.prototype, "wzrd_claim", null);
+function formatCcm(nativeAmount) {
+  return (Number(nativeAmount) / 1e9).toFixed(2);
 }
-__name(formatUsdc2, "formatUsdc");
+__name(formatCcm, "formatCcm");
 
-// src/tools/claim.ts
+// src/tools/rewards.ts
 var import_core6 = require("@goat-sdk/core");
-var import_wallet_solana3 = require("@goat-sdk/wallet-solana");
+var import_wallet_solana5 = require("@goat-sdk/wallet-solana");
 function _ts_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -580,91 +560,36 @@ function _ts_metadata5(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata5, "_ts_metadata");
-var ClaimTools = class {
+var RewardsTools = class {
   static {
-    __name(this, "ClaimTools");
+    __name(this, "RewardsTools");
   }
-  api;
-  constructor(api) {
-    this.api = api;
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  async wzrd_claim(walletClient, parameters) {
-    const pubkey = walletClient.getAddress();
-    const token = await this.api.authenticate(walletClient);
-    const claimsRes = await fetch(`${this.api.apiUrl}/v1/claims/${pubkey}`, {
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!claimsRes.ok) {
-      throw new Error(`Claims check failed: ${claimsRes.status}`);
-    }
-    const claims = await claimsRes.json();
-    const claimable = claims.cumulative_total - claims.claimed_total;
-    if (claimable <= 0) {
-      return {
-        success: true,
-        summary: `No CCM to claim. Cumulative: ${formatCcm2(claims.cumulative_total)}, already claimed: ${formatCcm2(claims.claimed_total)}.`,
-        claimable: 0,
-        cumulative_total: claims.cumulative_total,
-        claimed_total: claims.claimed_total
-      };
-    }
-    if (parameters.execute === false) {
-      return {
-        success: true,
-        summary: `${formatCcm2(claimable)} CCM claimable (${formatCcm2(claims.cumulative_total)} cumulative, ${formatCcm2(claims.claimed_total)} claimed). Root seq: ${claims.root_seq}. Set execute=true to claim.`,
-        claimable,
-        cumulative_total: claims.cumulative_total,
-        claimed_total: claims.claimed_total,
-        root_seq: claims.root_seq
-      };
-    }
-    const relayRes = await fetch(`${this.api.apiUrl}/v1/claims/${pubkey}/relay`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json"
-      }
-    });
-    if (!relayRes.ok) {
-      throw new Error(`Relay claim failed: ${relayRes.status} ${await relayRes.text()}`);
-    }
-    const result = await relayRes.json();
-    if (result.status === "already_claimed") {
-      return {
-        success: true,
-        summary: `Already claimed through root ${result.root_seq}. Claimed total: ${formatCcm2(result.claimed_total ?? claims.claimed_total)} CCM.`,
-        already_claimed: true,
-        root_seq: result.root_seq
-      };
-    }
+  async wzrd_rewards(walletClient, _parameters) {
+    const rewards = await this.client.getRewards(walletClient);
     return {
-      success: true,
-      summary: `Claimed CCM via gasless relay. Cumulative: ${formatCcm2(result.cumulative_total)}. Root seq: ${result.root_seq}. Tx: ${result.tx_sig?.slice(0, 16)}...`,
-      cumulative_total: result.cumulative_total,
-      root_seq: result.root_seq,
-      tx_sig: result.tx_sig,
-      claimable_before: claimable,
-      explorer: result.tx_sig ? `https://solscan.io/tx/${result.tx_sig}` : null
+      summary: `WZRD Rewards: ${(rewards.pending_ccm / 1e9).toFixed(2)} CCM pending, ${(rewards.total_rewarded_ccm / 1e9).toFixed(2)} CCM lifetime, ${rewards.contribution_count} contributions` + (rewards.rank ? `, rank #${rewards.rank}` : ""),
+      pending_ccm: rewards.pending_ccm,
+      total_rewarded_ccm: rewards.total_rewarded_ccm,
+      contribution_count: rewards.contribution_count,
+      rank: rewards.rank
     };
   }
 };
 _ts_decorate5([
   (0, import_core6.Tool)({
-    description: "Claim accrued CCM tokens from your WZRD positions. Uses the gasless relay \u2014 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. Set execute=false to check claimable amount without claiming."
+    description: "Check your pending CCM rewards, lifetime total, and contribution count. Use this to see how much you've earned from WZRD inference before claiming."
   }),
   _ts_metadata5("design:type", Function),
   _ts_metadata5("design:paramtypes", [
-    typeof import_wallet_solana3.SolanaWalletClient === "undefined" ? Object : import_wallet_solana3.SolanaWalletClient,
-    typeof ClaimParameters === "undefined" ? Object : ClaimParameters
+    typeof import_wallet_solana5.SolanaWalletClient === "undefined" ? Object : import_wallet_solana5.SolanaWalletClient,
+    typeof RewardsParameters === "undefined" ? Object : RewardsParameters
   ]),
   _ts_metadata5("design:returntype", Promise)
-], ClaimTools.prototype, "wzrd_claim", null);
-function formatCcm2(nativeAmount) {
-  return (Number(nativeAmount) / 1e6).toFixed(4);
-}
-__name(formatCcm2, "formatCcm");
+], RewardsTools.prototype, "wzrd_rewards", null);
 
 // src/wzrd.plugin.ts
 var WzrdPlugin = class extends import_core7.PluginBase {
@@ -672,13 +597,13 @@ var WzrdPlugin = class extends import_core7.PluginBase {
     __name(this, "WzrdPlugin");
   }
   constructor(options) {
-    const api = new WzrdApiClient(options);
+    const client = new WzrdClient(options);
     super("wzrd", [
-      new LeaderboardTools(api),
-      new VelocityTools(api),
-      new PortfolioTools(api),
-      new DepositTools(api),
-      new ClaimTools(api)
+      new EarnTools(client),
+      new InferTools(client),
+      new ReportTools(client),
+      new ClaimTools(client),
+      new RewardsTools(client)
     ]);
   }
   supportsChain = /* @__PURE__ */ __name((chain) => chain.type === "solana", "supportsChain");
@@ -687,11 +612,11 @@ var wzrd = /* @__PURE__ */ __name((options) => new WzrdPlugin(options), "wzrd");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ClaimParameters,
-  DepositParameters,
-  GetLeaderboardParameters,
-  GetPortfolioParameters,
-  GetVelocitySignalParameters,
-  WzrdApiClient,
+  EarnParameters,
+  InferParameters,
+  ReportParameters,
+  RewardsParameters,
+  WzrdClient,
   WzrdPlugin,
   wzrd
 });