@wzrd_sol/solana-agent-plugin 0.1.1 → 0.2.0

package/dist/client.d.ts

@@ -2,6 +2,9 @@
  * WZRD API client — handles agent auth (Ed25519 challenge/verify),
  * token caching, and all REST calls.
  *
+ * Auth flow: challenge → sign → verify → Bearer token (24h TTL)
+ * Earn flow: infer → report(execution_id) → claim
+ *
  * Standalone: no framework dependency. Works with a Keypair or any wallet
  * implementation that supports `publicKey` + `signMessage()`.
  */
@@ -12,62 +15,61 @@ export interface WzrdSigner {
     signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
     secretKey?: Uint8Array;
 }
-export interface WzrdMarket {
+export interface InferResult {
+    execution_id: string;
+    model: string;
+    provider: string;
+    quality_score: number;
+    response: string;
+    latency_ms: number;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+}
+export interface ReportResult {
+    contribution_id: number;
+    verification_state: string;
+    quality_score: number | null;
+    model_id: string;
+}
+export interface RewardsBalance {
+    pending_ccm: number;
+    total_rewarded_ccm: number;
+    rank: number | null;
+    contribution_count: number;
+}
+export interface ClaimResult {
+    tx_sig: string | null;
+    root_seq: number;
+    cumulative_total: number;
+    status: string;
+}
+export interface ClaimStatus {
+    cumulative_total: number;
+    claimed_total: number;
+    claimable: number;
+}
+export interface LeaderboardMarket {
     market_id: number;
+    /** Metric label for the market (e.g. "downloads", "stars"). NOT a model id. */
+    metric: string;
+    /** Server-resolvable model id — pass this as `model` to infer. */
     channel_id: string;
     platform: string;
-    metric: string;
     velocity_ema: number;
     multiplier_bps: number;
-    position_count: number;
-    tvl_usdc: number;
-    rank: number;
-    status: string;
     snapshot_count: number;
-    last_scored_at: string;
-    depositable: boolean;
+    position_count?: number;
+    tvl_usdc?: number;
 }
-export interface WzrdLeaderboard {
-    markets: WzrdMarket[];
+export interface LeaderboardResult {
+    markets: LeaderboardMarket[];
     root: {
         root_seq: number;
-        root_hash: string;
-        published_slot: number;
+        root_hash?: string;
+        published_slot?: number;
     };
-    total_positions: number;
-    total_tvl_usdc: number;
-    total_snapshots: number;
-    updated_at: string;
-}
-export interface WzrdPosition {
-    market_id: number;
-    metric: string;
-    usdc_deposited: number;
-    vlofi_minted: number;
-    multiplier_bps: number;
-    status: string;
-    is_settled: boolean;
-}
-export interface WzrdPortfolio {
-    positions: WzrdPosition[];
-    total_deposited_usdc: number;
-    total_vlofi: number;
-    total_ccm_earned: number;
-}
-export interface WzrdClaim {
-    root_seq: number;
-    cumulative_total: number;
-    claimed_total: number;
-    leaf_index: number;
-    proof: string[];
-    accounts: Record<string, string>;
-}
-export interface WzrdRelayResult {
-    root_seq: number;
-    cumulative_total: number;
-    claimed_total?: number;
-    tx_sig?: string;
-    status?: 'already_claimed';
+    total_positions?: number;
+    total_tvl_usdc?: number;
 }
 export declare class WzrdClient {
     private readonly signer;
@@ -82,14 +84,29 @@ export declare class WzrdClient {
     private authenticate;
     private getToken;
     private authedFetch;
+    /**
+     * Pick a model from the leaderboard — returns the top market's `channel_id`,
+     * which is the server-resolvable model id accepted by `infer`. The leaderboard
+     * is not task-segmented, so the top market is returned regardless of task type
+     * (pass `task_type` to `infer` to steer the provider cascade instead).
+     */
+    pickModel(): Promise<string>;
+    /** Server-witnessed inference — WZRD calls the provider, grades quality */
+    infer(prompt: string, model?: string, taskType?: string): Promise<InferResult>;
+    /** Report model pick with execution_id for verified rewards */
+    report(params: {
+        model_id: string;
+        execution_id: string;
+        task_type?: string;
+        quality_score?: number;
+        latency_ms?: number;
+    }): Promise<ReportResult>;
+    /** Check pending + total rewards */
+    getRewards(): Promise<RewardsBalance>;
+    /** Gasless CCM claim via server relay */
+    claimRelay(): Promise<ClaimResult>;
+    /** Check claims status */
+    getClaimStatus(): Promise<ClaimStatus>;
     /** Fetch leaderboard — no auth required. */
-    getLeaderboard(limit?: number, platform?: string): Promise<WzrdLeaderboard>;
-    /** Fetch authenticated portfolio. */
-    getPortfolio(): Promise<WzrdPortfolio>;
-    /** Fetch claim data (proof + amounts). */
-    getClaims(): Promise<WzrdClaim>;
-    /** Execute gasless relay claim — server pays tx fees. */
-    claimRelay(): Promise<WzrdRelayResult>;
-    /** Fetch system health — no auth required. */
-    getHealth(): Promise<Record<string, unknown>>;
+    getLeaderboard(limit?: number): Promise<LeaderboardResult>;
 }

package/dist/client.js

@@ -2,12 +2,15 @@
  * WZRD API client — handles agent auth (Ed25519 challenge/verify),
  * token caching, and all REST calls.
  *
+ * Auth flow: challenge → sign → verify → Bearer token (24h TTL)
+ * Earn flow: infer → report(execution_id) → claim
+ *
  * Standalone: no framework dependency. Works with a Keypair or any wallet
  * implementation that supports `publicKey` + `signMessage()`.
  */
 import { Keypair } from '@solana/web3.js';
 export const DEFAULT_API_URL = 'https://api.twzrd.xyz';
-const TOKEN_REFRESH_MARGIN_MS = 5 * 60 * 1000;
+const TOKEN_REFRESH_MARGIN_MS = 60 * 60 * 1000; // refresh 1h before expiry
 // ── Base58 encoder (zero-dependency) ────────────────────
 const B58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 function toBase58(bytes) {
@@ -66,7 +69,7 @@ export class WzrdClient {
     // ── Auth ────────────────────────────────────────────
     async authenticate() {
         // 1. Challenge
-        const cr = await fetch(`${this.apiUrl}/v1/agent/challenge`);
+        const cr = await fetch(`${this.apiUrl}/v1/agent/challenge?pubkey=${this.pubkey}`);
         if (!cr.ok)
             throw new Error(`Challenge failed: ${cr.status}`);
         const { nonce } = (await cr.json());
@@ -87,7 +90,9 @@ export class WzrdClient {
             throw new Error(`Verify failed: ${vr.status} ${await vr.text()}`);
         const { token, expires_at } = (await vr.json());
         this.token = token;
-        this.tokenExpiresAt = new Date(expires_at).getTime();
+        this.tokenExpiresAt = expires_at
+            ? new Date(expires_at).getTime()
+            : Date.now() + 23 * 60 * 60 * 1000;
     }
     async getToken() {
         if (!this.token ||
@@ -98,51 +103,92 @@ export class WzrdClient {
     }
     async authedFetch(path, init) {
         const token = await this.getToken();
-        return fetch(`${this.apiUrl}${path}`, {
-            ...init,
-            headers: { ...init?.headers, Authorization: `Bearer ${token}` },
-        });
+        const headers = new Headers(init?.headers);
+        headers.set('Authorization', `Bearer ${token}`);
+        headers.set('Content-Type', 'application/json');
+        return fetch(`${this.apiUrl}${path}`, { ...init, headers });
     }
-    // ── Public API ──────────────────────────────────────
-    /** Fetch leaderboard — no auth required. */
-    async getLeaderboard(limit = 20, platform) {
-        const params = new URLSearchParams({ limit: String(limit) });
-        if (platform)
-            params.set('platform', platform);
-        const res = await fetch(`${this.apiUrl}/v1/leaderboard?${params}`);
-        if (!res.ok)
-            throw new Error(`Leaderboard failed: ${res.status}`);
-        return (await res.json());
+    // ── Earn Loop API ─────────────────────────────────
+    /**
+     * Pick a model from the leaderboard — returns the top market's `channel_id`,
+     * which is the server-resolvable model id accepted by `infer`. The leaderboard
+     * is not task-segmented, so the top market is returned regardless of task type
+     * (pass `task_type` to `infer` to steer the provider cascade instead).
+     */
+    async pickModel() {
+        const lb = await this.getLeaderboard(10);
+        if (!lb.markets.length)
+            throw new Error('No models available on leaderboard');
+        return lb.markets[0].channel_id;
     }
-    /** Fetch authenticated portfolio. */
-    async getPortfolio() {
-        const res = await this.authedFetch('/v1/portfolio');
-        if (!res.ok)
-            throw new Error(`Portfolio failed: ${res.status}`);
-        return (await res.json());
+    /** Server-witnessed inference — WZRD calls the provider, grades quality */
+    async infer(prompt, model, taskType) {
+        const resolvedModel = model || await this.pickModel();
+        const res = await this.authedFetch('/v1/agent/infer', {
+            method: 'POST',
+            body: JSON.stringify({ model: resolvedModel, prompt, task_type: taskType || 'chat' }),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Infer failed (${res.status}): ${body}`);
+        }
+        return res.json();
     }
-    /** Fetch claim data (proof + amounts). */
-    async getClaims() {
-        const res = await this.authedFetch(`/v1/claims/${this.pubkey}`);
+    /** Report model pick with execution_id for verified rewards */
+    async report(params) {
+        const res = await this.authedFetch('/v1/agent/report', {
+            method: 'POST',
+            body: JSON.stringify(params),
+        });
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Report failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Check pending + total rewards */
+    async getRewards() {
+        const res = await this.authedFetch('/v1/agent/earned');
         if (!res.ok)
-            throw new Error(`Claims failed: ${res.status}`);
-        return (await res.json());
+            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),
+        };
     }
-    /** Execute gasless relay claim — server pays tx fees. */
+    /** Gasless CCM claim via server relay */
     async claimRelay() {
         const res = await this.authedFetch(`/v1/claims/${this.pubkey}/relay`, {
             method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
         });
-        if (!res.ok)
-            throw new Error(`Relay claim failed: ${res.status} ${await res.text()}`);
-        return (await res.json());
+        if (!res.ok) {
+            const body = await res.text().catch(() => '');
+            throw new Error(`Relay claim failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Check claims status */
+    async getClaimStatus() {
+        const res = await this.authedFetch(`/v1/claims/${this.pubkey}`);
+        if (!res.ok) {
+            if (res.status === 404)
+                return { cumulative_total: 0, claimed_total: 0, claimable: 0 };
+            throw new Error(`Claim status failed: ${res.status}`);
+        }
+        const data = (await res.json());
+        return { ...data, claimable: data.cumulative_total - data.claimed_total };
     }
-    /** Fetch system health — no auth required. */
-    async getHealth() {
-        const res = await fetch(`${this.apiUrl}/health`);
+    // ── Public API ──────────────────────────────────────
+    /** Fetch leaderboard — no auth required. */
+    async getLeaderboard(limit = 20) {
+        const res = await fetch(`${this.apiUrl}/v1/leaderboard?limit=${limit}`);
         if (!res.ok)
-            throw new Error(`Health failed: ${res.status}`);
+            throw new Error(`Leaderboard failed: ${res.status}`);
         return (await res.json());
     }
 }

package/dist/index.d.ts

@@ -1,41 +1,38 @@
 /**
  * @wzrd_sol/solana-agent-plugin
  *
- * WZRD Liquid Attention Protocol plugin for autonomous Solana agents.
+ * WZRD Liquid Attention Protocol plugin for Solana Agent Kit.
+ * Server-witnessed inference earn loop — infer, report, claim CCM.
  *
  * 5 actions:
- *   wzrd_leaderboard — browse attention markets (no auth)
- *   wzrd_velocity    — classify signal strength (no auth)
- *   wzrd_portfolio   — view positions + CCM earned (auth)
- *   wzrd_deposit     — deposit USDC → mint vLOFI (auth + keypair)
- *   wzrd_claim       — claim CCM via gasless relay (auth)
+ *   wzrd_earn      — full earn cycle (one-shot)
+ *   wzrd_infer     — server-witnessed inference
+ *   wzrd_report    — report with execution receipt
+ *   wzrd_claim     — gasless CCM claim
+ *   wzrd_rewards   — check pending + lifetime rewards
  *
  * Works with:
  *   - Solana Agent Kit (SendAI) — register as plugin
- *   - ElizaOS — wrap actions as ELIZA-style actions
  *   - Standalone — use WzrdClient directly
  *
  * Quick start:
  *   import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
  *   const client = new WzrdClient(keypair);
- *   const leaderboard = await client.getLeaderboard();
+ *   const result = await client.infer('Write a Python quicksort');
  */
 export { WzrdClient } from './client.js';
-export type { WzrdMarket, WzrdLeaderboard, WzrdPosition, WzrdPortfolio, WzrdClaim, WzrdRelayResult, } from './client.js';
-export { LEADERBOARD_ACTION, PORTFOLIO_ACTION, DEPOSIT_ACTION, CLAIM_ACTION, VELOCITY_ACTION, } from './actions/index.js';
-export type { MarketSignal } from './actions/index.js';
+export type { WzrdSigner, InferResult, ReportResult, RewardsBalance, ClaimResult, ClaimStatus, LeaderboardMarket, LeaderboardResult, } from './client.js';
+export { EARN_ACTION, INFER_ACTION, REPORT_ACTION, CLAIM_ACTION, REWARDS_ACTION, } from './actions/index.js';
 import type { Plugin } from 'solana-agent-kit';
-import { getClaimsData, getClientForAgent, getLeaderboardData } from './runtime.js';
-import { type MarketSignal } from './actions/velocity.js';
+import { getClientForAgent } from './runtime.js';
 export declare const WZRD_ACTIONS: Plugin["actions"];
 export interface WzrdPluginMethods {
-    wzrdLeaderboard(limit?: number, platform?: string): Promise<ReturnType<typeof getLeaderboardData>>;
-    wzrdPortfolio(): Promise<ReturnType<typeof getClientForAgent>['getPortfolio']>;
-    wzrdClaims(): Promise<ReturnType<typeof getClaimsData>>;
-    wzrdDeposit(marketId: number, amountUsdc: number, priorityFee?: number): Promise<Record<string, unknown>>;
-    wzrdClaim(execute?: boolean): Promise<Record<string, unknown>>;
-    wzrdVelocity(platform?: string, minSignal?: MarketSignal['signal']): Promise<Record<string, unknown>>;
     wzrdClient(): ReturnType<typeof getClientForAgent>;
+    wzrdEarn(taskType?: string, prompt?: string): Promise<Record<string, unknown>>;
+    wzrdInfer(prompt: string, model?: string, taskType?: string): Promise<Record<string, unknown>>;
+    wzrdReport(modelId: string, executionId: string, taskType?: string, qualityScore?: number, latencyMs?: number): Promise<Record<string, unknown>>;
+    wzrdClaim(): Promise<Record<string, unknown>>;
+    wzrdRewards(): Promise<Record<string, unknown>>;
 }
 export declare function createWzrdPlugin(): Plugin;
 /** Default plugin instance for direct registration via `agent.use(...)`. */

package/dist/index.js

@@ -1,39 +1,39 @@
 /**
  * @wzrd_sol/solana-agent-plugin
  *
- * WZRD Liquid Attention Protocol plugin for autonomous Solana agents.
+ * WZRD Liquid Attention Protocol plugin for Solana Agent Kit.
+ * Server-witnessed inference earn loop — infer, report, claim CCM.
  *
  * 5 actions:
- *   wzrd_leaderboard — browse attention markets (no auth)
- *   wzrd_velocity    — classify signal strength (no auth)
- *   wzrd_portfolio   — view positions + CCM earned (auth)
- *   wzrd_deposit     — deposit USDC → mint vLOFI (auth + keypair)
- *   wzrd_claim       — claim CCM via gasless relay (auth)
+ *   wzrd_earn      — full earn cycle (one-shot)
+ *   wzrd_infer     — server-witnessed inference
+ *   wzrd_report    — report with execution receipt
+ *   wzrd_claim     — gasless CCM claim
+ *   wzrd_rewards   — check pending + lifetime rewards
  *
  * Works with:
  *   - Solana Agent Kit (SendAI) — register as plugin
- *   - ElizaOS — wrap actions as ELIZA-style actions
  *   - Standalone — use WzrdClient directly
  *
  * Quick start:
  *   import { WzrdClient } from '@wzrd_sol/solana-agent-plugin';
  *   const client = new WzrdClient(keypair);
- *   const leaderboard = await client.getLeaderboard();
+ *   const result = await client.infer('Write a Python quicksort');
  */
 export { WzrdClient } from './client.js';
-export { LEADERBOARD_ACTION, PORTFOLIO_ACTION, DEPOSIT_ACTION, CLAIM_ACTION, VELOCITY_ACTION, } from './actions/index.js';
-import { getClaimsData, getClientForAgent, getLeaderboardData } from './runtime.js';
-import { LEADERBOARD_ACTION } from './actions/leaderboard.js';
-import { PORTFOLIO_ACTION } from './actions/portfolio.js';
-import { DEPOSIT_ACTION, depositHandler } from './actions/deposit.js';
+export { EARN_ACTION, INFER_ACTION, REPORT_ACTION, CLAIM_ACTION, REWARDS_ACTION, } from './actions/index.js';
+import { getClientForAgent } from './runtime.js';
+import { EARN_ACTION, earnHandler } from './actions/earn.js';
+import { INFER_ACTION, inferHandler } from './actions/infer.js';
+import { REPORT_ACTION, reportHandler } from './actions/report.js';
 import { CLAIM_ACTION, claimHandler } from './actions/claim.js';
-import { VELOCITY_ACTION, velocityHandler } from './actions/velocity.js';
+import { REWARDS_ACTION, rewardsHandler } from './actions/rewards.js';
 export const WZRD_ACTIONS = [
-    LEADERBOARD_ACTION,
-    PORTFOLIO_ACTION,
-    DEPOSIT_ACTION,
+    EARN_ACTION,
+    INFER_ACTION,
+    REPORT_ACTION,
     CLAIM_ACTION,
-    VELOCITY_ACTION,
+    REWARDS_ACTION,
 ];
 export function createWzrdPlugin() {
     let agentRef = null;
@@ -52,30 +52,26 @@ export function createWzrdPlugin() {
             wzrdClient() {
                 return getClientForAgent(requireAgent());
             },
-            async wzrdLeaderboard(limit = 20, platform) {
-                return getLeaderboardData(requireAgent(), { limit, platform });
+            async wzrdEarn(taskType, prompt) {
+                return earnHandler(requireAgent(), { task_type: taskType, prompt });
             },
-            async wzrdPortfolio() {
-                return getClientForAgent(requireAgent()).getPortfolio();
+            async wzrdInfer(prompt, model, taskType) {
+                return inferHandler(requireAgent(), { prompt, model, task_type: taskType });
             },
-            async wzrdClaims() {
-                return getClaimsData(requireAgent());
-            },
-            async wzrdDeposit(marketId, amountUsdc, priorityFee) {
-                return depositHandler(requireAgent(), {
-                    market_id: marketId,
-                    amount_usdc: amountUsdc,
-                    priority_fee: priorityFee,
+            async wzrdReport(modelId, executionId, taskType, qualityScore, latencyMs) {
+                return reportHandler(requireAgent(), {
+                    model_id: modelId,
+                    execution_id: executionId,
+                    task_type: taskType,
+                    quality_score: qualityScore,
+                    latency_ms: latencyMs,
                 });
             },
-            async wzrdClaim(execute = true) {
-                return claimHandler(requireAgent(), { execute });
+            async wzrdClaim() {
+                return claimHandler(requireAgent(), {});
             },
-            async wzrdVelocity(platform, minSignal) {
-                return velocityHandler(requireAgent(), {
-                    platform,
-                    min_signal: minSignal,
-                });
+            async wzrdRewards() {
+                return rewardsHandler(requireAgent(), {});
             },
         },
         actions: WZRD_ACTIONS,

package/dist/runtime.d.ts

@@ -1,16 +1,5 @@
-import { PublicKey } from '@solana/web3.js';
 import type { SolanaAgentKit } from 'solana-agent-kit';
-import { WzrdClient, type WzrdClaim, type WzrdLeaderboard, type WzrdPortfolio } from './client.js';
-export type SignalTier = 'BREAKOUT' | 'MOMENTUM' | 'EMERGING' | 'STABLE' | 'COOLING' | 'WEAK';
+import { WzrdClient } from './client.js';
 export declare function resolveApiUrl(explicit?: string): string;
 export declare function getClientForAgent(agent: SolanaAgentKit, apiUrl?: string): WzrdClient;
-export declare function getWalletPublicKey(agent: SolanaAgentKit): PublicKey;
-export declare function formatVelocity(v: number): string;
-export declare function formatUsdc(nativeAmount: number | bigint): string;
 export declare function formatCcm(nativeAmount: number | bigint): string;
-export declare function getLeaderboardData(agent: SolanaAgentKit, input: {
-    limit?: number;
-    platform?: string;
-}): Promise<WzrdLeaderboard>;
-export declare function getPortfolioData(agent: SolanaAgentKit): Promise<WzrdPortfolio>;
-export declare function getClaimsData(agent: SolanaAgentKit): Promise<WzrdClaim>;

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { DEFAULT_API_URL, WzrdClient, } from './client.js';
+import { DEFAULT_API_URL, WzrdClient } from './client.js';
 export function resolveApiUrl(explicit) {
     const envUrl = process.env.WZRD_API_URL?.trim();
     return explicit?.trim() || envUrl || DEFAULT_API_URL;
@@ -6,28 +6,6 @@ export function resolveApiUrl(explicit) {
 export function getClientForAgent(agent, apiUrl) {
     return new WzrdClient(agent.wallet, resolveApiUrl(apiUrl));
 }
-export function getWalletPublicKey(agent) {
-    return agent.wallet.publicKey;
-}
-export function formatVelocity(v) {
-    if (v >= 1_000_000)
-        return `${(v / 1_000_000).toFixed(1)}M`;
-    if (v >= 1_000)
-        return `${(v / 1_000).toFixed(0)}K`;
-    return v.toFixed(0);
-}
-export function formatUsdc(nativeAmount) {
-    return (Number(nativeAmount) / 1_000_000).toFixed(4);
-}
 export function formatCcm(nativeAmount) {
-    return (Number(nativeAmount) / 1_000_000).toFixed(4);
-}
-export async function getLeaderboardData(agent, input) {
-    return getClientForAgent(agent).getLeaderboard(input.limit ?? 10, input.platform);
-}
-export async function getPortfolioData(agent) {
-    return getClientForAgent(agent).getPortfolio();
-}
-export async function getClaimsData(agent) {
-    return getClientForAgent(agent).getClaims();
+    return (Number(nativeAmount) / 1e9).toFixed(2);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wzrd_sol/solana-agent-plugin",
-  "version": "0.1.1",
-  "description": "WZRD Liquid Attention Protocol plugin for Solana Agent Kit — deposit, claim, leaderboard, portfolio, velocity signal",
+  "version": "0.2.0",
+  "description": "WZRD Liquid Attention Protocol plugin for Solana Agent Kit — server-witnessed inference, verified CCM rewards, gasless claims",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,11 +14,16 @@
   },
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "prepack": "npm run build"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "dependencies": {
     "@solana/web3.js": "^1.95.0",
-    "@wzrd_sol/sdk": "^0.1.1",
     "tweetnacl": "^1.0.3",
     "zod": "^3.25.76"
   },
@@ -38,15 +43,19 @@
     "solana",
     "agent",
     "wzrd",
-    "attention",
-    "defi",
-    "mcp",
+    "ccm",
+    "inference",
+    "earn",
     "ai-agent",
     "solana-agent-kit"
   ],
   "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/twzrd-sol/wzrd-final"
+    "url": "git+https://github.com/twzrd-sol/wzrd-velocity.git",
+    "directory": "agents/solana-agent-kit-plugin"
   }
 }

package/dist/actions/deposit.d.ts

@@ -1,26 +0,0 @@
-/**
- * Action: wzrd_deposit
- *
- * Deposit USDC into a WZRD attention market → mint vLOFI tokens.
- * Requires: Keypair with USDC balance + SOL for tx fees.
- *
- * The agent picks a market_id (from leaderboard), specifies USDC amount,
- * and the handler builds + signs + sends the deposit transaction.
- */
-import { z } from 'zod';
-import type { Action, SolanaAgentKit } from 'solana-agent-kit';
-export declare const depositSchema: z.ZodObject<{
-    market_id: z.ZodNumber;
-    amount_usdc: z.ZodNumber;
-    priority_fee: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    market_id: number;
-    amount_usdc: number;
-    priority_fee?: number | undefined;
-}, {
-    market_id: number;
-    amount_usdc: number;
-    priority_fee?: number | undefined;
-}>;
-export declare function depositHandler(agent: SolanaAgentKit, input: z.infer<typeof depositSchema>): Promise<Record<string, unknown>>;
-export declare const DEPOSIT_ACTION: Action;