@wzrd_sol/sdk 0.1.2 → 0.3.0

package/dist/agent-loop.d.ts

@@ -0,0 +1,87 @@
+/**
+ * AgentLoop — turn any TypeScript agent into a WZRD earning agent.
+ *
+ * Ports the core earn loop from Python `wzrd.run_loop()` to TypeScript:
+ *   1. Auth via Ed25519 challenge/verify
+ *   2. Per task: fetchPick() (momentum API) -> agentInfer() -> agentReport()
+ *   3. Check earned -> relay claim if available
+ *   4. Sleep -> repeat
+ *
+ * Scoring parity with Python: confidence × action × trend × task-platform × quality.
+ *
+ * @example
+ * ```ts
+ * import { AgentLoop } from '@wzrd_sol/sdk';
+ * import { Keypair } from '@solana/web3.js';
+ *
+ * const loop = new AgentLoop({
+ *   keypair: Keypair.fromSecretKey(secretKey),
+ *   tasks: ['code', 'chat', 'reasoning'],
+ *   cycleSeconds: 300,
+ * });
+ *
+ * loop.start(); // runs forever, handles auth + infer + report + claim
+ * ```
+ *
+ * @module agent-loop
+ */
+import type { Keypair } from '@solana/web3.js';
+import type { EarnedResponse } from './agent-auth.js';
+/** Result of a single cycle, delivered via onCycle callback. */
+export interface CycleResult {
+    cycle: number;
+    tasks: Array<{
+        task: string;
+        model: string | null;
+        qualityScore: number | null;
+        executionId: string | null;
+        pendingCcm: number;
+    }>;
+    earned: EarnedResponse | null;
+    error: string | null;
+}
+/** Configuration for the AgentLoop. */
+export interface AgentLoopOptions {
+    /** Solana keypair for Ed25519 signing. */
+    keypair: Keypair;
+    /** Task types to report on each cycle. Default: ['code', 'chat', 'reasoning']. */
+    tasks?: string[];
+    /** Seconds between cycles (minimum 30). Default: 300. */
+    cycleSeconds?: number;
+    /** Stop after N cycles. Omit or 0 for infinite. */
+    maxCycles?: number;
+    /** Attempt gasless relay claim when CCM is claimable. Default: true. */
+    claim?: boolean;
+    /** API base URL. Default: 'https://api.twzrd.xyz'. */
+    apiBase?: string;
+    /** Optional callback invoked after each cycle completes. */
+    onCycle?: (result: CycleResult) => void;
+}
+/**
+ * Runs the WZRD earn loop: authenticate, pick models, infer, report, claim.
+ *
+ * Create one instance and call `start()`. The loop runs until `maxCycles`
+ * is reached or `stop()` is called. Handles SIGINT/SIGTERM for graceful
+ * shutdown.
+ */
+export declare class AgentLoop {
+    private readonly keypair;
+    private readonly tasks;
+    private readonly cycleSeconds;
+    private readonly maxCycles;
+    private readonly claim;
+    private readonly apiBase;
+    private readonly onCycle?;
+    private running;
+    private token;
+    private sleepResolve;
+    constructor(options: AgentLoopOptions);
+    /**
+     * Start the earn loop. Blocks until maxCycles is reached or stop() is called.
+     */
+    start(): Promise<void>;
+    /**
+     * Signal the loop to stop after the current cycle completes.
+     */
+    stop(): void;
+}

package/dist/agent-loop.js

@@ -0,0 +1,388 @@
+/**
+ * AgentLoop — turn any TypeScript agent into a WZRD earning agent.
+ *
+ * Ports the core earn loop from Python `wzrd.run_loop()` to TypeScript:
+ *   1. Auth via Ed25519 challenge/verify
+ *   2. Per task: fetchPick() (momentum API) -> agentInfer() -> agentReport()
+ *   3. Check earned -> relay claim if available
+ *   4. Sleep -> repeat
+ *
+ * Scoring parity with Python: confidence × action × trend × task-platform × quality.
+ *
+ * @example
+ * ```ts
+ * import { AgentLoop } from '@wzrd_sol/sdk';
+ * import { Keypair } from '@solana/web3.js';
+ *
+ * const loop = new AgentLoop({
+ *   keypair: Keypair.fromSecretKey(secretKey),
+ *   tasks: ['code', 'chat', 'reasoning'],
+ *   cycleSeconds: 300,
+ * });
+ *
+ * loop.start(); // runs forever, handles auth + infer + report + claim
+ * ```
+ *
+ * @module agent-loop
+ */
+import { agentAuth, agentInfer, agentReport, agentEarned, } from './agent-auth.js';
+// ── Constants ────────────────────────────────────────────────────
+const DEFAULT_TASKS = ['code', 'chat', 'reasoning'];
+const DEFAULT_CYCLE_SECONDS = 300;
+const MIN_CYCLE_SECONDS = 30;
+const SESSION_REFRESH_CYCLES = 100;
+// ── Helpers ──────────────────────────────────────────────────────
+function timestamp() {
+    return new Date().toISOString().substring(11, 19);
+}
+function log(msg) {
+    console.log(`${timestamp()} [wzrd] ${msg}`);
+}
+function fmtCcm(raw) {
+    if (!raw)
+        return '0 CCM';
+    const human = Math.floor(raw / 1e6).toLocaleString();
+    return `${human} CCM`;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Scoring weights — exact parity with Python client._TREND_WEIGHTS etc.
+const TREND_WEIGHTS = {
+    surging: 3.0, accelerating: 2.0, stable: 1.0, onchain: 1.0,
+    insufficient_history: 0.8, decelerating: 0.5, cooling: 0.25,
+};
+const CONFIDENCE_WEIGHTS = {
+    normal: 1.0, high: 1.0, low: 0.6, insufficient: 0.35, unknown: 0.75,
+};
+const ACTION_WEIGHTS = {
+    pre_warm_urgent: 1.2, pre_warm: 1.1, candidate: 1.0, recommend: 1.0,
+    onchain: 1.0, route: 1.0, maintain: 0.9, prewarm: 0.95,
+    evaluate: 0.9, watch: 0.6, consider_deprovision: 0.3, observe: 0.25,
+};
+const TASK_PLATFORM_WEIGHTS = {
+    code: { github: 1.5, openrouter: 1.2, artificial_analysis: 1.1, huggingface: 1.0 },
+    coding: { github: 1.5, openrouter: 1.2, artificial_analysis: 1.1, huggingface: 1.0 },
+    chat: { openrouter: 1.5, artificial_analysis: 1.1, github: 0.8, huggingface: 1.0 },
+    conversation: { openrouter: 1.5, artificial_analysis: 1.1, github: 0.8, huggingface: 1.0 },
+    reasoning: { artificial_analysis: 1.5, openrouter: 1.2, github: 0.8, huggingface: 1.0 },
+    math: { artificial_analysis: 1.5, openrouter: 1.2, github: 0.8, huggingface: 1.0 },
+};
+const TRUSTED_CONFIDENCE = new Set(['normal', 'high']);
+const RELAXED_CONFIDENCE = new Set(['normal', 'high', 'low']);
+const CAP_MAP = {
+    code: 'code', coding: 'code', chat: 'chat', conversation: 'chat',
+    reasoning: 'reasoning', math: 'reasoning', vision: 'vision',
+};
+/**
+ * Pick the top model for a task from the momentum API.
+ * Full parity with Python client._rank_signals() scoring:
+ * score × trend × confidence × action × task-platform × quality
+ */
+async function fetchPick(task, apiBase) {
+    try {
+        const resp = await fetch(`${apiBase}/v1/signals/momentum`);
+        if (!resp.ok)
+            return null;
+        const data = await resp.json();
+        const models = data.models ?? [];
+        if (models.length === 0)
+            return null;
+        // Step 1: Filter by capability
+        const requiredCap = CAP_MAP[task];
+        const capFiltered = requiredCap
+            ? models.filter((m) => m.capabilities?.includes(requiredCap))
+            : models;
+        const afterCap = capFiltered.length > 0 ? capFiltered : models;
+        // Step 2: Filter by confidence + action (trusted → relaxed → all)
+        const trusted = afterCap.filter((m) => TRUSTED_CONFIDENCE.has(m.confidence) && m.action !== 'observe');
+        const relaxed = afterCap.filter((m) => RELAXED_CONFIDENCE.has(m.confidence) && m.action !== 'observe');
+        const pool = trusted.length > 0 ? trusted : relaxed.length > 0 ? relaxed : afterCap;
+        // Step 3: Score with full 5-layer weighting
+        const taskKey = task.toLowerCase().trim();
+        const platformWeights = TASK_PLATFORM_WEIGHTS[taskKey] ?? {};
+        const scored = pool.map((m) => {
+            const rawScore = m.score ?? 0;
+            let s = rawScore;
+            s *= TREND_WEIGHTS[m.trend] ?? 1.0;
+            s *= CONFIDENCE_WEIGHTS[m.confidence] ?? CONFIDENCE_WEIGHTS.unknown;
+            s *= ACTION_WEIGHTS[m.action] ?? 1.0;
+            s *= platformWeights[m.platform?.toLowerCase()] ?? 1.0;
+            if (m.quality_index != null && m.quality_index > 0) {
+                s *= 1.0 + (m.quality_index / 100.0) * 0.15;
+            }
+            const policy = TRUSTED_CONFIDENCE.has(m.confidence) && m.action !== 'observe'
+                ? 'strict'
+                : RELAXED_CONFIDENCE.has(m.confidence) && m.action !== 'observe'
+                    ? 'relaxed'
+                    : 'fallback';
+            return {
+                ...m,
+                finalScore: s,
+                rawScore,
+                policy,
+                reason: `${policy} signal from ${m.platform || 'unknown'}${m.trend === 'surging' || m.trend === 'accelerating' ? ', ' + m.trend : ''}`,
+            };
+        });
+        scored.sort((a, b) => b.finalScore - a.finalScore);
+        return scored[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+// ── AgentLoop ────────────────────────────────────────────────────
+/**
+ * Runs the WZRD earn loop: authenticate, pick models, infer, report, claim.
+ *
+ * Create one instance and call `start()`. The loop runs until `maxCycles`
+ * is reached or `stop()` is called. Handles SIGINT/SIGTERM for graceful
+ * shutdown.
+ */
+export class AgentLoop {
+    constructor(options) {
+        this.running = false;
+        this.token = null;
+        this.sleepResolve = null;
+        this.keypair = options.keypair;
+        this.tasks = options.tasks ?? DEFAULT_TASKS;
+        const cs = options.cycleSeconds ?? DEFAULT_CYCLE_SECONDS;
+        if (!Number.isFinite(cs))
+            throw new Error('cycleSeconds must be a finite number');
+        this.cycleSeconds = Math.max(cs, MIN_CYCLE_SECONDS);
+        this.maxCycles = options.maxCycles ?? 0;
+        this.claim = options.claim ?? true;
+        this.apiBase = options.apiBase ?? 'https://api.twzrd.xyz';
+        this.onCycle = options.onCycle;
+    }
+    /**
+     * Start the earn loop. Blocks until maxCycles is reached or stop() is called.
+     */
+    async start() {
+        if (this.running)
+            throw new Error('AgentLoop is already running');
+        this.running = true;
+        const pubkey = this.keypair.publicKey.toBase58();
+        // Graceful shutdown on SIGINT/SIGTERM
+        const handleSignal = () => {
+            log('shutting down...');
+            this.stop();
+        };
+        if (typeof process !== 'undefined') {
+            process.on('SIGINT', handleSignal);
+            process.on('SIGTERM', handleSignal);
+        }
+        log(`agent: ${pubkey}`);
+        log(`tasks: ${this.tasks.join(', ')} | cycle: ${this.cycleSeconds}s`);
+        let cycle = 0;
+        let totalReports = 0;
+        let verifiedReports = 0;
+        let claimsMade = 0;
+        try {
+            while (this.running) {
+                if (this.maxCycles > 0 && cycle >= this.maxCycles) {
+                    log(`max_cycles reached (${this.maxCycles}), stopping`);
+                    break;
+                }
+                cycle++;
+                const cycleStart = Date.now();
+                const cycleResult = { cycle, tasks: [], earned: null, error: null };
+                try {
+                    // Re-auth on first cycle and every SESSION_REFRESH_CYCLES
+                    if (cycle === 1 || cycle % SESSION_REFRESH_CYCLES === 0) {
+                        this.token = await agentAuth(this.keypair, this.apiBase);
+                        log(`authenticated (session ${SESSION_REFRESH_CYCLES} cycles)`);
+                    }
+                    // Pick + infer + report per task
+                    for (const task of this.tasks) {
+                        if (!this.running)
+                            break;
+                        const taskResult = {
+                            task,
+                            model: null,
+                            qualityScore: null,
+                            executionId: null,
+                            pendingCcm: 0,
+                        };
+                        try {
+                            const pick = await fetchPick(task, this.apiBase);
+                            if (!pick) {
+                                log(`cycle ${cycle} | ${task} | no models available`);
+                                cycleResult.tasks.push(taskResult);
+                                continue;
+                            }
+                            const model = pick.model;
+                            taskResult.model = model;
+                            // Server-witnessed inference
+                            let infer = null;
+                            try {
+                                infer = await agentInfer(this.token, model, task, this.apiBase);
+                                taskResult.executionId = infer.execution_id;
+                                taskResult.qualityScore = infer.quality_score;
+                                if (infer.execution_id) {
+                                    const costStr = infer.cost_usd ? `, $${infer.cost_usd.toFixed(4)}` : '';
+                                    log(`cycle ${cycle} | ${task} | infer via ${infer.provider ?? '?'} -> ` +
+                                        `${infer.executed_model ?? '?'} (q=${(infer.quality_score ?? 0).toFixed(2)}, ` +
+                                        `${infer.latency_ms ?? 0}ms${costStr})`);
+                                }
+                            }
+                            catch (e) {
+                                log(`cycle ${cycle} | ${task} | infer failed (reporting without): ${e}`);
+                            }
+                            // Report the pick (with full metadata.wzrd block — parity with Python report_pick)
+                            const reportResp = await agentReport(this.token, model, {
+                                taskType: task,
+                                executionId: infer?.execution_id,
+                                qualityScore: infer?.quality_score,
+                                latencyMs: infer?.latency_ms,
+                                costUsd: infer?.cost_usd,
+                                metadata: {
+                                    wzrd: {
+                                        source: 'wzrd-sdk',
+                                        model: pick.model,
+                                        signal_model: pick.model,
+                                        selected_model: pick.model,
+                                        score: pick.finalScore,
+                                        raw_score: pick.rawScore,
+                                        trend: pick.trend,
+                                        confidence: pick.confidence,
+                                        action: pick.action,
+                                        platform: pick.platform,
+                                        policy: pick.policy,
+                                        policy_version: '1.0',
+                                        reason: pick.reason,
+                                        candidate_rank: 0,
+                                        exploration: false,
+                                        run_id: pubkey.substring(0, 12),
+                                        cycle_id: cycle,
+                                    },
+                                },
+                            }, this.apiBase);
+                            totalReports++;
+                            if (infer?.execution_id)
+                                verifiedReports++;
+                            const tag = infer?.execution_id ? 'V' : 'o';
+                            taskResult.pendingCcm = reportResp.pending_ccm ?? 0;
+                            log(`cycle ${cycle} | ${tag} ${task} -> ${model} | pending: ${fmtCcm(taskResult.pendingCcm)}`);
+                        }
+                        catch (e) {
+                            log(`cycle ${cycle} | ${task} | error: ${e}`);
+                        }
+                        cycleResult.tasks.push(taskResult);
+                    }
+                    // Check earned + claim
+                    if (this.claim && this.running && this.token) {
+                        try {
+                            const earned = await agentEarned(this.token, this.apiBase);
+                            cycleResult.earned = earned;
+                            const pending = earned.pending_ccm ?? 0;
+                            if (pending > 0) {
+                                try {
+                                    const claimResp = await fetch(`${this.apiBase}/v1/claims/${pubkey}/relay`, {
+                                        method: 'POST',
+                                        headers: {
+                                            Authorization: `Bearer ${this.token}`,
+                                            'Content-Type': 'application/json',
+                                        },
+                                    });
+                                    if (claimResp.ok) {
+                                        const data = await claimResp.json();
+                                        if (data.tx_sig) {
+                                            claimsMade++;
+                                            const txShort = data.tx_sig.length > 20
+                                                ? data.tx_sig.substring(0, 20) + '...'
+                                                : data.tx_sig;
+                                            log(`claimed ${fmtCcm(pending)} | tx: ${txShort}`);
+                                        }
+                                    }
+                                }
+                                catch {
+                                    // relay unavailable or rate limited — try next cycle
+                                }
+                            }
+                        }
+                        catch {
+                            // earned check failed — try next cycle
+                        }
+                    }
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    cycleResult.error = msg;
+                    log(`cycle ${cycle} failed: ${msg}`);
+                }
+                // Notify callback
+                if (this.onCycle) {
+                    try {
+                        this.onCycle(cycleResult);
+                    }
+                    catch {
+                        // callback errors should not break the loop
+                    }
+                }
+                // Sleep until next cycle (cancellable via stop())
+                const elapsed = Date.now() - cycleStart;
+                const sleepMs = Math.max(0, this.cycleSeconds * 1000 - elapsed);
+                if (sleepMs > 0 && this.running) {
+                    await new Promise((resolve) => {
+                        this.sleepResolve = resolve;
+                        const timer = setTimeout(() => { this.sleepResolve = null; resolve(); }, sleepMs);
+                        // If stop() was called during setup, resolve immediately
+                        if (!this.running) {
+                            clearTimeout(timer);
+                            this.sleepResolve = null;
+                            resolve();
+                        }
+                    });
+                }
+            }
+        }
+        finally {
+            // Clean up signal handlers
+            if (typeof process !== 'undefined') {
+                process.removeListener('SIGINT', handleSignal);
+                process.removeListener('SIGTERM', handleSignal);
+            }
+            this.running = false;
+        }
+        // Session summary
+        log('------------------------------------------------');
+        log(`session complete: ${cycle} cycles`);
+        log(`reports: ${totalReports} total (${verifiedReports} verified, ${totalReports - verifiedReports} unverified)`);
+        if (claimsMade > 0) {
+            log(`claims: ${claimsMade}`);
+        }
+        // Final earned status
+        if (this.token) {
+            try {
+                const final_ = await agentEarned(this.token, this.apiBase);
+                const total = final_.total_earned_ccm ?? 0;
+                const pending = final_.pending_ccm ?? 0;
+                const parts = [];
+                parts.push(`${fmtCcm(total)} lifetime`);
+                if (pending > 0)
+                    parts.push(`${fmtCcm(pending)} pending`);
+                if (final_.rank)
+                    parts.push(`rank #${final_.rank}`);
+                if (final_.contribution_streak_days > 1) {
+                    parts.push(`${final_.contribution_streak_days}-day streak`);
+                }
+                log(parts.join(' | '));
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    /**
+     * Signal the loop to stop after the current cycle completes.
+     */
+    stop() {
+        this.running = false;
+        // Cancel any pending sleep so shutdown is immediate
+        if (this.sleepResolve) {
+            this.sleepResolve();
+            this.sleepResolve = null;
+        }
+    }
+}

package/dist/constants.d.ts

@@ -14,3 +14,5 @@ export declare const MARKET_POSITION_SEED = "market_position";
 export declare const GLOBAL_ROOT_SEED = "global_root";
 export declare const CLAIM_STATE_GLOBAL_SEED = "claim_global";
 export declare const CHANNEL_CONFIG_V2_SEED = "channel_cfg_v2";
+export declare const STREAM_ROOT_SEED = "stream_root";
+export declare const CLAIM_STATE_STREAM_SEED = "claim_stream";

package/dist/constants.js

@@ -17,3 +17,6 @@ export const MARKET_POSITION_SEED = 'market_position';
 export const GLOBAL_ROOT_SEED = 'global_root';
 export const CLAIM_STATE_GLOBAL_SEED = 'claim_global';
 export const CHANNEL_CONFIG_V2_SEED = 'channel_cfg_v2';
+// ── Stream (vLOFI distribution) PDA Seeds ────────────────
+export const STREAM_ROOT_SEED = 'stream_root';
+export const CLAIM_STATE_STREAM_SEED = 'claim_stream';

package/dist/index.d.ts

@@ -4,11 +4,18 @@
  * PDA derivation, instruction builders, and account parsers for
  * deposit_market, settle_market, and claim_global.
  */
-export declare const VERSION = "0.1.1";
-export { PROGRAM_ID, DEVNET_PROGRAM_ID, MAINNET_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, PROTOCOL_STATE_SEED, MARKET_VAULT_SEED, MARKET_POSITION_SEED, GLOBAL_ROOT_SEED, CLAIM_STATE_GLOBAL_SEED, CHANNEL_CONFIG_V2_SEED, } from './constants.js';
-export { getProtocolStatePDA, getMarketVaultPDA, getUserPositionPDA, getGlobalRootConfigPDA, getClaimStatePDA, getChannelConfigV2PDA, getAta, } from './pda.js';
-export type { MarketVaultData, MarketVaultFull, ProtocolStateData, OnChainPosition, } from './accounts.js';
-export { parseMarketVault, parseProtocolState, parseUserMarketPosition, fetchOnChainPosition, fetchMarketVault, fetchTokenBalance, } from './accounts.js';
+export declare const VERSION = "0.2.0";
+export { PROGRAM_ID, DEVNET_PROGRAM_ID, MAINNET_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, PROTOCOL_STATE_SEED, MARKET_VAULT_SEED, MARKET_POSITION_SEED, GLOBAL_ROOT_SEED, CLAIM_STATE_GLOBAL_SEED, CHANNEL_CONFIG_V2_SEED, STREAM_ROOT_SEED, CLAIM_STATE_STREAM_SEED, } from './constants.js';
+export { getProtocolStatePDA, getMarketVaultPDA, getUserPositionPDA, getGlobalRootConfigPDA, getClaimStatePDA, getChannelConfigV2PDA, getStreamRootConfigPDA, getClaimStateStreamPDA, getAta, } from './pda.js';
+export type { LifecyclePhase, LifecyclePhaseInput, MarketVaultData, MarketVaultFull, ProtocolStateData, OnChainPosition, } from './accounts.js';
+export { parseMarketVault, parseProtocolState, parseUserMarketPosition, deriveLifecyclePhase, fetchOnChainPosition, fetchMarketVault, fetchTokenBalance, } from './accounts.js';
 export type { NavInfo } from './nav.js';
 export { computeSharesForDeposit, computePrincipalForSettle, } from './nav.js';
-export { anchorDisc, createAtaIdempotentIx, createDepositMarketIx, createSettleMarketIx, createInitializeMarketVaultIx, createClaimGlobalIx, createClaimGlobalV2Ix, createChannelConfigV2Ix, } from './instructions.js';
+export { anchorDisc, createAtaIdempotentIx, createDepositMarketIx, createMintSharesIx, createRedeemSharesIx, createSettlePredictionIx, createSettleMarketIx, createInitializeMarketVaultIx, createClaimGlobalV2Ix, createChannelConfigV2Ix, } from './instructions.js';
+export { createPublishStreamRootIx, createClaimStreamIx, createClaimStreamSponsoredIx, } from './stream.js';
+export type { BudgetTier, TaskType, VelocityTrend, Confidence, ModelRecommendation, ModelSelectorOptions, ModelSelectorConfig, } from './model-selector.js';
+export { ModelSelector, bestModel } from './model-selector.js';
+export type { ChallengeResponse, VerifyResponse, InferResponse, ReportResponse, EarnedResponse, } from './agent-auth.js';
+export { agentAuth, agentChallenge, agentVerify, agentInfer, agentReport, agentEarned, } from './agent-auth.js';
+export type { AgentLoopOptions, CycleResult } from './agent-loop.js';
+export { AgentLoop } from './agent-loop.js';

package/dist/index.js

@@ -4,12 +4,19 @@
  * PDA derivation, instruction builders, and account parsers for
  * deposit_market, settle_market, and claim_global.
  */
-export const VERSION = '0.1.1';
+export const VERSION = '0.2.0';
 // ── Constants ──────────────────────────────────────────
-export { PROGRAM_ID, DEVNET_PROGRAM_ID, MAINNET_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, PROTOCOL_STATE_SEED, MARKET_VAULT_SEED, MARKET_POSITION_SEED, GLOBAL_ROOT_SEED, CLAIM_STATE_GLOBAL_SEED, CHANNEL_CONFIG_V2_SEED, } from './constants.js';
+export { PROGRAM_ID, DEVNET_PROGRAM_ID, MAINNET_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, PROTOCOL_STATE_SEED, MARKET_VAULT_SEED, MARKET_POSITION_SEED, GLOBAL_ROOT_SEED, CLAIM_STATE_GLOBAL_SEED, CHANNEL_CONFIG_V2_SEED, STREAM_ROOT_SEED, CLAIM_STATE_STREAM_SEED, } from './constants.js';
 // ── PDA Derivation ─────────────────────────────────────
-export { getProtocolStatePDA, getMarketVaultPDA, getUserPositionPDA, getGlobalRootConfigPDA, getClaimStatePDA, getChannelConfigV2PDA, getAta, } from './pda.js';
-export { parseMarketVault, parseProtocolState, parseUserMarketPosition, fetchOnChainPosition, fetchMarketVault, fetchTokenBalance, } from './accounts.js';
+export { getProtocolStatePDA, getMarketVaultPDA, getUserPositionPDA, getGlobalRootConfigPDA, getClaimStatePDA, getChannelConfigV2PDA, getStreamRootConfigPDA, getClaimStateStreamPDA, getAta, } from './pda.js';
+export { parseMarketVault, parseProtocolState, parseUserMarketPosition, deriveLifecyclePhase, fetchOnChainPosition, fetchMarketVault, fetchTokenBalance, } from './accounts.js';
 export { computeSharesForDeposit, computePrincipalForSettle, } from './nav.js';
 // ── Instruction Builders ───────────────────────────────
-export { anchorDisc, createAtaIdempotentIx, createDepositMarketIx, createSettleMarketIx, createInitializeMarketVaultIx, createClaimGlobalIx, createClaimGlobalV2Ix, createChannelConfigV2Ix, } from './instructions.js';
+export { anchorDisc, createAtaIdempotentIx, createDepositMarketIx, createMintSharesIx, createRedeemSharesIx, createSettlePredictionIx, createSettleMarketIx, createInitializeMarketVaultIx, 
+// V1 createClaimGlobalIx removed — all agents/consumers use V2 since root_seq 1707
+createClaimGlobalV2Ix, createChannelConfigV2Ix, } from './instructions.js';
+// ── Stream (vLOFI) Instruction Builders ──────────────────
+export { createPublishStreamRootIx, createClaimStreamIx, createClaimStreamSponsoredIx, } from './stream.js';
+export { ModelSelector, bestModel } from './model-selector.js';
+export { agentAuth, agentChallenge, agentVerify, agentInfer, agentReport, agentEarned, } from './agent-auth.js';
+export { AgentLoop } from './agent-loop.js';

package/dist/instructions.d.ts

@@ -582,3 +582,72 @@ export declare function createInitializeGlobalRootIx(payer: PublicKey, ccmMint:
 export declare function createSetPriceUpdaterIx(authority: PublicKey, 
 /** 32-byte label (zero-padded). Use `Buffer.alloc(32)` and write your label. */
 label: Buffer, newUpdater: PublicKey, programId?: PublicKey): Promise<TransactionInstruction>;
+/**
+ * Build a `mint_shares` TransactionInstruction (prediction markets).
+ *
+ * Deposits CCM into the prediction market vault and receives 1:1 YES + NO tokens.
+ *
+ * Accounts (13 fixed, order matches markets.rs mint_shares):
+ *   0.  depositor          (signer, writable)
+ *   1.  protocol_state     (readonly)
+ *   2.  market_state       (writable)
+ *   3.  ccm_mint           (readonly)
+ *   4.  depositor_ccm_ata  (writable)
+ *   5.  vault              (writable)
+ *   6.  yes_mint           (writable)
+ *   7.  no_mint            (writable)
+ *   8.  depositor_yes_ata  (writable)
+ *   9.  depositor_no_ata   (writable)
+ *   10. mint_authority     (readonly)
+ *   11. token_program      (Token-2022, for CCM)
+ *   12. outcome_token_prog (SPL Token, for YES/NO)
+ *
+ * Args: amount (u64) — CCM native units to deposit
+ */
+export declare function createMintSharesIx(depositor: PublicKey, ccmMint: PublicKey, marketId: number, amount: bigint | number, programId?: PublicKey): Promise<TransactionInstruction>;
+/**
+ * Build a `redeem_shares` TransactionInstruction (prediction markets).
+ *
+ * Burns equal YES + NO shares and returns CCM. Pre-resolution only.
+ *
+ * Accounts (13 fixed, order matches markets.rs redeem_shares):
+ *   0.  redeemer           (signer, writable)
+ *   1.  protocol_state     (readonly)
+ *   2.  market_state       (writable)
+ *   3.  ccm_mint           (readonly)
+ *   4.  vault              (writable)
+ *   5.  yes_mint           (writable)
+ *   6.  no_mint            (writable)
+ *   7.  redeemer_yes_ata   (writable)
+ *   8.  redeemer_no_ata    (writable)
+ *   9.  redeemer_ccm_ata   (writable)
+ *   10. mint_authority     (readonly)
+ *   11. token_program      (Token-2022, for CCM)
+ *   12. outcome_token_prog (SPL Token, for YES/NO)
+ *
+ * Args: shares (u64) — number of YES+NO pairs to redeem
+ */
+export declare function createRedeemSharesIx(redeemer: PublicKey, ccmMint: PublicKey, marketId: number, shares: bigint | number, programId?: PublicKey): Promise<TransactionInstruction>;
+/**
+ * Build a `settle` TransactionInstruction (prediction markets).
+ *
+ * Burns winning-side tokens and returns CCM 1:1. Post-resolution only.
+ *
+ * Accounts (11 fixed, order matches markets.rs settle):
+ *   0.  settler            (signer, writable)
+ *   1.  protocol_state     (readonly)
+ *   2.  market_state       (readonly)
+ *   3.  ccm_mint           (readonly)
+ *   4.  vault              (writable)
+ *   5.  winning_mint       (writable) — yes_mint if YES won, no_mint if NO
+ *   6.  settler_winning    (writable) — settler's ATA for the winning mint
+ *   7.  settler_ccm        (writable) — settler's CCM ATA
+ *   8.  mint_authority     (readonly)
+ *   9.  token_program      (Token-2022, for CCM)
+ *   10. outcome_token_prog (SPL Token, for YES/NO)
+ *
+ * Args: shares (u64) — winning tokens to settle
+ */
+export declare function createSettlePredictionIx(settler: PublicKey, ccmMint: PublicKey, marketId: number, shares: bigint | number, 
+/** true = YES won, false = NO won */
+yesOutcome: boolean, programId?: PublicKey): Promise<TransactionInstruction>;