---
updatedAt: 2026-03-03T12:05:48.000Z
agentTools:
  projectIndex: https://docs.stake.fish/llms.txt
---

# EigenLayer (native Ether restaking)

@stakefish/sdk-eigenlayer

The @stakefish/sdk-eigenlayer is a JavaScript/TypeScript library that provides a unified interface for EigenLayer restaking operations with stake.fish. It allows developers to manage EigenPods, delegate to operators, manage withdrawals, handle checkpoints, and claim rewards.

## Table of Contents

* [Installation](#installation)
* [Type Imports](#type-imports)
* [API Reference](#api-reference)
  * [Constructor](#constructor)
  * [Create Pod](#create-pod)
  * [Delegation](#delegation)
  * [Undelegation](#undelegation)
  * [Queue Withdrawal](#queue-withdrawal)
  * [Complete Withdrawal](#complete-withdrawal)
  * [Start Checkpoint](#start-checkpoint)
  * [Verify Withdrawal Credentials](#verify-withdrawal-credentials)
  * [Verify Checkpoint Proofs](#verify-checkpoint-proofs)
  * [Claim Rewards](#claim-rewards)
  * [Get Staker Info](#get-staker-info)
  * [Get Withdrawals](#get-withdrawals)
  * [Get Rewards](#get-rewards)
  * [Signing](#signing)
  * [Broadcasting](#broadcasting)
* [Examples](#examples)
* [Notes](#notes)

## Installation

```bash
npm install @stakefish/sdk-eigenlayer
```

```bash
yarn add @stakefish/sdk-eigenlayer
```

## Type Imports

```typescript
import { EigenLayer } from '@stakefish/sdk-eigenlayer';
import type {
  EigenLayerConfig,
  EigenLayerAddress,
  EigenLayerQueueWithdrawal,
  EigenLayerCompleteWithdrawal,
  EigenLayerStartCheckpoint,
  EigenLayerClaimRewards,
  EigenLayerSign,
  EigenLayerBroadcast,
  EigenLayerUnsignedTransaction,
  EigenLayerSignedTransaction,
  EigenLayerBroadcastResult,
  EigenLayerStakerResponseDto,
  EigenLayerWithdrawalsResponseDto,
  EigenLayerRewardsResponseDto,
} from '@stakefish/sdk-eigenlayer';
```

## API Reference

### Constructor

```typescript
import type { EigenLayerConfig } from '@stakefish/sdk-eigenlayer';

new EigenLayer({ ethereumRpcUrl: 'https://mainnet.infura.io/v3/YOUR_PROJECT_ID' }: EigenLayerConfig)
```

Creates a new EigenLayer SDK instance.

**Parameters:**

* `ethereumRpcUrl`: Ethereum RPC endpoint URL
* `network` (optional): Network to use, `'mainnet'` or `'hoodi'`. Defaults to `'mainnet'`.

> **Note:** Contract addresses, stakefish operator, and service URLs are automatically configured per network.

### Create Pod

```typescript
import type { EigenLayerAddress, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

createPod({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to deploy an EigenPod for the staker. Must be called before any other staking operations.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Delegation

```typescript
import type { EigenLayerAddress, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

delegate({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to delegate to the stake.fish operator. Requires an existing EigenPod.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Undelegation

```typescript
import type { EigenLayerAddress, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

undelegate({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to undelegate from the operator. This starts a \~14-day escrow period.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Queue Withdrawal

```typescript
import type { EigenLayerQueueWithdrawal, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

queueWithdrawal({ delegatorAddress: '0x...', strategies: ['0x...'], shares: ['32000000000'] }: EigenLayerQueueWithdrawal): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to queue a withdrawal of restaked shares.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker
* `strategies`: Array of strategy contract addresses
* `shares`: Array of share amounts (must match strategies length)

### Complete Withdrawal

```typescript
import type { EigenLayerCompleteWithdrawal, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

completeWithdrawal({ delegatorAddress: '0x...', withdrawalRoot: '0x...', tokens: ['0x...'], receiveAsTokens: true }: EigenLayerCompleteWithdrawal): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to complete a queued withdrawal after the escrow period.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker
* `withdrawalRoot`: The withdrawal root hash from queueWithdrawal
* `tokens`: Array of token addresses matching withdrawal strategies
* `receiveAsTokens`: Whether to receive as tokens (`true`) or restake (`false`)

### Start Checkpoint

```typescript
import type { EigenLayerStartCheckpoint, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

startCheckpoint({ delegatorAddress: '0x...', revertIfNoBalance: false }: EigenLayerStartCheckpoint): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to start a checkpoint on the staker's EigenPod.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker
* `revertIfNoBalance` (optional): Revert if no balance to checkpoint. Defaults to `false`.

### Verify Withdrawal Credentials

```typescript
import type { EigenLayerAddress, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

verifyWithdrawalCredentials({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerUnsignedTransaction[]>
```

Returns an array of unsigned transactions to verify withdrawal credentials for unproven validators. Transactions are batched by the proof generation service and **must be submitted in order**.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Verify Checkpoint Proofs

```typescript
import type { EigenLayerAddress, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

verifyCheckpointProofs({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerUnsignedTransaction[]>
```

Returns an array of unsigned transactions to verify checkpoint proofs for an active checkpoint. Transactions are batched and **must be submitted in order**.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Claim Rewards

```typescript
import type { EigenLayerClaimRewards, EigenLayerUnsignedTransaction } from '@stakefish/sdk-eigenlayer';

claimRewards({ delegatorAddress: '0x...', tokens: ['0x...'] }: EigenLayerClaimRewards): Promise<EigenLayerUnsignedTransaction>
```

Creates an unsigned transaction to claim accumulated rewards with Merkle proof.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker
* `tokens`: Array of reward token addresses to claim

### Get Staker Info

```typescript
import type { EigenLayerAddress, EigenLayerStakerResponseDto } from '@stakefish/sdk-eigenlayer';

getStaker({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerStakerResponseDto>
```

Gets the staker profile including delegation status, validator info, and checkpoint state.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

**Returns:** Object containing:

* `address`: Staker address
* `eigenPod`: EigenPod contract address (or null)
* `isDelegated`: Whether delegated to an operator
* `delegatedTo`: Operator address (or null)
* `sharesGwei`: Restaked shares in gwei
* `activeValidatorCount`: Number of verified validators
* `unprovenValidatorCount`: Number of unproven validators
* `canStartCheckpoint`: Whether a checkpoint can be started
* `needsCheckpointVerify`: Whether checkpoint proofs need verification
* `validators`: List of validator details

### Get Withdrawals

```typescript
import type { EigenLayerAddress, EigenLayerWithdrawalsResponseDto } from '@stakefish/sdk-eigenlayer';

getWithdrawals({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerWithdrawalsResponseDto>
```

Gets queued and completable withdrawals for the staker.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Get Rewards

```typescript
import type { EigenLayerAddress, EigenLayerRewardsResponseDto } from '@stakefish/sdk-eigenlayer';

getRewards({ delegatorAddress: '0x...' }: EigenLayerAddress): Promise<EigenLayerRewardsResponseDto>
```

Gets summarized rewards per token for the staker.

**Parameters:**

* `delegatorAddress`: The Ethereum address of the staker

### Signing

```typescript
import type { EigenLayerSign, EigenLayerUnsignedTransaction, EigenLayerSignedTransaction } from '@stakefish/sdk-eigenlayer';

sign({ privateKeyHex: '0x...', unsignedTx }: EigenLayerSign): Promise<EigenLayerSignedTransaction>
```

Signs an unsigned transaction using the provided private key. This operation works completely offline.

**Parameters:**

* `privateKeyHex`: The private key in hexadecimal format (with or without '0x' prefix)
* `unsignedTx`: The unsigned transaction object from any prepare method

### Broadcasting

```typescript
import type { EigenLayerBroadcast, EigenLayerSignedTransaction, EigenLayerBroadcastResult } from '@stakefish/sdk-eigenlayer';

broadcast({ signedTx, checkInclusion: true, timeoutMs: 60000, pollIntervalMs: 2000 }: EigenLayerBroadcast): Promise<EigenLayerBroadcastResult>
```

Broadcasts the signed transaction to the Ethereum network.

**Parameters:**

* `signedTx`: The signed transaction object from `sign()`
* `checkInclusion` (optional): Whether to wait for transaction inclusion. Defaults to `false`.
* `timeoutMs` (optional): Maximum time to wait for inclusion in milliseconds. Defaults to `60000`.
* `pollIntervalMs` (optional): Interval between inclusion checks in milliseconds. Defaults to `2000`.

**Returns:** `EigenLayerBroadcastResult` object containing:

* `txId`: The transaction hash
* `success`: Boolean indicating if the transaction was successful
* `error`: Error message if the transaction failed (optional)

## Examples

### Basic Setup

```typescript
import { EigenLayer } from '@stakefish/sdk-eigenlayer';
import type { EigenLayerConfig } from '@stakefish/sdk-eigenlayer';
// or: const { EigenLayer } = require('@stakefish/sdk-eigenlayer');

const config: EigenLayerConfig = {
  ethereumRpcUrl: 'https://mainnet.infura.io/v3/YOUR_PROJECT_ID',
};

const eigenlayer = new EigenLayer(config);
```

### Create Pod and Delegate

```typescript
import type { EigenLayerUnsignedTransaction, EigenLayerSignedTransaction, EigenLayerBroadcastResult } from '@stakefish/sdk-eigenlayer';

const staker = '0x...';
const privateKeyHex = process.env.PRIVATE_KEY!;

// 1. Create EigenPod
const createPodTx: EigenLayerUnsignedTransaction = await eigenlayer.createPod({ delegatorAddress: staker });
const signedCreatePod: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: createPodTx });
const createPodResult: EigenLayerBroadcastResult = await eigenlayer.broadcast({ signedTx: signedCreatePod, checkInclusion: true });
console.log(`Pod created: ${createPodResult.txId}`);

// 2. Delegate to stake.fish
const delegateTx: EigenLayerUnsignedTransaction = await eigenlayer.delegate({ delegatorAddress: staker });
const signedDelegate: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: delegateTx });
const delegateResult: EigenLayerBroadcastResult = await eigenlayer.broadcast({ signedTx: signedDelegate, checkInclusion: true });
console.log(`Delegated: ${delegateResult.txId}`);
```

### Check Staker Status

```typescript
import type { EigenLayerStakerResponseDto } from '@stakefish/sdk-eigenlayer';

const stakerInfo: EigenLayerStakerResponseDto = await eigenlayer.getStaker({ delegatorAddress: '0x...' });
console.log(`Delegated: ${stakerInfo.isDelegated}`);
console.log(`Operator: ${stakerInfo.delegatedTo}`);
console.log(`Active validators: ${stakerInfo.activeValidatorCount}`);
```

### Checkpoint Workflow

```typescript
import type { EigenLayerUnsignedTransaction, EigenLayerSignedTransaction } from '@stakefish/sdk-eigenlayer';

// 1. Start checkpoint
const checkpointTx: EigenLayerUnsignedTransaction = await eigenlayer.startCheckpoint({ delegatorAddress: staker });
const signedCheckpoint: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: checkpointTx });
await eigenlayer.broadcast({ signedTx: signedCheckpoint, checkInclusion: true });

// 2. Verify credential proofs (batched, submit in order)
const credentialTxs: EigenLayerUnsignedTransaction[] = await eigenlayer.verifyWithdrawalCredentials({ delegatorAddress: staker });
for (const tx of credentialTxs) {
  const signed: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: tx });
  await eigenlayer.broadcast({ signedTx: signed, checkInclusion: true });
}

// 3. Verify checkpoint proofs (batched, submit in order)
const checkpointProofTxs: EigenLayerUnsignedTransaction[] = await eigenlayer.verifyCheckpointProofs({ delegatorAddress: staker });
for (const tx of checkpointProofTxs) {
  const signed: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: tx });
  await eigenlayer.broadcast({ signedTx: signed, checkInclusion: true });
}
```

### Withdrawal Workflow

```typescript
import type { EigenLayerUnsignedTransaction, EigenLayerSignedTransaction, EigenLayerWithdrawalsResponseDto } from '@stakefish/sdk-eigenlayer';

// 1. Queue withdrawal
const queueTx: EigenLayerUnsignedTransaction = await eigenlayer.queueWithdrawal({
  delegatorAddress: staker,
  strategies: ['0xbeaC0eeEeeeeEEeEeEEEEeeEEeEeeeEeeEEBEaC0'],
  shares: ['32000000000'],
});
const signedQueue: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: queueTx });
await eigenlayer.broadcast({ signedTx: signedQueue, checkInclusion: true });

// 2. Check withdrawal status (after ~14 day escrow)
const withdrawals: EigenLayerWithdrawalsResponseDto = await eigenlayer.getWithdrawals({ delegatorAddress: staker });
const completable = withdrawals.withdrawals.filter(w => w.isCompletable);

// 3. Complete withdrawal
if (completable.length > 0) {
  const completeTx: EigenLayerUnsignedTransaction = await eigenlayer.completeWithdrawal({
    delegatorAddress: staker,
    withdrawalRoot: completable[0].withdrawalRoot,
    tokens: ['0x0000000000000000000000000000000000000000'], // ETH
    receiveAsTokens: true,
  });
  const signedComplete: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: completeTx });
  await eigenlayer.broadcast({ signedTx: signedComplete, checkInclusion: true });
}
```

### Claim Rewards

```typescript
import type { EigenLayerUnsignedTransaction, EigenLayerSignedTransaction, EigenLayerRewardsResponseDto } from '@stakefish/sdk-eigenlayer';

const rewards: EigenLayerRewardsResponseDto = await eigenlayer.getRewards({ delegatorAddress: staker });
const claimableTokens = rewards.rewards
  .filter(r => BigInt(r.claimable) > 0n)
  .map(r => r.token);

if (claimableTokens.length > 0) {
  const claimTx: EigenLayerUnsignedTransaction = await eigenlayer.claimRewards({
    delegatorAddress: staker,
    tokens: claimableTokens,
  });
  const signedClaim: EigenLayerSignedTransaction = await eigenlayer.sign({ privateKeyHex, unsignedTx: claimTx });
  await eigenlayer.broadcast({ signedTx: signedClaim, checkInclusion: true });
}
```

### Hoodi Testnet

```typescript
const eigenlayer = new EigenLayer({
  ethereumRpcUrl: 'https://hoodi.infura.io/v3/YOUR_PROJECT_ID',
  network: 'hoodi',
});
```

## Notes

* **EigenPod is required** -- you must create an EigenPod before delegating or performing other operations
* **Staking happens on Ethereum** -- you need ETH to pay gas fees
* **Delegation is to operators** -- EigenLayer delegates to operators (like stake.fish), not validators directly
* **Undelegation has a \~14-day escrow** -- queued withdrawals can only be completed after the escrow period
* **Batch transactions must be ordered** -- `verifyWithdrawalCredentials` and `verifyCheckpointProofs` return arrays that must be submitted sequentially
* All signing operations are performed locally -- keys are never transmitted over the network
* Private keys can be provided in hexadecimal format with or without the '0x' prefix