@wzrd_sol/goat-plugin 0.1.0

package/dist/index.mjs

@@ -0,0 +1,655 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/wzrd.plugin.ts
+import { PluginBase } from "@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 {
+  static {
+    __name(this, "WzrdApiClient");
+  }
+  apiUrl;
+  // Cache auth tokens per wallet address to avoid re-auth on every tool call
+  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.
+  */
+  async authenticate(walletClient) {
+    const address = walletClient.getAddress();
+    const cached = this.tokenCache.get(address);
+    if (cached && Date.now() < cached.expiresAt - TOKEN_REFRESH_MARGIN_MS) {
+      return cached.token;
+    }
+    const challengeRes = await fetch(`${this.apiUrl}/v1/agent/challenge`);
+    if (!challengeRes.ok) {
+      throw new Error(`WZRD auth challenge failed: ${challengeRes.status}`);
+    }
+    const { nonce } = await challengeRes.json();
+    const message = `wzrd-agent-auth v1 | wallet:${address} | nonce:${nonce}`;
+    const { signature: sigHex } = await walletClient.signMessage(message);
+    const sigBytes = hexToBytes(sigHex);
+    const sigBase58 = toBase58(sigBytes);
+    const verifyRes = await fetch(`${this.apiUrl}/v1/agent/verify`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        pubkey: address,
+        nonce,
+        signature: sigBase58
+      })
+    });
+    if (!verifyRes.ok) {
+      throw new Error(`WZRD auth verify failed: ${verifyRes.status} ${await verifyRes.text()}`);
+    }
+    const { token, expires_at } = await verifyRes.json();
+    this.tokenCache.set(address, {
+      token,
+      expiresAt: new Date(expires_at).getTime()
+    });
+    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;
+    }
+    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");
+
+// src/tools/leaderboard.ts
+import { Tool } from "@goat-sdk/core";
+
+// src/parameters.ts
+import { createToolParameters } from "@goat-sdk/core";
+import { z } from "zod";
+var GetLeaderboardParameters = class extends createToolParameters(z.object({
+  limit: z.number().int().min(1).max(50).optional().describe("Number of markets to return (default 20, max 50)"),
+  platform: z.string().optional().describe("Filter by platform: 'huggingface', 'github', or omit for all")
+})) {
+  static {
+    __name(this, "GetLeaderboardParameters");
+  }
+};
+var GetVelocitySignalParameters = class extends createToolParameters(z.object({
+  platform: z.string().optional().describe("Filter by platform: 'huggingface', 'github'"),
+  min_signal: 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.")
+})) {
+  static {
+    __name(this, "GetVelocitySignalParameters");
+  }
+};
+var GetPortfolioParameters = class extends createToolParameters(z.object({})) {
+  static {
+    __name(this, "GetPortfolioParameters");
+  }
+};
+var DepositParameters = class extends createToolParameters(z.object({
+  market_id: z.number().int().min(1).describe("Market ID to deposit into (get from wzrd_get_leaderboard)"),
+  amount_usdc: z.number().positive().max(100).describe("Amount of USDC to deposit (e.g. 0.01). Max 100 per deposit."),
+  priority_fee: z.number().int().positive().optional().describe("Priority fee in micro-lamports (default 50000). Higher = faster inclusion.")
+})) {
+  static {
+    __name(this, "DepositParameters");
+  }
+};
+var ClaimParameters = class extends createToolParameters(z.object({
+  execute: z.boolean().optional().describe("If false, only check claimable amount without executing. Default true.")
+})) {
+  static {
+    __name(this, "ClaimParameters");
+  }
+};
+
+// src/tools/leaderboard.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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+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 {
+  static {
+    __name(this, "LeaderboardTools");
+  }
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  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");
+    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
+    };
+  }
+};
+_ts_decorate([
+  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."
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof GetLeaderboardParameters === "undefined" ? Object : GetLeaderboardParameters
+  ]),
+  _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");
+
+// src/tools/velocity.ts
+import { Tool as Tool2 } from "@goat-sdk/core";
+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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+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 {
+  static {
+    __name(this, "VelocityTools");
+  }
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  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)
+      };
+    });
+    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
+    };
+  }
+};
+_ts_decorate2([
+  Tool2({
+    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."
+  }),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof GetVelocitySignalParameters === "undefined" ? Object : GetVelocitySignalParameters
+  ]),
+  _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");
+
+// src/tools/portfolio.ts
+import { Tool as Tool3 } from "@goat-sdk/core";
+import { SolanaWalletClient } from "@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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+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 {
+  static {
+    __name(this, "PortfolioTools");
+  }
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  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}`
+      }
+    });
+    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]" : ""));
+    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
+    };
+  }
+};
+_ts_decorate3([
+  Tool3({
+    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."
+  }),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof SolanaWalletClient === "undefined" ? Object : SolanaWalletClient,
+    typeof GetPortfolioParameters === "undefined" ? Object : GetPortfolioParameters
+  ]),
+  _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");
+
+// src/tools/deposit.ts
+import { Tool as Tool4 } from "@goat-sdk/core";
+import { SolanaWalletClient as SolanaWalletClient2 } from "@goat-sdk/wallet-solana";
+import { ComputeBudgetProgram, PublicKey } from "@solana/web3.js";
+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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+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 {
+  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 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) {
+      return {
+        success: false,
+        error: `Insufficient USDC: have ${formatUsdc2(usdcBalance)}, need ${amount_usdc.toFixed(4)}`,
+        market_id,
+        required_native: amountNative.toString(),
+        balance_native: usdcBalance.toString()
+      };
+    }
+    const solBalance = await connection.getBalance(payer);
+    if (solBalance < 1e4) {
+      return {
+        success: false,
+        error: `Insufficient SOL for tx fees: ${solBalance} lamports`,
+        market_id,
+        sol_balance_lamports: solBalance
+      };
+    }
+    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(ComputeBudgetProgram.setComputeUnitLimit({
+      units: 3e5
+    }), 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}`
+    };
+  }
+};
+_ts_decorate4([
+  Tool4({
+    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."
+  }),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof SolanaWalletClient2 === "undefined" ? Object : SolanaWalletClient2,
+    typeof DepositParameters === "undefined" ? Object : DepositParameters
+  ]),
+  _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);
+}
+__name(formatUsdc2, "formatUsdc");
+
+// src/tools/claim.ts
+import { Tool as Tool5 } from "@goat-sdk/core";
+import { SolanaWalletClient as SolanaWalletClient3 } from "@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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+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 {
+  static {
+    __name(this, "ClaimTools");
+  }
+  api;
+  constructor(api) {
+    this.api = api;
+  }
+  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
+      };
+    }
+    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
+    };
+  }
+};
+_ts_decorate5([
+  Tool5({
+    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."
+  }),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof SolanaWalletClient3 === "undefined" ? Object : SolanaWalletClient3,
+    typeof ClaimParameters === "undefined" ? Object : ClaimParameters
+  ]),
+  _ts_metadata5("design:returntype", Promise)
+], ClaimTools.prototype, "wzrd_claim", null);
+function formatCcm2(nativeAmount) {
+  return (Number(nativeAmount) / 1e6).toFixed(4);
+}
+__name(formatCcm2, "formatCcm");
+
+// src/wzrd.plugin.ts
+var WzrdPlugin = class extends PluginBase {
+  static {
+    __name(this, "WzrdPlugin");
+  }
+  constructor(options) {
+    const api = new WzrdApiClient(options);
+    super("wzrd", [
+      new LeaderboardTools(api),
+      new VelocityTools(api),
+      new PortfolioTools(api),
+      new DepositTools(api),
+      new ClaimTools(api)
+    ]);
+  }
+  supportsChain = /* @__PURE__ */ __name((chain) => chain.type === "solana", "supportsChain");
+};
+var wzrd = /* @__PURE__ */ __name((options) => new WzrdPlugin(options), "wzrd");
+export {
+  ClaimParameters,
+  DepositParameters,
+  GetLeaderboardParameters,
+  GetPortfolioParameters,
+  GetVelocitySignalParameters,
+  WzrdApiClient,
+  WzrdPlugin,
+  wzrd
+};
+//# sourceMappingURL=index.mjs.map