eigen-skills 1.0.0

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

@@ -0,0 +1,153 @@
+/**
+ * EigenCompute API — Wrapper around ecloud CLI for programmatic TEE management
+ *
+ * Provides a JS API over the ecloud CLI commands for app deployment,
+ * lifecycle management, and TEE attestation.
+ */
+
+const { execSync } = require('child_process');
+const crypto = require('crypto');
+const fs = require('fs');
+
+class EigenCompute {
+    constructor() {
+        this.cliAvailable = this._checkCLI();
+    }
+
+    _checkCLI() {
+        try {
+            execSync('ecloud --version', { stdio: 'pipe' });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    _exec(cmd) {
+        if (!this.cliAvailable) throw new Error('ecloud CLI not installed. Run: npm install -g @layr-labs/ecloud-cli');
+        try {
+            return execSync(`ecloud ${cmd}`, { encoding: 'utf-8', timeout: 30000 }).trim();
+        } catch (err) {
+            throw new Error(`ecloud command failed: ${err.stderr || err.message}`);
+        }
+    }
+
+    // ─── Authentication ───────────────────────────────────
+
+    /**
+     * Check which address the CLI is authenticated as.
+     */
+    whoami() {
+        return this._exec('auth whoami');
+    }
+
+    // ─── App Management ───────────────────────────────────
+
+    /**
+     * List all deployed apps.
+     */
+    listApps() {
+        const output = this._exec('compute app list');
+        return output;
+    }
+
+    /**
+     * Get info for a specific app.
+     * @param {string} appId
+     */
+    getAppInfo(appId) {
+        return this._exec(`compute app info ${appId}`);
+    }
+
+    /**
+     * Get logs for a specific app.
+     * @param {string} appId
+     */
+    getAppLogs(appId) {
+        return this._exec(`compute app logs ${appId}`);
+    }
+
+    /**
+     * Stop a running app.
+     * @param {string} appId
+     */
+    stopApp(appId) {
+        return this._exec(`compute app stop ${appId}`);
+    }
+
+    /**
+     * Start a stopped app.
+     * @param {string} appId
+     */
+    startApp(appId) {
+        return this._exec(`compute app start ${appId}`);
+    }
+
+    // ─── TEE Attestation ──────────────────────────────────
+
+    /**
+     * Collect attestation data from inside a TEE container.
+     * Call this from within a running EigenCompute deployment.
+     */
+    collectAttestation() {
+        return {
+            appId: process.env.ECLOUD_APP_ID || null,
+            platform: 'Intel TDX (EigenCompute)',
+            imageDigest: this._getImageDigest(),
+            kmsKeyFingerprint: this._getKMSFingerprint(),
+            nodeVersion: process.version,
+            uptimeSeconds: Math.floor(process.uptime()),
+            timestamp: new Date().toISOString(),
+        };
+    }
+
+    /**
+     * Hash config files to prove integrity.
+     * @param {string[]} filePaths - paths to config files
+     */
+    computeConfigHash(filePaths) {
+        const contents = [];
+        const resolved = [];
+        for (const p of filePaths) {
+            try {
+                const data = fs.readFileSync(p, 'utf-8');
+                contents.push(data);
+                resolved.push(p);
+            } catch { /* skip missing files */ }
+        }
+        if (contents.length === 0) return { hash: null, files: [] };
+        const hash = 'sha256:' + crypto.createHash('sha256').update(contents.join('\n')).digest('hex');
+        return { hash, files: resolved };
+    }
+
+    _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; }
+    }
+
+    _getImageDigest() {
+        if (process.env.IMAGE_DIGEST) return process.env.IMAGE_DIGEST;
+        if (process.env.HOSTNAME) {
+            try {
+                const cgroup = fs.readFileSync('/proc/self/cgroup', 'utf-8');
+                const match = cgroup.match(/docker[/-]([a-f0-9]{64})/);
+                if (match) return 'container:' + match[1].substring(0, 12);
+            } catch { /* not in docker */ }
+        }
+        return null;
+    }
+
+    // ─── Health ───────────────────────────────────────────
+
+    healthCheck() {
+        return {
+            cliInstalled: this.cliAvailable,
+            insideTEE: !!this._getKMSFingerprint(),
+            hasAppId: !!process.env.ECLOUD_APP_ID,
+        };
+    }
+}
+
+module.exports = EigenCompute;

package/skills/eigen-da/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: eigen-da
+description: "Store and retrieve data blobs on EigenDA (Data Availability layer) — disperse blobs, retrieve by commitment, check status via proxy or direct API"
+version: 1.0.0
+metadata:
+  emoji: "📦"
+  tags: ["eigenlayer", "eigenda", "data-availability", "blobs", "storage"]
+user-invocable: true
+---
+
+# EigenDA Skill
+
+Store and retrieve data blobs on EigenDA — EigenLayer's Data Availability layer. EigenDA provides high-throughput, low-cost data availability for rollups and applications.
+
+## What is EigenDA?
+
+EigenDA is a **data availability (DA) service** built on EigenLayer. It lets you:
+- **Store blobs** — submit arbitrary data, get back a cryptographic commitment
+- **Retrieve blobs** — fetch data using the commitment hash
+- **Verify** — KZG commitments prove data integrity
+
+## Architecture
+
+```
+Your App → EigenDA Proxy (localhost:3100) → EigenDA Disperser → EigenDA Operators
+```
+
+The **EigenDA Proxy** is a local REST server that handles encoding, KZG verification, and communication with the EigenDA disperser network.
+
+## Prerequisites
+
+Run the EigenDA Proxy locally via Docker:
+
+```bash
+docker run -d \
+  --name eigenda-proxy \
+  -p 3100:3100 \
+  ghcr.io/layr-labs/eigenda-proxy:latest \
+  --eigenda.disperser-rpc=disperser-sepolia.eigenda.xyz:443 \
+  --eigenda.service-manager-addr=0xD4A7E1Bd8015057293f0D0A557088c286942e84b \
+  --eigenda.eth-rpc=YOUR_SEPOLIA_RPC_URL \
+  --eigenda.status-query-timeout=45s \
+  --eigenda.signer-private-key-hex=YOUR_PRIVATE_KEY \
+  --memstore.enabled=false \
+  --eigenda.disable-tls=false
+```
+
+## When to use this skill
+
+Use when the user asks about:
+- Storing data on EigenDA
+- Retrieving data from EigenDA by commitment
+- Data availability for rollups
+- Blob storage and retrieval
+- EigenDA proxy setup
+- Verifying data commitments
+- EigenDA health/status checks
+
+## How to use
+
+### Store a blob via proxy
+
+```bash
+curl -s -X POST "http://127.0.0.1:3100/put?commitment_mode=standard" \
+  -H "Content-Type: application/json" \
+  -d '{"key": "value", "timestamp": "2025-01-01T00:00:00Z"}'
+```
+
+Returns: a hex commitment string (the blob's address on EigenDA).
+
+### Retrieve a blob via proxy
+
+```bash
+curl -s "http://127.0.0.1:3100/get/COMMITMENT_HASH?commitment_mode=standard"
+```
+
+Returns: the original JSON data.
+
+### Health check
+
+```bash
+curl -s "http://127.0.0.1:3100/health"
+```
+
+### View blob on explorer
+
+After storing, view the blob at:
+```
+https://blobs-sepolia.eigenda.xyz/blobs/COMMITMENT_HASH
+```
+
+## EigenDA v2 Disperser API (Direct)
+
+For direct access without the proxy (advanced):
+
+### Disperse a blob
+The v2 disperser uses gRPC at `disperser-sepolia.eigenda.xyz:443`:
+- `DisperseBlob()` — enqueue a blob for dispersal
+- `GetBlobStatus()` — poll dispersal status
+- `GetBlobCommitment()` — get the KZG commitment
+
+### Retrieve from relay
+The v2 Relay API provides:
+- `GetBlob(blob_key)` — retrieve blob from relay nodes
+
+## Configuration
+
+| Env Var | Default | Description |
+|---------|---------|-------------|
+| `EIGENDA_PROXY_URL` | `http://127.0.0.1:3100` | Proxy address |
+| `EIGENDA_COMMITMENT_MODE` | `standard` | `standard` or `optimistic` |
+| `EIGENDA_TIMEOUT` | `60000` | Timeout in ms |
+
+### Commitment modes
+
+- **standard** — full KZG commitment, highest security
+- **optimistic** — faster but with weaker guarantees
+
+## Networks
+
+| Network | Disperser RPC | Service Manager |
+|---------|---------------|-----------------|
+| Sepolia | `disperser-sepolia.eigenda.xyz:443` | `0xD4A7E1Bd8015057293f0D0A557088c286942e84b` |
+| Mainnet | `disperser.eigenda.xyz:443` | Check EigenLayer docs |
+
+## Programmatic Usage
+
+```javascript
+const EigenDA = require('eigen-skills/skills/eigen-da/scripts/da-api');
+
+const da = new EigenDA({
+  proxyUrl: 'http://127.0.0.1:3100',  // default
+  commitmentMode: 'standard',          // default
+  timeout: 60000,                      // default
+});
+
+// Store data
+const commitment = await da.store({ key: 'value', timestamp: new Date() });
+console.log('Commitment:', commitment);
+console.log('Explorer:', da.getExplorerUrl(commitment));
+
+// Retrieve data
+const data = await da.retrieve(commitment);
+console.log('Retrieved:', data);
+
+// Health check
+const healthy = await da.healthCheck();
+```

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

@@ -0,0 +1,128 @@
+/**
+ * EigenDA API Client — Blob Storage via Local Proxy
+ *
+ * Stores and retrieves data blobs on EigenDA through the local proxy.
+ * Proxy handles KZG commitments, encoding, and disperser communication.
+ *
+ * Proxy endpoints:
+ *   POST /put?commitment_mode=standard  → store blob, get commitment hash
+ *   GET  /get/<commitment>?commitment_mode=standard → retrieve stored blob
+ *   GET  /health → proxy health check
+ */
+
+const axios = require('axios');
+
+class EigenDA {
+    /**
+     * @param {object} opts
+     * @param {string} [opts.proxyUrl='http://127.0.0.1:3100']
+     * @param {string} [opts.commitmentMode='standard'] - 'standard' | 'optimistic'
+     * @param {number} [opts.timeout=60000]
+     */
+    constructor(opts = {}) {
+        this.proxyUrl = opts.proxyUrl || process.env.EIGENDA_PROXY_URL || 'http://127.0.0.1:3100';
+        this.commitmentMode = opts.commitmentMode || process.env.EIGENDA_COMMITMENT_MODE || 'standard';
+        this.timeout = opts.timeout || parseInt(process.env.EIGENDA_TIMEOUT || '60000', 10);
+
+        this.client = axios.create({
+            baseURL: this.proxyUrl,
+            timeout: this.timeout,
+        });
+    }
+
+    /**
+     * Store a JSON payload on EigenDA.
+     * @param {object} data - the data to store
+     * @returns {Promise<string>} commitment hash
+     */
+    async store(data) {
+        const payload = JSON.stringify(data);
+        console.log(`[EigenDA] Storing blob (${payload.length} bytes)...`);
+
+        try {
+            const response = await this.client.post(
+                `/put?commitment_mode=${this.commitmentMode}`,
+                payload,
+                { headers: { 'Content-Type': 'application/json' } }
+            );
+
+            const commitment = response.data;
+            if (!commitment || typeof commitment !== 'string') {
+                throw new Error(`Invalid commitment: ${JSON.stringify(response.data)}`);
+            }
+
+            console.log(`[EigenDA] ✅ Stored. Commitment: ${commitment.substring(0, 40)}...`);
+            return commitment;
+        } catch (error) {
+            const msg = this._formatError(error);
+            console.error(`[EigenDA] ❌ Store failed: ${msg}`);
+            throw new Error(`EigenDA store failed: ${msg}`);
+        }
+    }
+
+    /**
+     * Retrieve a blob from EigenDA by commitment.
+     * @param {string} commitment
+     * @returns {Promise<object>} parsed JSON
+     */
+    async retrieve(commitment) {
+        console.log(`[EigenDA] Retrieving blob: ${commitment.substring(0, 40)}...`);
+
+        try {
+            const response = await this.client.get(
+                `/get/${commitment}?commitment_mode=${this.commitmentMode}`
+            );
+
+            const payload = response.data;
+            if (typeof payload === 'string') {
+                return JSON.parse(payload);
+            }
+            return payload;
+        } catch (error) {
+            const msg = this._formatError(error);
+            console.error(`[EigenDA] ❌ Retrieve failed: ${msg}`);
+            throw new Error(`EigenDA retrieve failed: ${msg}`);
+        }
+    }
+
+    /**
+     * Get the EigenDA blob explorer URL for a commitment.
+     * @param {string} commitment
+     * @param {string} [network='sepolia']
+     * @returns {string}
+     */
+    getExplorerUrl(commitment, network = 'sepolia') {
+        const base = network === 'mainnet'
+            ? 'https://blobs.eigenda.xyz/blobs'
+            : 'https://blobs-sepolia.eigenda.xyz/blobs';
+        return `${base}/${commitment}`;
+    }
+
+    /**
+     * Health check — ping the proxy.
+     * @returns {Promise<boolean>}
+     */
+    async healthCheck() {
+        try {
+            const response = await this.client.get('/health', {
+                validateStatus: () => true,
+                timeout: 5000,
+            });
+            return response.status === 200 || response.status === 404;
+        } catch {
+            return false;
+        }
+    }
+
+    _formatError(error) {
+        if (axios.isAxiosError(error) && error.response) {
+            return `HTTP ${error.response.status}: ${typeof error.response.data === 'string'
+                ? error.response.data
+                : JSON.stringify(error.response.data)
+                }`;
+        }
+        return error.message || String(error);
+    }
+}
+
+module.exports = EigenDA;

package/skills/eigen-delegation/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: eigen-delegation
+description: "Query EigenLayer delegation data — delegation events, operator delegations, staker positions, operator-sets, and top delegated operators"
+version: 1.0.0
+metadata:
+  emoji: "🤝"
+  tags: ["eigenlayer", "delegation", "operators", "stakers", "operator-sets"]
+user-invocable: true
+---
+
+# EigenLayer Delegation Skill
+
+Query live delegation data from EigenLayer: delegation/undelegation events, operator delegation profiles, staker delegation positions, operator-sets, and find the most delegated operators.
+
+## 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:
+- Who is delegating to whom
+- Delegation/undelegation events
+- Top operators by delegation (most stakers, most TVL)
+- A specific staker's delegation position
+- Which operator a staker is delegated to
+- Operator-sets
+- Withdrawal queue or pending undelegations
+
+## How to query
+
+### Get top operators by total stakers (most delegated)
+```bash
+curl -s "https://api.eigenexplorer.com/operators?withTvl=true&sortByTotalStakers=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get top operators by TVL (most capital delegated)
+```bash
+curl -s "https://api.eigenexplorer.com/operators?withTvl=true&sortByTvl=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get a specific operator's delegation profile
+```bash
+curl -s "https://api.eigenexplorer.com/operators/0xOPERATOR_ADDRESS?withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get stakers delegating to an operator
+```bash
+curl -s "https://api.eigenexplorer.com/operators/0xOPERATOR_ADDRESS/stakers?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get which operator a staker has delegated to
+```bash
+curl -s "https://api.eigenexplorer.com/stakers/0xSTAKER_ADDRESS" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get staker withdrawals (undelegations)
+```bash
+curl -s "https://api.eigenexplorer.com/stakers/0xSTAKER_ADDRESS/withdrawals?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get delegation events
+```bash
+curl -s "https://api.eigenexplorer.com/events?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get all operator-sets
+```bash
+curl -s "https://api.eigenexplorer.com/operator-sets?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+### Get operator-sets for a specific AVS
+```bash
+curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operator-sets?take=20" -H "x-api-token: $EIGEN_API_KEY"
+```
+
+## Response Format
+
+Format results for the user with:
+- **Bold operator names** and abbreviated addresses
+- Total stakers count
+- TVL in human-readable form
+- Shares breakdown by strategy where relevant
+- Active vs inactive AVS registrations
+- Use bullet points, never tables in chat
+
+## Programmatic Usage
+
+```javascript
+const DelegationAPI = require('eigen-agent-skills/skills/eigen-delegation/scripts/delegation-api');
+const api = new DelegationAPI('YOUR_API_KEY');
+
+const topDelegated = await api.getTopDelegatedOperators(10);
+const topByTVL = await api.getTopOperatorsByTVL(10);
+const opProfile = await api.getOperatorDelegation('0x...');
+const stakerPos = await api.getStakerDelegation('0x...');
+```

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

@@ -0,0 +1,160 @@
+/**
+ * EigenLayer Delegation API Client
+ *
+ * Data source: EigenExplorer REST API
+ * Covers: delegation events, operator-sets, staker ↔ operator delegation tracking
+ */
+
+const axios = require('axios');
+
+const MAINNET = 'https://api.eigenexplorer.com';
+const HOLESKY = 'https://api-holesky.eigenexplorer.com';
+
+class DelegationAPI {
+    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,
+        });
+    }
+
+    // ─── Delegation Events ────────────────────────────────
+
+    /**
+     * Get recent delegation/undelegation events across the protocol.
+     * @param {object} opts
+     * @param {string} [opts.type] - 'DELEGATION' | 'UNDELEGATION'
+     * @param {number} [opts.skip=0]
+     * @param {number} [opts.take=12]
+     */
+    async getDelegationEvents(opts = {}) {
+        const params = {
+            skip: opts.skip || 0,
+            take: opts.take || 12,
+        };
+        if (opts.type) params.type = opts.type;
+
+        const { data } = await this.client.get('/events', { params });
+        return data;
+    }
+
+    // ─── Operator Delegation Details ──────────────────────
+
+    /**
+     * Get an operator's full delegation profile (stakers, shares, strategies, TVL).
+     * @param {string} operatorAddress
+     */
+    async getOperatorDelegation(operatorAddress) {
+        const { data } = await this.client.get(`/operators/${operatorAddress}`, {
+            params: { withTvl: 'true' },
+        });
+        return {
+            address: data.address,
+            name: data.metadataName,
+            totalStakers: data.totalStakers,
+            totalAvs: data.totalAvs,
+            shares: data.shares,
+            tvl: data.tvl,
+            avsRegistrations: data.avsRegistrations,
+        };
+    }
+
+    /**
+     * Get all stakers delegating to a specific operator.
+     * @param {string} operatorAddress
+     * @param {object} opts
+     */
+    async getOperatorStakers(operatorAddress, opts = {}) {
+        const { data } = await this.client.get(`/operators/${operatorAddress}/stakers`, {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+
+    // ─── Staker Delegation ────────────────────────────────
+
+    /**
+     * Get which operator a staker has delegated to and their position details.
+     * @param {string} stakerAddress
+     */
+    async getStakerDelegation(stakerAddress) {
+        const { data } = await this.client.get(`/stakers/${stakerAddress}`);
+        return data;
+    }
+
+    /**
+     * Get a staker's withdrawal history (partial/full undelegations).
+     * @param {string} stakerAddress
+     * @param {object} opts
+     */
+    async getStakerWithdrawals(stakerAddress, opts = {}) {
+        const { data } = await this.client.get(`/stakers/${stakerAddress}/withdrawals`, {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+
+    // ─── Operator-Sets ────────────────────────────────────
+
+    /**
+     * Get all operator-sets (the new slashing-era grouping model).
+     * @param {object} opts
+     */
+    async getOperatorSets(opts = {}) {
+        const { data } = await this.client.get('/operator-sets', {
+            params: { skip: opts.skip || 0, take: opts.take || 12 },
+        });
+        return data;
+    }
+
+    /**
+     * Get a specific operator-set by AVS address + operatorSetId.
+     * @param {string} avsAddress
+     * @param {string} operatorSetId
+     */
+    async getOperatorSet(avsAddress, operatorSetId) {
+        const { data } = await this.client.get(`/operator-sets/${avsAddress}/${operatorSetId}`);
+        return data;
+    }
+
+    // ─── Top Delegated Operators ──────────────────────────
+
+    /**
+     * Get operators sorted by total stakers (most delegated first).
+     * @param {number} [limit=10]
+     */
+    async getTopDelegatedOperators(limit = 10) {
+        const { data } = await this.client.get('/operators', {
+            params: {
+                withTvl: 'true',
+                sortByTotalStakers: 'desc',
+                take: limit,
+                skip: 0,
+            },
+        });
+        return data;
+    }
+
+    /**
+     * Get operators sorted by TVL (most capital delegated first).
+     * @param {number} [limit=10]
+     */
+    async getTopOperatorsByTVL(limit = 10) {
+        const { data } = await this.client.get('/operators', {
+            params: {
+                withTvl: 'true',
+                sortByTvl: 'desc',
+                take: limit,
+                skip: 0,
+            },
+        });
+        return data;
+    }
+}
+
+module.exports = DelegationAPI;