@hypelens/hypelens-agent-rail 0.1.1 → 0.1.2

package/scripts/bundle-vendor.mjs

@@ -1,13 +0,0 @@
-// prepack: copy the shipped extension modules into agent-rail/vendor so the
-// published npm package is self-contained. The rail evals these verbatim.
-import { copyFileSync, mkdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const RAIL = join(dirname(fileURLToPath(import.meta.url)), '..');
-const EXT = join(RAIL, '..', 'extension');
-mkdirSync(join(RAIL, 'vendor'), { recursive: true });
-for (const f of [['vendor/hl-sdk.js', 'hl-sdk.js'], ['exchange/hl-signer.js', 'hl-signer.js'], ['exchange/hl-actions.js', 'hl-actions.js'], ['viewmodel.js', 'viewmodel.js']]) {
-  copyFileSync(join(EXT, f[0]), join(RAIL, 'vendor', f[1]));
-  console.log('bundled', f[1]);
-}

package/server.json

@@ -1,35 +0,0 @@
-{
-  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-07-09/server.schema.json",
-  "name": "io.github.polyparlay/hypelens-agent-rail",
-  "description": "Real-data Hyperliquid risk intelligence for trading agents: liquidation walls, cascade chains, whale book, and pre-trade liq checks from a live 1,100-wallet position crawl — plus risk-checked, testnet-gated order placement.",
-  "status": "active",
-  "repository": {
-    "url": "https://github.com/polyparlay/hypelens",
-    "source": "github",
-    "subfolder": "agent-rail"
-  },
-  "version": "0.1.0",
-  "packages": [
-    {
-      "registry_type": "npm",
-      "registry_base_url": "https://registry.npmjs.org",
-      "identifier": "hypelens-agent-rail",
-      "version": "0.1.0",
-      "transport": { "type": "stdio" },
-      "environment_variables": [
-        {
-          "name": "HYPELENS_AGENT_PK",
-          "description": "Optional: agent-wallet private key for order placement (risk tools need no key)",
-          "is_required": false,
-          "is_secret": true
-        },
-        {
-          "name": "HYPELENS_NET",
-          "description": "Optional: 'testnet' (default) or 'mainnet' (placement hard-blocked until enabled)",
-          "is_required": false,
-          "is_secret": false
-        }
-      ]
-    }
-  ]
-}

package/smithery.yaml

@@ -1,23 +0,0 @@
-# Smithery.ai listing config — https://smithery.ai/docs/config
-startCommand:
-  type: stdio
-  configSchema:
-    type: object
-    properties:
-      hypelensAgentPk:
-        type: string
-        description: "Optional agent-wallet private key for order placement. Risk tools (walls, cascade, pretrade check, whale book) work without any key."
-      hypelensNet:
-        type: string
-        enum: [testnet, mainnet]
-        default: testnet
-        description: "Execution network. Mainnet placement is hard-blocked in code until operator-enabled."
-  commandFunction: |-
-    (config) => ({
-      command: 'node',
-      args: ['bin/hypelens-rail-mcp.js'],
-      env: {
-        ...(config.hypelensAgentPk ? { HYPELENS_AGENT_PK: config.hypelensAgentPk } : {}),
-        ...(config.hypelensNet ? { HYPELENS_NET: config.hypelensNet } : {})
-      }
-    })

package/test/exchange.test.mjs

@@ -1,74 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { loadShipped } from '../src/load.js';
-import { status, placeOrder, newAgentWallet, approvePayloads } from '../src/exchange.js';
-import { _setFixtures } from '../src/core.js';
-
-test('shipped modules load in node; signer self-test passes', () => {
-  const { actions, signer, VM } = loadShipped();
-  assert.equal(signer.selfTest().ok, true, signer.selfTest().error || '');
-  assert.equal(typeof VM.computeCascade, 'function');
-  assert.equal(actions.BUILDER, '0x9548B8E9554a1968843B3C380431b10996247c88');
-});
-
-test('every order action carries the pinned builder fee', () => {
-  const { actions } = loadShipped();
-  const a = actions.buildOrderAction({ assetIndex: 0, szDecimals: 5, isBuy: true, entryPx: 100000, size: 0.01, slPx: 95000, tpPx: 111000 });
-  assert.deepEqual(a.builder, { b: actions.BUILDER.toLowerCase(), f: 10 });
-  assert.equal(a.grouping, 'normalTpsl');
-  assert.equal(a.orders.length, 3);
-  assert.equal(a.orders[1].r, true); // SL reduce-only
-});
-
-test('mainnet placement is hard-blocked', async () => {
-  process.env.HYPELENS_NET = 'mainnet';
-  process.env.HYPELENS_AGENT_PK = '0x' + '1'.repeat(64);
-  await assert.rejects(
-    () => placeOrder({ coin: 'BTC', isBuy: true, size: 0.01, entryPx: 100000, skipRiskCheck: true }),
-    /MAINNET PLACEMENT DISABLED/);
-  delete process.env.HYPELENS_NET;
-  delete process.env.HYPELENS_AGENT_PK;
-});
-
-test('placement without agent key fails closed', async () => {
-  delete process.env.HYPELENS_AGENT_PK;
-  await assert.rejects(
-    () => placeOrder({ coin: 'BTC', isBuy: true, size: 0.01, entryPx: 100000, skipRiskCheck: true }),
-    /HYPELENS_AGENT_PK not set/);
-});
-
-test('risk gate refuses danger orders without override', async () => {
-  process.env.HYPELENS_NET = 'testnet';
-  process.env.HYPELENS_AGENT_PK = '0x' + '1'.repeat(64);
-  _setFixtures({
-    feed: {
-      updated: new Date().toISOString(),
-      coins: { BTC: { mark: 100000, coverage: { pct: 53 }, positions: [[94800, 50e6, 0, '0xaaa0000000000000000000000000000000000001', 104000]] } }
-    },
-    meta: { BTC: { assetIndex: 0, szDecimals: 5, maxLeverage: 40, markPx: 100000, oiNtl: 2e9, dayNtlVlm: 2e9 } }
-  });
-  // leverage chosen so liq falls near 94800 wall; if the model puts liq inside
-  // the wall the order must be refused (no network call is made on refusal)
-  const r = await placeOrder({ coin: 'BTC', isBuy: true, size: 0.01, entryPx: 100000, leverage: 18 })
-    .catch((e) => ({ threw: String(e.message) }));
-  if (r.refused) {
-    assert.match(r.refused, /wall/);
-    assert.equal(r.placed, false);
-  } else {
-    // liq didn't land in the wall under the shipped model — acceptable; the
-    // testnet POST path was then exercised or asset lookup failed. Either way
-    // the call must not report a successful mainnet placement.
-    assert.notEqual(r.net, 'mainnet');
-  }
-  delete process.env.HYPELENS_AGENT_PK;
-  delete process.env.HYPELENS_NET;
-});
-
-test('agent wallet + approve payloads are well-formed', () => {
-  const w = newAgentWallet();
-  assert.match(w.address, /^0x[0-9a-fA-F]{40}$/);
-  const p = approvePayloads(w.address);
-  assert.equal(p.approveAgent.action.type, 'approveAgent');
-  assert.equal(p.approveBuilderFee.action.maxFeeRate, '0.01%');
-  assert.equal(p.approveBuilderFee.primaryType, 'HyperliquidTransaction:ApproveBuilderFee');
-});

package/test/risk.test.mjs

@@ -1,86 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { binWalls, pretradeCheck, walls, cascade, whaleBook, _setFixtures } from '../src/core.js';
-
-// Synthetic fixture: BTC at 100,000 with a fat long wall at 95,000.
-const FEED = {
-  updated: new Date().toISOString(),
-  coins: {
-    BTC: {
-      mark: 100000, oiUsd: 2e9, coverage: { pct: 53 },
-      positions: [
-        [95000, 30e6, 0, '0xaaa0000000000000000000000000000000000001', 104000],
-        [94900, 15e6, 0, '0xaaa0000000000000000000000000000000000002', 103000],
-        [99500, 12e6, 0, '0xaaa0000000000000000000000000000000000003', 101000],
-        [112000, 20e6, 1, '0xbbb0000000000000000000000000000000000004', 98000],
-        [140000, 5e6, 1, '0xbbb0000000000000000000000000000000000005', 90000]
-      ]
-    }
-  }
-};
-const META = { BTC: { assetIndex: 0, szDecimals: 5, maxLeverage: 40, markPx: 100000, oiNtl: 2e9, dayNtlVlm: 2e9 } };
-
-test('binWalls: bins by 0.4% of mark, sides by price vs mark, sorted by size', () => {
-  const w = binWalls(FEED.coins.BTC.positions.map((p) => ({ price: p[0], sizeUsd: p[1] })), 100000);
-  assert.ok(w.length >= 3);
-  // 95000 → bin 238 (95200), 94900 → bin 237 (94800): adjacent bins, no merge
-  assert.equal(w[0].sizeUsd, 30e6);
-  assert.equal(w[0].side, 'long');
-  assert.ok(Math.abs(w[0].distPct + 5) < 1);
-  assert.equal(w[1].sizeUsd, 20e6); // the 112000 short wall ranks second
-  // 140000 is outside ±50%? no — inside; but check the 112000 short bin exists
-  assert.ok(w.some((x) => x.side === 'short'));
-});
-
-test('walls(): magnet detected only within 1.5% and ≥$10M', async () => {
-  _setFixtures({ feed: FEED, meta: META });
-  const r = await walls('BTC');
-  assert.equal(r.magnet.sizeUsd, 12e6); // 99500 wall is 0.5% away and ≥$10M
-  assert.equal(r.magnet.side, 'below');
-  assert.equal(r.coverage_pct, 53);
-  assert.ok(r.totalLiqBelowUsd > r.totalLiqAboveUsd);
-});
-
-test('pretradeCheck: high leverage lands in the wall → danger + clear-leverage suggestion', async () => {
-  _setFixtures({ feed: FEED, meta: META });
-  // long entry 100k: find a leverage whose liq is ~95k (inside the 45M wall)
-  const r = await pretradeCheck({ coin: 'BTC', dir: 'long', leverage: 18, entryPx: 100000 });
-  assert.equal(typeof r.liqPx, 'number');
-  assert.ok(r.liqPx < 100000);
-  if (r.liqInsideWall) {
-    assert.equal(r.verdict, 'danger');
-    assert.ok(r.suggestedClearLeverage == null || r.suggestedClearLeverage < 18);
-  } else {
-    assert.ok(['ok', 'warning'].includes(r.verdict));
-  }
-});
-
-test('pretradeCheck: low leverage clears the walls', async () => {
-  _setFixtures({ feed: FEED, meta: META });
-  const r = await pretradeCheck({ coin: 'BTC', dir: 'long', leverage: 2, entryPx: 100000 });
-  assert.equal(r.liqInsideWall, false);
-  assert.notEqual(r.verdict, 'danger');
-});
-
-test('pretradeCheck: rejects leverage above max', async () => {
-  _setFixtures({ feed: FEED, meta: META });
-  await assert.rejects(() => pretradeCheck({ coin: 'BTC', dir: 'long', leverage: 41 }), /exceeds max/);
-});
-
-test('cascade: returns model output shape from shipped computeCascade', async () => {
-  _setFixtures({ feed: FEED, meta: META });
-  const r = await cascade('BTC', 'down');
-  assert.equal(r.dir, 'down');
-  if (r.cascade) {
-    assert.ok(r.cascade.triggerPx > 0);
-    assert.ok(r.cascade.totalLiqUsd > 0);
-  }
-});
-
-test('whaleBook: sorted by notional, capped, honest fields present', async () => {
-  _setFixtures({ feed: FEED, meta: META });
-  const r = await whaleBook('BTC', 3);
-  assert.equal(r.positions.length, 3);
-  assert.ok(r.positions[0].notionalUsd >= r.positions[1].notionalUsd);
-  assert.ok(r.source.includes('NOT estimates'));
-});