@wzrd_sol/eliza-plugin 0.1.2 → 0.3.0

package/dist/intel-helpers.js

@@ -0,0 +1,181 @@
+import { intelTrustUrl, } from '@wzrd_sol/sdk';
+const DEFAULT_INTEL = 'https://intel.twzrd.xyz';
+export function getIntelBase(runtime) {
+    const url = runtime.getSetting('WZRD_INTEL_URL');
+    return typeof url === 'string' && url.length > 0 ? url : DEFAULT_INTEL;
+}
+/** Pull structured fields from Eliza message content (flat or JSON-in-text). */
+export function parsePreflightInput(content) {
+    const direct = {
+        resource_name: str(content.resource_name),
+        seller_wallet: str(content.seller_wallet ?? content.pubkey ?? content.wallet),
+        resource_url: str(content.resource_url ?? content.url),
+        price_usdc: num(content.price_usdc ?? content.price),
+        buyer_wallet: str(content.buyer_wallet),
+        agent_intent: str(content.agent_intent ?? content.intent),
+        marketplace_score: num(content.marketplace_score),
+    };
+    const text = str(content.text);
+    if (text) {
+        const fromJson = tryParseJson(text);
+        if (fromJson)
+            return { ...direct, ...pickPreflight(fromJson) };
+        const wallet = extractWallet(text);
+        if (wallet && !direct.seller_wallet)
+            direct.seller_wallet = wallet;
+        if (!direct.agent_intent)
+            direct.agent_intent = text;
+    }
+    return compactPreflight(direct);
+}
+export function parseReceipt(content) {
+    if (content.receipt && typeof content.receipt === 'object') {
+        return content.receipt;
+    }
+    const text = str(content.text);
+    if (!text)
+        return null;
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === 'object' && 'leaf' in parsed && 'preimage' in parsed) {
+        return parsed;
+    }
+    return null;
+}
+export function extractPubkey(content) {
+    const direct = str(content.pubkey ?? content.seller_wallet ?? content.wallet);
+    if (direct)
+        return direct;
+    const text = str(content.text);
+    if (!text)
+        return null;
+    const fromJson = tryParseJson(text);
+    if (fromJson) {
+        const w = str(fromJson.pubkey ?? fromJson.seller_wallet ?? fromJson.wallet);
+        if (w)
+            return w;
+    }
+    return extractWallet(text);
+}
+export function formatPaymentRequired(err, apiBase, pubkey) {
+    const url = intelTrustUrl(pubkey, apiBase);
+    const reqs = err.paymentRequirements;
+    const accepts = reqs && typeof reqs === 'object' && 'accepts' in reqs && Array.isArray(reqs.accepts)
+        ? reqs.accepts[0]
+        : null;
+    const amount = accepts?.amount ?? '50000';
+    const payTo = accepts?.payTo ?? '(see accepts)';
+    const network = accepts?.network ?? 'solana';
+    return (`Intel trust requires x402 payment (~0.05 USDC).\n` +
+        `Endpoint: ${url}\n` +
+        `Network: ${network}, amount (atomic): ${amount}, payTo: ${payTo}\n\n` +
+        `No paying fetch configured. Wire one before runtime creation:\n` +
+        `  import { setPayingFetch } from '@wzrd_sol/eliza-plugin';\n` +
+        `  setPayingFetch(myAgentcashFetch);\n\n` +
+        `Or pay out of band:\n` +
+        `  npx agentcash@latest fetch ${url}`);
+}
+function str(v) {
+    if (typeof v === 'string' && v.trim())
+        return v.trim();
+    return undefined;
+}
+function num(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v.trim()) {
+        const n = Number(v);
+        if (Number.isFinite(n))
+            return n;
+    }
+    return undefined;
+}
+function tryParseJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('{'))
+        return null;
+    try {
+        const v = JSON.parse(trimmed);
+        return v && typeof v === 'object' ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractWallet(text) {
+    const m = text.match(/[1-9A-HJ-NP-Za-km-z]{32,44}/);
+    return m ? m[0] : null;
+}
+function pickPreflight(obj) {
+    return compactPreflight({
+        resource_name: str(obj.resource_name),
+        seller_wallet: str(obj.seller_wallet ?? obj.pubkey ?? obj.wallet),
+        resource_url: str(obj.resource_url ?? obj.url),
+        price_usdc: num(obj.price_usdc ?? obj.price),
+        buyer_wallet: str(obj.buyer_wallet),
+        agent_intent: str(obj.agent_intent ?? obj.intent),
+        marketplace_score: num(obj.marketplace_score),
+    });
+}
+function compactPreflight(input) {
+    const out = {};
+    if (input.resource_name)
+        out.resource_name = input.resource_name;
+    if (input.seller_wallet)
+        out.seller_wallet = input.seller_wallet;
+    if (input.resource_url)
+        out.resource_url = input.resource_url;
+    if (input.price_usdc !== undefined)
+        out.price_usdc = input.price_usdc;
+    if (input.buyer_wallet)
+        out.buyer_wallet = input.buyer_wallet;
+    if (input.agent_intent)
+        out.agent_intent = input.agent_intent;
+    if (input.marketplace_score !== undefined)
+        out.marketplace_score = input.marketplace_score;
+    return out;
+}
+/**
+ * Timeout wrapper for SDK network calls (preflight/trust/verify).
+ * Supports two call forms for minimal change:
+ * - withTimeout(promise) for preflight (SDK does not expose fetchImpl/signal)
+ * - withTimeout((signal) => sdkCallWithFetchImpl(abortingFetch)) for trust/verify
+ * Uses AbortController + signal: abort() is called on timeout so that when caller
+ * wires the returned signal into fetchImpl, the underlying network request is aborted.
+ * Always clears timer in finally (no leak). Attaches rejection observer to the
+ * call promise (without altering settlement) to avoid unhandled rejections on the
+ * loser of the race.
+ * Applied to actions + getIntelClient delegates.
+ */
+export function withTimeout(pOrMake, ms = 8000) {
+    if (typeof pOrMake === 'function') {
+        const makeCall = pOrMake;
+        const controller = new AbortController();
+        let timer;
+        const timeoutP = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                controller.abort();
+                reject(new Error('timeout'));
+            }, ms);
+        });
+        const callP = makeCall(controller.signal);
+        // Observe rejections on callP so a late rejection after timeout does not emit unhandledrejection.
+        callP.then(undefined, () => { });
+        return Promise.race([callP, timeoutP]).finally(() => {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        });
+    }
+    // legacy path (promise passed directly): still safe timeout + no unhandled + clear
+    const p = pOrMake;
+    let timer;
+    const timeoutP = new Promise((_, reject) => {
+        timer = setTimeout(() => {
+            reject(new Error('timeout'));
+        }, ms);
+    });
+    p.then(undefined, () => { });
+    return Promise.race([p, timeoutP]).finally(() => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    });
+}

package/dist/paying-fetch.d.ts

@@ -0,0 +1,9 @@
+/** x402-capable fetch injection for paid intel actions. No embedded wallet. */
+import type { IAgentRuntime } from '@elizaos/core';
+/** Host supplies an x402-capable fetch (agentcash, twzrd-x402-gate, etc.) before runtime creation. */
+export declare function setPayingFetch(f: typeof fetch): void;
+export declare function clearPayingFetch(): void;
+type FetchLike = typeof fetch;
+/** Resolve paying fetch: module setter > runtime service > runtime.fetch > global fetch. */
+export declare function resolvePayingFetch(runtime: IAgentRuntime): FetchLike;
+export {};

package/dist/paying-fetch.js

@@ -0,0 +1,27 @@
+let modulePayingFetch = null;
+/** Host supplies an x402-capable fetch (agentcash, twzrd-x402-gate, etc.) before runtime creation. */
+export function setPayingFetch(f) {
+    modulePayingFetch = f;
+}
+export function clearPayingFetch() {
+    modulePayingFetch = null;
+}
+function serviceFetch(runtime) {
+    for (const name of ['x402', 'payingFetch', 'agentcash']) {
+        const svc = runtime.getService(name);
+        if (svc?.fetch && typeof svc.fetch === 'function')
+            return svc.fetch;
+    }
+    return null;
+}
+/** Resolve paying fetch: module setter > runtime service > runtime.fetch > global fetch. */
+export function resolvePayingFetch(runtime) {
+    if (modulePayingFetch)
+        return modulePayingFetch;
+    const fromSvc = serviceFetch(runtime);
+    if (fromSvc)
+        return fromSvc;
+    if (runtime.fetch && typeof runtime.fetch === 'function')
+        return runtime.fetch;
+    return globalThis.fetch;
+}

package/dist/test/plugin-registration.intel.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/plugin-registration.intel.js

@@ -0,0 +1,253 @@
+/**
+ * Real E2E: load wzrdPlugin via @elizaos/core AgentRuntime (critical missing piece per plan).
+ * Constructs minimal runtime with plugins:[wzrdPlugin]; asserts intel action names present;
+ * invokes handlers w/ mock Memory (preflight uses seller_wallet/price/resource_name);
+ * paid path: injected mock paying fetch that returns fake IntelTrustResponse w/ receipt;
+ * verifies callback contains decision/score/ALLOW etc + success result.
+ * (Uses package import to match existing tsconfig.test paths + `npm run build && npm test` runtime;
+ * plan referenced '../src/index.js' for source-load semantics in test source.)
+ */
+import assert from 'node:assert/strict';
+import { describe, it, before, after } from 'node:test';
+import { AgentRuntime } from '@elizaos/core';
+import wzrdPlugin, { intelPreflightAction, intelTrustAction, verifyReceiptAction, setPayingFetch, clearPayingFetch, getIntelClient, resolvePayingFetch, } from '@wzrd_sol/eliza-plugin';
+function mockMemory(content) {
+    return {
+        id: '00000000-0000-0000-0000-000000000001',
+        entityId: '00000000-0000-0000-0000-000000000002',
+        roomId: '00000000-0000-0000-0000-000000000003',
+        content: content,
+        createdAt: Date.now(),
+    };
+}
+function mockRuntime(settings = {}) {
+    const store = new Map(Object.entries(settings));
+    return {
+        getSetting: (key) => store.get(key) ?? null,
+        getService: () => null,
+        fetch: globalThis.fetch,
+    };
+}
+describe('wzrdPlugin intel registration + E2E (real runtime load)', () => {
+    let runtime;
+    before(async () => {
+        runtime = new AgentRuntime({
+            character: { name: 'wzrd-intel-test', bio: 'test', plugins: [] },
+            settings: { WZRD_INTEL_URL: 'https://intel.twzrd.xyz' },
+        });
+        await runtime.registerPlugin(wzrdPlugin);
+    });
+    after(() => {
+        clearPayingFetch();
+    });
+    it('constructs runtime with plugins and registers intel actions', () => {
+        const names = runtime.actions.map((a) => a.name);
+        assert.ok(names.includes('WZRD_INTEL_PREFLIGHT'), 'preflight must be registered');
+        assert.ok(names.includes('WZRD_INTEL_TRUST'), 'trust must be registered');
+        assert.ok(names.includes('WZRD_VERIFY_RECEIPT'), 'verify must be registered');
+    });
+    it('preflight handler accepts seller_wallet + price + resource_name, returns success + decision/score text (live)', { timeout: 10000 }, async () => {
+        const rt = mockRuntime({ WZRD_INTEL_URL: 'https://intel.twzrd.xyz' });
+        const callbacks = [];
+        const result = await intelPreflightAction.handler(rt, mockMemory({
+            seller_wallet: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE',
+            price_usdc: 0.05,
+            resource_name: 'test-resource',
+        }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, true, `preflight failed: ${result?.error}`);
+        assert.equal(typeof result.success, 'boolean');
+        assert.ok(callbacks.length > 0);
+        const text = callbacks.join('\n');
+        assert.match(text, /Decision: (ALLOW|WARN|BLOCK)/i);
+        assert.match(text, /score|trust_score/i);
+        if (result.data)
+            assert.ok(result.data);
+    });
+    it('preflight validation rejects bad seller_wallet (non-base58)', async () => {
+        const rt = mockRuntime({ WZRD_INTEL_URL: 'https://intel.twzrd.xyz' });
+        const callbacks = [];
+        const result = await intelPreflightAction.handler(rt, mockMemory({ seller_wallet: 'not-base58!!!', price_usdc: 0.05 }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, false);
+        assert.equal(typeof result.success, 'boolean');
+        const text = callbacks.join('\n');
+        assert.match(text, /Invalid preflight input/);
+        assert.match(text, /seller_wallet must be 32-44 char base58/);
+    });
+    it('preflight validation rejects negative price_usdc', async () => {
+        const rt = mockRuntime({ WZRD_INTEL_URL: 'https://intel.twzrd.xyz' });
+        const callbacks = [];
+        const result = await intelPreflightAction.handler(rt, mockMemory({ seller_wallet: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', price_usdc: -1 }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, false);
+        assert.equal(typeof result.success, 'boolean');
+        const text = callbacks.join('\n');
+        assert.match(text, /Invalid preflight input/);
+        assert.match(text, /price_usdc must be non-negative finite number/);
+    });
+    it('trust handler with injected paying fetch (fake IntelTrustResponse containing receipt) succeeds + surfaces score + leaf in callback', async () => {
+        const fakeReceipt = {
+            version: 'v5',
+            leaf: '0xdeadbeef',
+            preimage: { domain: 'TWZRD:AO_REPUTATION_RECEIPT_V5', agent_id: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', score: 99, version: 'v5' },
+            signature: 'sig',
+            signing_pubkey: '11111111111111111111111111111111',
+        };
+        setPayingFetch(async () => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', trust: { score: 88 }, paid: true, twzrd_receipt: fakeReceipt }),
+        }));
+        const rt = mockRuntime();
+        const callbacks = [];
+        const result = await intelTrustAction.handler(rt, mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, true, String(result?.error));
+        assert.equal(typeof result.success, 'boolean');
+        assert.ok(callbacks.length > 0);
+        const text = callbacks.join('\n');
+        assert.match(text, /Score: 88/);
+        assert.match(text, /leaf:/i);
+        if (result.data)
+            assert.ok(result.data);
+    });
+    it('PREFLIGHT-BEFORE-PAY: decision=block aborts the trust purchase before any payment', async () => {
+        // preSpendGate runs the FREE preflight via the SDK's intelPreflight, which uses
+        // the global fetch (not the injected paying fetch — that is reserved for the
+        // paid leg). So we stub global fetch to return a block ReadinessCard, and put a
+        // tripwire on the injected paying fetch: if the pay leg runs after a block, the
+        // tripwire fires and the test fails.
+        const realFetch = globalThis.fetch;
+        let payAttempted = false;
+        setPayingFetch(async () => {
+            payAttempted = true;
+            return { ok: true, status: 200, json: async () => ({}) };
+        });
+        globalThis.fetch = (async () => ({
+            ok: true,
+            status: 200,
+            json: async () => ({
+                readiness_card: { decision: 'block', trust_score: 5, can_spend: false },
+                reason: 'seller flagged by corpus',
+            }),
+        }));
+        try {
+            const callbacks = [];
+            const result = await intelTrustAction.handler(mockRuntime(), mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+                callbacks.push(r.text ?? '');
+                return [];
+            });
+            assert.equal(result?.success, false);
+            assert.equal(result?.error, 'preflight_block');
+            assert.equal(payAttempted, false, 'payment must NOT be attempted after a block decision');
+            assert.match(callbacks.join('\n'), /blocked|No payment was sent/i);
+        }
+        finally {
+            globalThis.fetch = realFetch;
+        }
+    });
+    it('VERIFY: a V6 receipt (reputation_* bound into the leaf) is accepted by the verify action path', async () => {
+        // Live receipts are V6; the SDK selects the leaf binding from the domain, so a
+        // V6 receipt must round-trip through WZRD_VERIFY_RECEIPT without a V5/V6 mixup.
+        // We assert the action runs and reports the V6 domain rather than erroring.
+        const v6Receipt = {
+            version: 'v6',
+            leaf: '0x4c82649d2be393b1fca2da7c5d4c7afebb189ad3f0b93b620ce2e552fe5ce558',
+            preimage: {
+                domain: 'TWZRD:AO_REPUTATION_RECEIPT_V6',
+                agent_id: '11111111111111111111111111111111',
+                score: 72,
+                confidence_bps: 8000,
+                timestamp_unix: 1748736000,
+                payer: '11111111111111111111111111111111',
+                settlement_tx: 'EXAMPLE-sample-receipt-no-real-settlement-tx-0001',
+                reputation_score: 4242,
+                reputation_confidence_bps: 7500,
+                reputation_score_version: 'intel_renorm_v1',
+                reputation_feature_window_start_unix: 1748000000,
+                reputation_data_quality: 'high',
+                version: 'v6',
+            },
+            signature: 'sig',
+            signing_pubkey: '11111111111111111111111111111111',
+        };
+        const callbacks = [];
+        const result = await verifyReceiptAction.handler(mockRuntime(), mockMemory({ receipt: v6Receipt }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        // The action ran (no exception) and exercised the SDK V6 leaf path. The
+        // signature is a stub so it won't pass authenticity, but the leaf must
+        // recompute against the V6 binding (not the V5 one) — proven by the SDK's
+        // own canonical-vector tests; here we assert the action did not crash and
+        // surfaced a verdict for the V6 domain.
+        assert.ok(result, 'verify action returned a result for a V6 receipt');
+        assert.ok(callbacks.length > 0, 'verify action produced output for a V6 receipt');
+    });
+    it('trust surfaces payment_required + x402/agentcash text on 402 from (failing) fetch (explicit IntelPaymentRequiredError branch)', async () => {
+        setPayingFetch(async () => ({
+            ok: false,
+            status: 402,
+            headers: { get: () => null },
+            json: async () => ({ error: 'payment required' }),
+            text: async () => '',
+        }));
+        const rt = mockRuntime();
+        const callbacks = [];
+        const result = await intelTrustAction.handler(rt, mockMemory({ pubkey: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE' }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.equal(result?.success, false);
+        assert.equal(result?.error, 'payment_required');
+        assert.equal(typeof result.success, 'boolean');
+        const text = callbacks.join('\n');
+        assert.match(text, /x402|Intel trust requires|agentcash/i);
+    });
+    it('verify handler runs with receipt content (exercises SDK verify path)', async () => {
+        const rt = mockRuntime();
+        const callbacks = [];
+        const minimalReceipt = {
+            version: 'v5',
+            leaf: '0x0000000000000000000000000000000000000000000000000000000000000000',
+            preimage: { domain: 'TWZRD:AO_REPUTATION_RECEIPT_V5', agent_id: '4LkEFjJdXARkKx8FBx4LBFa2SvJNmjQpgGDLoJcypZUE', score: 0, version: 'v5' },
+            signature: 'AA',
+            signing_pubkey: '11111111111111111111111111111111',
+        };
+        const result = await verifyReceiptAction.handler(rt, mockMemory({ receipt: minimalReceipt }), undefined, undefined, async (r) => {
+            callbacks.push(r.text ?? '');
+            return [];
+        });
+        assert.ok(result, 'verify handler must return');
+        assert.equal(typeof result.success, 'boolean');
+        assert.equal(result.success, false);
+        assert.ok(callbacks.length > 0);
+        const text = callbacks.join('\n');
+        assert.match(text, /INVALID/);
+    });
+    it('getIntelClient factory + resolvePayingFetch service fallback exercised (covers factory delegates and resolve branches)', () => {
+        clearPayingFetch(); // ensure module-level does not shadow the service fallback we want to test
+        const mockPaying = async () => ({ ok: true, status: 200, json: async () => ({}) });
+        const rt = {
+            getSetting: () => null,
+            getService: (n) => (n === 'payingFetch' ? { fetch: mockPaying } : null),
+            fetch: globalThis.fetch,
+        };
+        const intel = getIntelClient(rt);
+        assert.equal(typeof intel.preflight, 'function');
+        assert.equal(typeof intel.trust, 'function');
+        assert.equal(typeof intel.verify, 'function');
+        // exercise at least one resolve fallback path (service)
+        const resolved = resolvePayingFetch(rt);
+        assert.equal(resolved, mockPaying);
+    });
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@wzrd_sol/eliza-plugin",
-  "version": "0.1.2",
-  "description": "WZRD Liquid Attention Protocol plugin for ElizaOS — leaderboard, portfolio, deposit, claim, velocity",
+  "version": "0.3.0",
+  "description": "WZRD Agent Intel for ElizaOS — preflight ReadinessCards, x402-paid V5 trust receipts, offline verification on intel.twzrd.xyz. Also ships the legacy earn loop.",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,13 +13,15 @@
     }
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc -p tsconfig.test.json",
+    "test": "node --test dist/test/plugin-registration.intel.js",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@wzrd_sol/solana-agent-plugin": "^0.1.0",
-    "@wzrd_sol/sdk": "^0.1.1",
-    "@solana/web3.js": "^1.95.0"
+    "@solana/web3.js": "^1.95.0",
+    "@wzrd_sol/sdk": "^0.4.3",
+    "bs58": "^5.0.0",
+    "tweetnacl": "^1.0.3"
   },
   "peerDependencies": {
     "@elizaos/core": "^1.0.0"
@@ -31,6 +33,7 @@
   },
   "devDependencies": {
     "@elizaos/core": "^1.0.0",
+    "@types/node": "^22.13.10",
     "typescript": "^5.6.3"
   },
   "keywords": [
@@ -38,9 +41,17 @@
     "eliza",
     "elizaos",
     "wzrd",
-    "attention",
-    "defi",
-    "ai-agent"
+    "intel",
+    "x402",
+    "trust",
+    "receipt",
+    "reputation",
+    "preflight",
+    "ccm",
+    "inference",
+    "earn",
+    "ai-agent",
+    "mcp"
   ],
   "license": "MIT",
   "publishConfig": {
@@ -48,7 +59,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/twzrd-sol/wzrd-final.git",
+    "url": "git+https://github.com/twzrd-sol/wzrd-velocity.git",
     "directory": "agents/eliza-plugin"
   },
   "files": [

package/dist/actions/deposit.d.ts

@@ -1,2 +0,0 @@
-import type { Action } from '@elizaos/core';
-export declare const depositAction: Action;

package/dist/actions/deposit.js

@@ -1,79 +0,0 @@
-/**
- * ELIZA Action: WZRD_DEPOSIT — deposit USDC into attention market, mint vLOFI (auth + keypair).
- *
- * Before depositing, agents can check expected returns via the APR endpoint:
- *   GET /v1/markets/:id/apr  — returns base_apr_bps, attention_multiplier_bps,
- *                              projected_total_apr_bps, tvl_usdc, and the yield formula.
- *   GET /v1/markets/:id/preview — returns projected_multiplier_bps and freshness_secs
- *                                  for a live multiplier snapshot before committing capital.
- * Use WzrdClient.getMarketApr(marketId) or WzrdClient.getMarketPreview(marketId).
- */
-import { Keypair, ComputeBudgetProgram, TransactionMessage, VersionedTransaction, Connection } from '@solana/web3.js';
-export const depositAction = {
-    name: 'WZRD_DEPOSIT',
-    similes: ['DEPOSIT_USDC', 'BUY_ATTENTION', 'ENTER_MARKET'],
-    description: 'Deposit USDC into a WZRD attention market to mint vLOFI. Requires market_id and amount_usdc in message content.',
-    examples: [[
-            { name: '{{user1}}', content: { text: 'Deposit 0.01 USDC into WZRD market 10' } },
-            { name: '{{agentName}}', content: { text: 'Deposited 0.0100 USDC into Market #10. Tx: X7FG...' } },
-        ]],
-    validate: async () => true,
-    handler: async (runtime, message, _state, _opt, callback) => {
-        const { market_id: marketId, amount_usdc: amountUsdc, priority_fee = 50_000 } = message.content;
-        if (!marketId || !amountUsdc || amountUsdc > 100) {
-            const text = !marketId || !amountUsdc
-                ? 'Missing required: market_id and amount_usdc.' : 'Max 100 USDC per deposit.';
-            await callback?.({ text });
-            return { success: false, text };
-        }
-        const sk = runtime.getSetting('SOLANA_PRIVATE_KEY');
-        if (!sk)
-            throw new Error('SOLANA_PRIVATE_KEY not configured');
-        const kp = Keypair.fromSecretKey(Uint8Array.from(JSON.parse(String(sk))));
-        const payer = kp.publicKey;
-        const amt = BigInt(Math.round(amountUsdc * 1e6));
-        const rpcSetting = runtime.getSetting('SOLANA_RPC_URL');
-        const rpc = (typeof rpcSetting === 'string' ? rpcSetting : undefined) || 'https://api.mainnet-beta.solana.com';
-        const conn = new Connection(rpc, 'confirmed');
-        const sdk = await import('@wzrd_sol/sdk');
-        const vault = await sdk.fetchMarketVault(conn, marketId);
-        if (!vault) {
-            await callback?.({ text: `Market ${marketId} has no vault.` });
-            return { success: false };
-        }
-        const pos = await sdk.fetchOnChainPosition(conn, payer, marketId);
-        if (pos && pos.depositedAmount > 0n && !pos.settled) {
-            await callback?.({ text: `Position exists in market ${marketId}.` });
-            return { success: false };
-        }
-        const bal = await sdk.fetchTokenBalance(conn, sdk.getAta(payer, vault.depositMint, sdk.TOKEN_PROGRAM_ID));
-        if (bal < amt) {
-            await callback?.({ text: `Insufficient USDC.` });
-            return { success: false };
-        }
-        const ixs = await sdk.createDepositMarketIx(conn, payer, marketId, amt);
-        ixs.unshift(ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }), ComputeBudgetProgram.setComputeUnitPrice({ microLamports: priority_fee }));
-        const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash('confirmed');
-        const tx = new VersionedTransaction(new TransactionMessage({ payerKey: payer, recentBlockhash: blockhash, instructions: ixs }).compileToV0Message());
-        tx.sign([kp]);
-        const sim = await conn.simulateTransaction(tx);
-        if (sim.value.err) {
-            await callback?.({ text: `Sim failed: ${JSON.stringify(sim.value.err)}` });
-            return { success: false };
-        }
-        const sig = await conn.sendTransaction(tx, { skipPreflight: true, maxRetries: 3 });
-        try {
-            await Promise.race([
-                conn.confirmTransaction({ signature: sig, blockhash, lastValidBlockHeight }, 'confirmed'),
-                new Promise((_, rej) => setTimeout(() => rej(new Error('Timeout')), 60_000)),
-            ]);
-        }
-        catch {
-            await callback?.({ text: `Deposit sent, confirmation timed out. Tx: ${sig}` });
-            return { success: true, data: { signature: sig, timed_out: true } };
-        }
-        const text = `Deposited ${amountUsdc.toFixed(4)} USDC into Market #${marketId}. Tx: ${sig.slice(0, 16)}...`;
-        await callback?.({ text });
-        return { success: true, text, data: { signature: sig, market_id: marketId, amount_usdc: amountUsdc } };
-    },
-};

package/dist/actions/leaderboard.d.ts

@@ -1,3 +0,0 @@
-/** ELIZA Action: WZRD_LEADERBOARD — fetch attention market leaderboard (no auth). */
-import type { Action } from '@elizaos/core';
-export declare const leaderboardAction: Action;

package/dist/actions/leaderboard.js

@@ -1,25 +0,0 @@
-import { getWzrdClient } from '../client.js';
-export const leaderboardAction = {
-    name: 'WZRD_LEADERBOARD',
-    similes: ['WZRD_MARKETS', 'WZRD_TRENDING', 'TOP_MODELS'],
-    description: 'Fetch the WZRD attention market leaderboard ranked by velocity EMA.',
-    examples: [[
-            { name: '{{user1}}', content: { text: 'Show me the top WZRD markets' } },
-            { name: '{{agentName}}', content: { text: 'Here are the top WZRD attention markets...' } },
-        ]],
-    validate: async () => true,
-    handler: async (runtime, _msg, _state, _opt, callback) => {
-        const result = await getWzrdClient(runtime).getLeaderboard(10);
-        const lines = result.markets.map((m, i) => `${i + 1}. ${m.metric} — ${fmtV(m.velocity_ema)} velocity (${m.platform}) | ${m.multiplier_bps / 10_000}x | id=${m.market_id}`);
-        const text = `WZRD Leaderboard (${result.markets.length} markets, root_seq=${result.root.root_seq}):\n${lines.join('\n')}`;
-        await callback?.({ text });
-        return { success: true, data: result };
-    },
-};
-function fmtV(v) {
-    if (v >= 1e6)
-        return `${(v / 1e6).toFixed(1)}M`;
-    if (v >= 1e3)
-        return `${(v / 1e3).toFixed(0)}K`;
-    return v.toFixed(0);
-}

package/dist/actions/portfolio.d.ts

@@ -1,3 +0,0 @@
-/** ELIZA Action: WZRD_PORTFOLIO — fetch agent's positions + CCM earned (auth). */
-import type { Action } from '@elizaos/core';
-export declare const portfolioAction: Action;