eigen-skills 1.0.0

package/index.js

@@ -0,0 +1,23 @@
+/**
+ * eigen-skills — EigenLayer data & infra skills for AI agents
+ *
+ * Install:  npx skills add zeeshan8281/eigen-skills
+ * Usage:    Agents discover SKILL.md files in skills/ automatically.
+ *           For programmatic use, require this module.
+ */
+
+const EigenAPI = require('./skills/eigen-restaking/scripts/eigen-api');
+const AVSAPI = require('./skills/eigen-avs/scripts/avs-api');
+const RewardsAPI = require('./skills/eigen-rewards/scripts/rewards-api');
+const DelegationAPI = require('./skills/eigen-delegation/scripts/delegation-api');
+const EigenCompute = require('./skills/eigen-compute/scripts/compute-api');
+const EigenDA = require('./skills/eigen-da/scripts/da-api');
+
+module.exports = {
+    EigenAPI,
+    AVSAPI,
+    RewardsAPI,
+    DelegationAPI,
+    EigenCompute,
+    EigenDA,
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "eigen-skills",
+    "version": "1.0.0",
+    "description": "Agent Skills for EigenLayer — restaking, AVS, operators, rewards, delegation data powered by EigenExplorer API",
+    "main": "index.js",
+    "agents": {
+        "skills": "skills/"
+    },
+    "scripts": {
+        "test": "node scripts/test-all.js",
+        "demo": "node scripts/demo.js"
+    },
+    "keywords": [
+        "eigenlayer",
+        "eigen",
+        "restaking",
+        "avs",
+        "agent-skills",
+        "ai-agent",
+        "claude",
+        "openclaw",
+        "eigenexplorer"
+    ],
+    "author": "zeeshan8281",
+    "license": "MIT",
+    "dependencies": {
+        "axios": "^1.7.0"
+    }
+}

package/scripts/demo.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * Demo — run all eigen-agent-skills to verify they work.
+ *
+ * Usage:
+ *   EIGEN_API_KEY=your_key node scripts/demo.js
+ */
+
+const EigenAPI = require('../skills/eigen-restaking/scripts/eigen-api');
+const AVSAPI = require('../skills/eigen-avs/scripts/avs-api');
+const RewardsAPI = require('../skills/eigen-rewards/scripts/rewards-api');
+const DelegationAPI = require('../skills/eigen-delegation/scripts/delegation-api');
+
+const API_KEY = process.env.EIGEN_API_KEY;
+
+if (!API_KEY) {
+    console.error('❌  Set EIGEN_API_KEY env var. Get a free key at https://developer.eigenexplorer.com');
+    process.exit(1);
+}
+
+async function run() {
+    console.log('\n🔄 ═════════════════════════════════════');
+    console.log('   Eigen Agent Skills — Demo');
+    console.log('═══════════════════════════════════════\n');
+
+    const eigen = new EigenAPI(API_KEY);
+    const avs = new AVSAPI(API_KEY);
+    const rewards = new RewardsAPI(API_KEY);
+    const delegation = new DelegationAPI(API_KEY);
+
+    // 1. Health check
+    console.log('📡 Health check...');
+    const health = await eigen.healthCheck();
+    console.log(`   Status: ${health.ok ? '✅ Healthy' : '❌ Failed'}`);
+    if (health.tvl) console.log(`   EigenLayer TVL: ${JSON.stringify(health.tvl)}`);
+    console.log('');
+
+    // 2. Ecosystem metrics
+    console.log('📊 Ecosystem Metrics...');
+    const metrics = await eigen.getMetrics();
+    console.log(`   ${JSON.stringify(metrics, null, 2).substring(0, 500)}`);
+    console.log('');
+
+    // 3. Top 5 operators by TVL
+    console.log('👥 Top 5 Operators by TVL...');
+    const ops = await eigen.getOperators({ sortByTvl: 'desc', take: 5 });
+    if (ops.data) {
+        ops.data.forEach((op, i) => {
+            console.log(`   ${i + 1}. ${op.metadataName || op.address} — TVL: ${JSON.stringify(op.tvl?.tvl || 'N/A')} — Stakers: ${op.totalStakers}`);
+        });
+    }
+    console.log('');
+
+    // 4. Top 5 AVS by TVL
+    console.log('🛡️  Top 5 AVS by TVL...');
+    const avsList = await avs.getAllAVS({ sortByTvl: 'desc', take: 5 });
+    if (avsList.data) {
+        avsList.data.forEach((a, i) => {
+            console.log(`   ${i + 1}. ${a.metadataName || a.address} — TVL: ${JSON.stringify(a.tvl?.tvl || 'N/A')}`);
+        });
+    }
+    console.log('');
+
+    // 5. Top 5 operators by APY
+    console.log('💰 Top 5 Operators by APY...');
+    const topApy = await rewards.getTopOperatorsByAPY(5);
+    if (topApy.data) {
+        topApy.data.forEach((op, i) => {
+            console.log(`   ${i + 1}. ${op.metadataName || op.address} — APY: ${op.maxApy || 'N/A'}`);
+        });
+    }
+    console.log('');
+
+    // 6. Top 5 operators by delegation
+    console.log('🤝 Top 5 Operators by Delegation (staker count)...');
+    const topDel = await delegation.getTopDelegatedOperators(5);
+    if (topDel.data) {
+        topDel.data.forEach((op, i) => {
+            console.log(`   ${i + 1}. ${op.metadataName || op.address} — Stakers: ${op.totalStakers} — AVS: ${op.totalAvs}`);
+        });
+    }
+    console.log('');
+
+    console.log('═══════════════════════════════════════');
+    console.log('   ✅ Demo complete');
+    console.log('═══════════════════════════════════════\n');
+}
+
+run().catch(err => {
+    console.error('Demo failed:', err.message);
+    process.exit(1);
+});

package/skills/eigen-avs/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: eigen-avs
+description: "Query EigenLayer AVS (Actively Validated Services) — list services, operators per AVS, stakers per AVS, registration events, and operator-sets"
+version: 1.0.0
+metadata:
+  emoji: "🛡️"
+  tags: ["eigenlayer", "avs", "services", "operators", "security"]
+user-invocable: true
+---
+
+# EigenLayer AVS Skill
+
+Query live data about Actively Validated Services (AVS) on EigenLayer: service listings, operators securing each AVS, staker delegations, registration events, and operator-sets.
+
+## Data Source
+
+**EigenExplorer API** — `https://api.eigenexplorer.com`
+- Auth: `x-api-token` header (free key at https://developer.eigenexplorer.com)
+
+## When to use this skill
+
+Use when the user asks about:
+- AVS (Actively Validated Services) on EigenLayer
+- Which operators are securing a specific AVS
+- Stakers delegated to a specific AVS
+- AVS registration/deregistration events
+- Operator-sets for an AVS
+- Comparing AVS by TVL, staker count, or APY
+
+## How to query
+
+### Get all AVS (sorted by TVL)
+```bash
+curl -s "https://api.eigenexplorer.com/avs?withTvl=true&sortByTvl=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Search AVS by name
+```bash
+curl -s "https://api.eigenexplorer.com/avs?searchByText=eigenda&withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get a specific AVS
+```bash
+curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS?withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get operators registered to an AVS
+```bash
+curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operators?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get stakers for an AVS
+```bash
+curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/stakers?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get registration events for an AVS
+```bash
+curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/events/registration?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get operator-sets for an AVS
+```bash
+curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operator-sets?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get all AVS addresses (lightweight)
+```bash
+curl -s "https://api.eigenexplorer.com/avs/addresses" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+## Response Format
+
+Format results for the user with:
+- **Bold AVS names** and abbreviated addresses
+- TVL in human-readable form (e.g., "$500M")
+- Number of operators securing the AVS
+- Number of stakers
+- APY if available
+- Active/inactive status for operator registrations
+- Use bullet points, never tables in chat
+
+## Programmatic Usage
+
+```javascript
+const AVSAPI = require('eigen-agent-skills/skills/eigen-avs/scripts/avs-api');
+const api = new AVSAPI('YOUR_API_KEY');
+
+const allAVS = await api.getAllAVS({ sortByTvl: 'desc', take: 10 });
+const operators = await api.getAVSOperators('0xAVS_ADDRESS');
+const stakers = await api.getAVSStakers('0xAVS_ADDRESS');
+```

package/skills/eigen-avs/scripts/avs-api.js

@@ -0,0 +1,131 @@
+/**
+ * EigenLayer AVS (Actively Validated Services) API Client
+ *
+ * Data source: EigenExplorer REST API
+ * Covers: AVS listing, detail, operators per AVS, stakers per AVS, registration events
+ */
+
+const axios = require('axios');
+
+const MAINNET = 'https://api.eigenexplorer.com';
+const HOLESKY = 'https://api-holesky.eigenexplorer.com';
+
+class AVSAPI {
+    constructor(apiKey, { network = 'mainnet' } = {}) {
+        if (!apiKey) throw new Error('EigenExplorer API key required. Get one free at https://developer.eigenexplorer.com');
+        this.client = axios.create({
+            baseURL: network === 'holesky' ? HOLESKY : MAINNET,
+            headers: {
+                'x-api-token': apiKey,
+                'Content-Type': 'application/json',
+            },
+            timeout: 30000,
+        });
+    }
+
+    // ─── AVS Listing ──────────────────────────────────────
+
+    /**
+     * Get all AVS with optional filtering and sorting.
+     * @param {object} opts
+     * @param {boolean} [opts.withTvl=true]
+     * @param {string}  [opts.searchByText] - search AVS by name
+     * @param {'asc'|'desc'} [opts.sortByTvl]
+     * @param {'asc'|'desc'} [opts.sortByApy]
+     * @param {'asc'|'desc'} [opts.sortByTotalStakers]
+     * @param {number} [opts.skip=0]
+     * @param {number} [opts.take=12]
+     */
+    async getAllAVS(opts = {}) {
+        const params = {
+            withTvl: opts.withTvl !== false ? 'true' : 'false',
+            skip: opts.skip || 0,
+            take: opts.take || 12,
+        };
+        if (opts.searchByText) params.searchByText = opts.searchByText;
+        if (opts.sortByTvl) params.sortByTvl = opts.sortByTvl;
+        if (opts.sortByApy) params.sortByApy = opts.sortByApy;
+        if (opts.sortByTotalStakers) params.sortByTotalStakers = opts.sortByTotalStakers;
+
+        const { data } = await this.client.get('/avs', { params });
+        return data;
+    }
+
+    /**
+     * Get AVS addresses only (lightweight).
+     */
+    async getAVSAddresses() {
+        const { data } = await this.client.get('/avs/addresses');
+        return data;
+    }
+
+    /**
+     * Get detailed info for a single AVS.
+     * @param {string} address - AVS contract address
+     * @param {boolean} [withTvl=true]
+     */
+    async getAVS(address, withTvl = true) {
+        const { data } = await this.client.get(`/avs/${address}`, {
+            params: { withTvl: withTvl ? 'true' : 'false' },
+        });
+        return data;
+    }
+
+    // ─── AVS ↔ Operators ─────────────────────────────────
+
+    /**
+     * Get operators registered to a specific AVS.
+     * @param {string} avsAddress
+     * @param {object} opts
+     */
+    async getAVSOperators(avsAddress, opts = {}) {
+        const { data } = await this.client.get(`/avs/${avsAddress}/operators`, {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+
+    // ─── AVS ↔ Stakers ───────────────────────────────────
+
+    /**
+     * Get stakers delegated to a specific AVS.
+     * @param {string} avsAddress
+     * @param {object} opts
+     */
+    async getAVSStakers(avsAddress, opts = {}) {
+        const { data } = await this.client.get(`/avs/${avsAddress}/stakers`, {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+
+    // ─── AVS Registration Events ──────────────────────────
+
+    /**
+     * Get registration events for a specific AVS.
+     * @param {string} avsAddress
+     * @param {object} opts
+     */
+    async getAVSRegistrationEvents(avsAddress, opts = {}) {
+        const { data } = await this.client.get(`/avs/${avsAddress}/events/registration`, {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+
+    // ─── Operator-Sets per AVS ────────────────────────────
+
+    /**
+     * Get operator sets for a specific AVS.
+     * @param {string} avsAddress
+     * @param {object} opts
+     */
+    async getAVSOperatorSets(avsAddress, opts = {}) {
+        const { data } = await this.client.get(`/avs/${avsAddress}/operator-sets`, {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+}
+
+module.exports = AVSAPI;

package/skills/eigen-compute/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: eigen-compute
+description: "Deploy and manage applications on EigenCompute TEE (Trusted Execution Environment) — deploy, monitor, attest, and manage lifecycle via ecloud CLI"
+version: 1.0.0
+metadata:
+  emoji: "🔒"
+  tags: ["eigenlayer", "eigencompute", "tee", "tdx", "deploy", "attestation"]
+user-invocable: true
+---
+
+# EigenCompute Skill
+
+Deploy, manage, and attest applications running inside EigenCompute TEE (Trusted Execution Environment) powered by Intel TDX.
+
+## What is EigenCompute?
+
+EigenCompute runs your Docker containers inside **hardware-isolated Intel TDX TEEs**. Each deployed app gets:
+- **Encrypted memory** — the host cannot read your app's data
+- **Unique wallet** — cryptographic identity per deployment
+- **KMS signing key** — at `/usr/local/bin/kms-signing-public-key.pem`
+- **Sealed secrets** — env vars are unsealed inside the TEE at runtime
+- **Cryptographic attestation** — verifiable proof of what code is running
+
+## Prerequisites
+
+Install the ecloud CLI:
+```bash
+npm install -g @layr-labs/ecloud-cli
+```
+
+## When to use this skill
+
+Use when the user asks about:
+- Deploying to EigenCompute / TEE / EigenCloud
+- Checking app status, logs, or info
+- TEE attestation or verification
+- Managing EigenCompute apps (start, stop, terminate)
+- Dockerfile setup for TEE deployment
+- KMS signing or sealed secrets
+- EigenCompute troubleshooting
+
+## How to use
+
+### Authentication
+
+```bash
+# Login with existing key
+ecloud auth login
+
+# Or generate a new key
+ecloud auth generate --store
+
+# Check who you're authenticated as
+ecloud auth whoami
+```
+
+### Create a new app from template
+
+```bash
+ecloud compute app create --name my-app --language typescript
+# Languages: typescript, python, golang, rust
+```
+
+### Deploy from Dockerfile (recommended)
+
+```bash
+ecloud compute app deploy
+```
+- Select **"Build and deploy from Dockerfile"** (most reliable method)
+- Choose **Linux/AMD64** (standard TEE architecture)
+- Estimated cost: ~0.008 ETH per deploy (Sepolia testnet)
+
+**IMPORTANT:** "Deploy from registry" method is unreliable — apps often end up in `Status: Unknown` with no error. Always use "Build from Dockerfile".
+
+### Check app status
+
+```bash
+# List all your apps
+ecloud compute app list
+
+# Get info for a specific app
+ecloud compute app info <APP_ID>
+
+# View logs (may require admin permissions)
+ecloud compute app logs <APP_ID>
+```
+
+### Set environment variables (sealed secrets)
+
+```bash
+ecloud compute app env set \
+  MY_SECRET="value" \
+  API_KEY="key"
+```
+
+**Note:** You cannot inspect sealed secrets after they're set. Verify through your app's logging.
+
+### App lifecycle
+
+```bash
+# Start a stopped app
+ecloud compute app start <APP_ID>
+
+# Stop a running app
+ecloud compute app stop <APP_ID>
+
+# Terminate (permanent — creates new App ID on redeploy)
+ecloud compute app terminate <APP_ID>
+```
+
+### Upgrade (update running app)
+```bash
+ecloud compute app upgrade <APP_ID>
+```
+
+## TEE Container Internals
+
+Inside the TEE container, these are available:
+
+| Path | What |
+|------|------|
+| `/usr/local/bin/compute-source-env.sh` | Sources sealed env vars at runtime |
+| `/usr/local/bin/kms-signing-public-key.pem` | KMS signing public key |
+| `/usr/local/bin/kms-client` | KMS signing client binary |
+
+### Entrypoint pattern for TEE
+
+```bash
+#!/bin/bash
+# Source sealed secrets
+if [ -f "/usr/local/bin/compute-source-env.sh" ]; then
+    source /usr/local/bin/compute-source-env.sh
+fi
+
+# Start your app
+node server.js
+```
+
+### Dockerfile pattern for TEE
+
+```dockerfile
+FROM node:20-slim
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --production
+COPY . .
+EXPOSE 3000
+ENTRYPOINT ["bash", "entrypoint.sh"]
+```
+
+## TEE Attestation
+
+Collect attestation data to prove your app runs in a real TEE:
+
+```javascript
+const crypto = require('crypto');
+const fs = require('fs');
+
+function getAttestation() {
+    return {
+        appId: process.env.ECLOUD_APP_ID || null,
+        platform: 'Intel TDX (EigenCompute)',
+        kmsKeyFingerprint: getKMSFingerprint(),
+        nodeVersion: process.version,
+        uptimeSeconds: Math.floor(process.uptime()),
+        timestamp: new Date().toISOString(),
+    };
+}
+
+function getKMSFingerprint() {
+    try {
+        const pem = fs.readFileSync('/usr/local/bin/kms-signing-public-key.pem', 'utf-8');
+        return 'sha256:' + crypto.createHash('sha256').update(pem.trim()).digest('hex');
+    } catch { return null; }
+}
+```
+
+Verify at: `https://verify-sepolia.eigencloud.xyz`
+
+## Known Issues & Workarounds
+
+- **429 rate limiting** — The API rate-limits aggressively after deploys. Wait 30-60s before running `app list` or `app info`.
+- **Logs 403** — Even with "admin viewable" selected, `app logs` may return 403. Add logging within your app and expose it via HTTP as a workaround.
+- **IP changes on every deploy** — No static IP. Don't hardcode IPs in DNS or webhooks.
+- **App ID changes on terminate + redeploy** — No persistent identity across deploys.
+- **Secret rotation requires full redeploy** — No way to update env vars without terminate + deploy.
+
+## Programmatic Usage
+
+```javascript
+const EigenCompute = require('eigen-skills/skills/eigen-compute/scripts/compute-api');
+const compute = new EigenCompute();
+
+// These are wrappers around the ecloud CLI
+const apps = await compute.listApps();
+const info = await compute.getAppInfo('APP_ID');
+const attestation = compute.collectAttestation();
+```