StakeWise

https://docs.stakewise.io
Admin
StakeWise is a liquid staking protocol that enables users to stake ETH and GNO while maintaining...
Tokens:160,929
Snippets:1,184
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start Operator Service (Binary)

Source: https://docs.stakewise.io/operator/start-operator

Use this command to start the Operator Service when installed as a binary. Ensure you replace the placeholder addresses with your actual Vault and node endpoints.

```bash
./operator start \
  --vault=0x834F27bC8670491b75af512d943f01D5383F87Cf \
  --consensus-endpoints=https://consensus-node \
  --execution-endpoints=https://execution-node
```

--------------------------------

### Run Operator Service Command

Source: https://docs.stakewise.io/operator/launch-operator-service

Example format for running Operator Service commands after installation.

```bash
./operator COMMAND --flagA=123 --flagB=xyz
```

--------------------------------

### Install Reth and Lighthouse Binaries

Source: https://docs.stakewise.io/operator/manage-validators/automated-node-setup

Use `node-install` to download and install the Reth and Lighthouse binaries. Specify the network using the `--network` flag. The `--data-dir`, `--lighthouse-version`, and `--reth-version` flags can be used to customize the installation path and client versions.

```bash
./operator node-install --network=mainnet
```

--------------------------------

### Operator Service Example Output

Source: https://docs.stakewise.io/operator/meta-vault/operate-meta-vault

This is an example of the output you can expect when the Operator Service runs the `process-meta-vaults` command. It shows the service starting, processing vaults, and updating their states.

```text
Starting operator service, version v4.1.7  

Started meta vault processing  

Fetching meta vaults  

Processing meta vault: 0x15639E82d2072Fa510E5d2b5F0db361c823bCad3  

Getting state update calls for meta vault 0x15639E82d2072Fa510E5d2b5F0db361c823bCad3  

Sub vault 0xba447498DC4c169f2b4f427B2c4D532320457E89 is not harvestable, skipping  

No sub vault exit requests to claim for meta vault 0x15639E82d2072Fa510E5d2b5F0db361c823bCad3  

Meta vault 0x15639E82d2072Fa510E5d2b5F0db361c823bCad3 state is up-to-date, no updates needed  
```

--------------------------------

### Start Operator Service (Docker)

Source: https://docs.stakewise.io/operator/start-operator

This command is used to start the Operator Service when running via Docker. It includes mounting the keystore directory and specifying the data directory. Ensure the image tag (v4.1.11) matches your installation.

```bash
docker run --restart on-failure:10 \
-u $(id -u):$(id -g) \
-v ~/.stakewise/:/data \
europe-west4-docker.pkg.dev/stakewiselabs/public/v3-operator:v4.1.11 \
src/main.py start \
--vault=0x834F27bC8670491b75af512d943f01D5383F87Cf \
--data-dir=/data \
--consensus-endpoints=http://localhost:5052 \
--execution-endpoints=http://localhost:8545
```

--------------------------------

### Start Operator Service (Source Files)

Source: https://docs.stakewise.io/operator/start-operator

Run the Operator Service from source files using Poetry. This command assumes you have Poetry installed and configured for the project.

```bash
PYTHONPATH=. poetry run python src/main.py start \
--vault=0x834F27bC8670491b75af512d943f01D5383F87Cf \
--consensus-endpoints=http://localhost:5052 \
--execution-endpoints=http://localhost:8545
```

--------------------------------

### Get Leverage Strategy Proxy SDK Example

Source: https://docs.stakewise.io/sdk/api/boost/requests/getleveragestrategyproxy

Call the SDK to fetch the leverage strategy proxy address. Ensure you provide valid user and vault addresses.

```javascript
const strategyProxy = await sdk.boost.getLeverageStrategyProxy({
  userAddress: '0x...',
  vaultAddress: '0x...',
})
```

--------------------------------

### Start SSV Node with Docker

Source: https://docs.stakewise.io/operator/alternative-key-management/dvt/ssv-setup

Run this Docker command in the same folder as your `config.yaml` to start the SSV node. It maps ports, mounts configuration and key files, and starts the node. Use `-d` for background execution. Do not run multiple instances with the same operator keys.

```bash
docker run --restart unless-stopped --name ssv_node -e \
CONFIG_PATH=/config.yaml -p 13001:13001 -p 12001:12001/udp -p 15000:15000 -p 16000:16000 \
-v "$(pwd)/config.yaml":/config.yaml \
-v "$(pwd)":/data \
-v "$(pwd)/password":/password \
-v "$(pwd)/encrypted_private_key.json":/encrypted_private_key.json \
-it "ssvlabs/ssv-node:latest" make BUILD_PATH="/go/bin/ssvnode" start-node  

```

--------------------------------

### Install Operator Service (Latest Release)

Source: https://docs.stakewise.io/operator/launch-operator-service

Installs the latest version of the Operator Service binary to `~/bin`. Ensure `~/bin` is in your PATH.

```bash
curl -sSfL https://raw.githubusercontent.com/stakewise/v3-operator/master/scripts/install.sh | sh -s
```

--------------------------------

### Install StakeWise SDK

Source: https://docs.stakewise.io/sdk/installation-setup

Install the StakeWise v3 SDK using npm or yarn. This is the first step for integrating the SDK into your project.

```bash
npm install @stakewise/v3-sdk
```

```bash
yarn add @stakewise/v3-sdk
```

--------------------------------

### `node-install`

Source: https://docs.stakewise.io/operator/manage-validators/automated-node-setup

Installs Reth and Lighthouse binaries to the data directory.

```APIDOC
## `node-install`

Installs Reth and Lighthouse binaries to the data directory.

### Command
```bash
./operator node-install --network=mainnet
```

### Parameters
#### Query Parameters
- `--network` (string) - Required - Network for your vault: `mainnet`, `hoodi`, or `gnosis`
- `--data-dir` (string) - Optional - Path where node data will be placed. Default: `~/.stakewise`
- `--lighthouse-version` (string) - Optional - Lighthouse version to install. Default: `v8.0.0`
- `--reth-version` (string) - Optional - Reth version to install. Default: `v1.8.2`
```

--------------------------------

### `node-start`

Source: https://docs.stakewise.io/operator/manage-validators/automated-node-setup

Starts the node services and begins syncing.

```APIDOC
## `node-start`

To start the node services and begin syncing:

### Command
```bash
./operator node-start \
  --vault=0x834F27bC8670491b75af512d943f01D5383F87Cf
```

### Parameters
#### Query Parameters
- `--vault` (string) - Required - Your Vault contract address
- `--data-dir` (string) - Optional - Path where node data will be placed. Default: `~/.stakewise`
- `--print-execution-logs` (boolean) - Optional - Print execution node logs
- `--print-consensus-logs` (boolean) - Optional - Print consensus node logs
- `--print-validator-logs` (boolean) - Optional - Print validator node logs
- `--no-confirm` (boolean) - Optional - Skip confirmation messages

**Note:** Instead of running `node-start` separately, you can add the `--run-nodes` flag to the `start` command to start nodes automatically alongside the Operator Service.
```

--------------------------------

### StakeWise V3 SDK Usage Example

Source: https://docs.stakewise.io/sdk/endpoints

Example of how to initialize the StakeWise SDK and retrieve statistics. The SDK automatically handles subgraph URL configuration based on the network.

```APIDOC
## StakeWise V3 SDK Usage Example

### Description
This example demonstrates initializing the StakeWise SDK with a specific network and RPC endpoint, and then calling a method to retrieve statistics. The SDK abstracts away the direct handling of subgraph URLs for common read operations.

### Method
```javascript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: { web3: 'https://main-rpc.io' },
})

const stats = await sdk.utils.getStakewiseStats()
```

### Usage Notes
- The `network` parameter specifies the blockchain network (e.g., `Network.Mainnet`).
- The `endpoints.web3` parameter is for the RPC endpoint.
- Read methods like `getStakewiseStats` automatically use the correct subgraph URL for the configured network.
```

--------------------------------

### Start Node Services and Begin Syncing

Source: https://docs.stakewise.io/operator/manage-validators/automated-node-setup

Initiate node services and start the syncing process with the `node-start` command. Provide your Vault contract address using the `--vault` flag. Optional flags include `--data-dir`, `--print-execution-logs`, `--print-consensus-logs`, `--print-validator-logs`, and `--no-confirm` for customization and log verbosity.

```bash
./operator node-start \
  --vault=0x834F27bC8670491b75af512d943f01D5383F87Cf
```

--------------------------------

### Example Vault URL Structure

Source: https://docs.stakewise.io/operator/create-regular-vault

This is an example of how your Vault's URL will appear after creation, with the Vault address highlighted.

```text
https://stakewise.io/vault/mainnet/0x1234567890abcdef...
                                   ^^^^^^^^^^^^^^^^^^^
                                    Your Vault Address  
```

--------------------------------

### Get Stake Balance SDK Example

Source: https://docs.stakewise.io/sdk/api/vault/requests/getstakebalance

Call the `getStakeBalance` function with the user's address and the vault's address to retrieve balance information.

```javascript
await sdk.vault.getStakeBalance({
  userAddress: '0x...',
  vaultAddress: '0x...',
})
```

--------------------------------

### Get Balance SDK Example

Source: https://docs.stakewise.io/sdk/api/osToken/requests/getbalance

Call the getBalance method on the osToken SDK object, providing the user's address and the vault's address to retrieve the token balances.

```javascript
await sdk.osToken.getBalance({
  userAddress: '0x...',
  vaultAddress: '0x...',
})
```

--------------------------------

### Example Output of Node Status

Source: https://docs.stakewise.io/operator/manage-validators/automated-node-setup

This is an example of the output you can expect when running the `node-status` command, showing sync progress and validator activity for both consensus and execution nodes.

```text
Consensus node status:  
  Is syncing: True  
  Head slot: 1914271  
  Sync distance: 15562  
  Estimated time to sync: 1h 26m 12s  
Execution node status:  
  Is syncing: True  
  Block number: 1769633  
  Sync distance: 27305  
  Estimated time to sync: 9h 20m 38s  
Validator activity:  
  Active validators: 0  
  Total validators: 10  
```

--------------------------------

### Clone and Install Operator Service

Source: https://docs.stakewise.io/operator/launch-operator-service

Clone the v3-operator repository and install main dependencies using Poetry. Ensure you have Python 3.12+, Poetry, Git, Cargo, and libpq-dev installed.

```bash
git clone https://github.com/stakewise/v3-operator.git  

cd v3-operator  

poetry install --only main  
```

--------------------------------

### Install Specific Operator Service Version

Source: https://docs.stakewise.io/operator/launch-operator-service

Installs a specific version of the Operator Service to a custom path using the install script.

```bash
curl -sSfL https://raw.githubusercontent.com/stakewise/v3-operator/master/scripts/install.sh | sh -s -- -b <path> <version>
```

--------------------------------

### Get Sub Vaults Example

Source: https://docs.stakewise.io/sdk/api/vault/requests/getsubvaults

Call the getSubVaults function with the desired skip, limit, and meta vault address to retrieve a list of sub vaults.

```javascript
await sdk.vault.getSubVaults({
  skip: 0,
  limit: 20,
  vaultAddress: '0x...'
})
```

--------------------------------

### Start Operator Service with Remote Signer

Source: https://docs.stakewise.io/operator/alternative-key-management/remote-signer

Start the operator service in remote signer mode by providing the remote signer URL via the `--remote-signer-url` flag. Ensure to also specify vault, consensus, and execution endpoints.

```bash
./operator start-remote-signer \
  --vault=0x834F27bC8670491b75af512d943f01D5383F87Cf \
  --consensus-endpoints=https://consensus-node \
  --execution-endpoints=https://execution-node \
  --remote-signer-url=https://remote-signer:9000

```

--------------------------------

### Start Operator Service in Relayer Mode

Source: https://docs.stakewise.io/operator/alternative-key-management/api-mode

Use this command to start the Operator Service in API mode, enabling it to communicate with a Relayer. Parameters can be provided directly or via environment variables.

```bash
./operator start-relayer
```

--------------------------------

### Create Environment Configuration File

Source: https://docs.stakewise.io/operator/alternative-key-management/dvt/obol-setup

Set up the .env file with essential Charon settings including vault contract address, fee recipient, and network name. Ensure addresses are in lowercase.

```bash
cat <<EOF > .env  

export VAULT_CONTRACT_ADDR=[ENTER YOUR VAULT CONTRACT ADDRESS HERE]  

export FEE_RECIPIENT_ADDR=[ENTER YOUR BLOCK REWARD RECIPIENT ADDRESS HERE]  

export NETWORK=[ENTER YOUR NETWORK NAME]  

EOF  
```

--------------------------------

### Get Periodic Distributions

Source: https://docs.stakewise.io/sdk/api/vault/requests/getperiodicdistributions

Call this function to retrieve the periodic distribution of additional incentives for a vault. Ensure you provide the vault's address, and the start and end timestamps for the desired period.

```javascript
await sdk.vault.getPeriodicDistributions({
  userAddress: '0x...',
  endTimestamp: 1741346116,
  startTimestamp: 1741346116,
})
```

--------------------------------

### Get User Rewards

Source: https://docs.stakewise.io/sdk/api/vault/requests/getuserrewards

Fetches daily rewards for a user within a specified date range for a given vault. Ensure you provide valid user and vault addresses, along with the start and end dates in milliseconds.

```javascript
await sdk.vault.getUserRewards({
  userAddress: '0x...',
  vaultAddress: '0x...',
  dateTo: 1727827200000,
  dateFrom: 1721606400000,
})
```

--------------------------------

### Get Latest Round Data

Source: https://docs.stakewise.io/contracts/api/tokens/PriceFeed

Retrieves comprehensive data from the latest price feed round, including round ID, answer, start time, update time, and answered in round. This function is external and view.

```solidity
function latestRoundData()  
    external  
    view  
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

```

--------------------------------

### Get Queue Position SDK Example

Source: https://docs.stakewise.io/sdk/api/boost/requests/getqueueposition

Call the `getQueuePosition` function with the user's address and the vault's address to retrieve their exit queue status and details. This is useful for displaying a user's current position and estimated exit details.

```javascript
await sdk.boost.getQueuePosition({
  userAddress: '0x...',
  vaultAddress: '0x...',
})
```

--------------------------------

### Initialize SDK and Get Boost Data Type

Source: https://docs.stakewise.io/sdk/sdk-reference

Demonstrates how to initialize the SDK and retrieve the type for the `boost.getData` method using two different approaches.

```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'
  
const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: { web3: 'https://main-rpc.io' },
})
  
// First approach
type BoostData = Awaited<ReturnType<typeof sdk.boost.getData>>
  
// Second approach
type BoostData = Awaited<ReturnType<StakeWise.Services.BoostService['getData']>>
```

--------------------------------

### Fetch Blocklist for a Vault

Source: https://docs.stakewise.io/sdk/api/vault/requests/getblocklist

This example demonstrates how to fetch the blocklist for a given vault address. Ensure you have the SDK initialized and the vault address is correctly provided.

```javascript
await sdk.vault.getBlocklist({
  vaultAddress: '0x...',
})
```

--------------------------------

### Example Meta Vault URL

Source: https://docs.stakewise.io/operator/meta-vault/create-meta-vault

This is an example of a Meta Vault URL, where the vault address is located at the end of the URL.

```url
https://stakewise.io/vault/mainnet/0x1234567890abcdef...
```

--------------------------------

### SDK Initialization and Type Hinting for Boost Data

Source: https://docs.stakewise.io/sdk/sdk-reference

Demonstrates how to initialize the Stakewise SDK and use TypeScript to infer the return type of the `sdk.boost.getData` method using two different approaches.

```APIDOC
## SDK Initialization and Type Hinting for Boost Data

This example shows how to initialize the SDK and get the return type of the `sdk.boost.getData` method.

### Method
```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: { web3: 'https://main-rpc.io' },
})

// First approach
type BoostData = Awaited<ReturnType<typeof sdk.boost.getData>>

// Second approach
type BoostData = Awaited<ReturnType<StakeWise.Services.BoostService['getData']>>
```
```

--------------------------------

### Initialize SDK with Network and RPC Endpoint

Source: https://docs.stakewise.io/sdk

Instantiate the SDK specifying the target network and a single web3 RPC endpoint. SDK instances are immutable per network.

```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: { web3: 'https://main-rpc.io' },
})
```

--------------------------------

### Start Operator Service with HashiCorp Vault

Source: https://docs.stakewise.io/operator/alternative-key-management/hashicorp-vault

Use the `start-hashi-vault` command with specific flags to enable loading validator signing keys directly from a remote HashiCorp Vault instance. Multiple `--hashi-vault-key-path` flags can be used to specify different storage locations.

```bash
./operator start-hashi-vault \
  --network=mainnet \
  --vault=0x834F27bC8670491b75af512d943f01D5383F87Cf \
  --consensus-endpoints=https://consensus-node \
  --execution-endpoints=https://execution-node \
  --hashi-vault-key-path=keystores1 \
  --hashi-vault-key-path=keystores2 \
  --hashi-vault-token=hvs.abcde \
  --hashi-vault-url=https://hashi-vault:8200
```

--------------------------------

### Get User APY - JavaScript

Source: https://docs.stakewise.io/sdk/api/vault/requests/getuserapy

Call this function with the user's and vault's addresses to get the current APY. Ensure you have the SDK initialized.

```javascript
await sdk.vault.getUserApy({
  userAddress: '0x...',
  vaultAddress: '0x...'
})
```

--------------------------------

### Create SDK Instance (Read/Write with Provider)

Source: https://docs.stakewise.io/sdk/installation-setup

Initialize the StakeWiseSDK with an ethers BrowserProvider for full read and write capabilities. This is ideal for browser-based wallet integrations like MetaMask or WalletConnect, allowing direct transaction execution.

```typescript
import { BrowserProvider } from 'ethers'
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const eip1193Provider = window.ethereum

const browserProvider = new BrowserProvider(eip1193Provider, {
  chainId: Network.Mainnet,
  name: 'mainnet',
})

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  provider: browserProvider,
})

```

--------------------------------

### Setup Remote Signer with Operator CLI

Source: https://docs.stakewise.io/operator/alternative-key-management/remote-signer

Use the `setup-remote-signer` command to upload keystores to a remote signer and configure the operator. This process prompts for vault address and remote signer URL, and offers to remove local keystores.

```bash
./operator setup-remote-signer

```

--------------------------------

### Get Vault Factory with ERC20 Token

Source: https://docs.stakewise.io/sdk/api/vault/requests/getvaultfactory

Use this function to get the vault factory for creating vaults, specifying an ERC20 token. Requires importing VaultType.

```typescript
import { VaultType } from '@stakewise/v3-sdk'  

await sdk.vault.getVaultFactory({
  vaultType: VaultType.Default,
  isErc20: true,
})
```

--------------------------------

### SDK Initialization

Source: https://docs.stakewise.io/sdk

Initialize the StakeWiseSDK with the desired network and RPC endpoints. You can provide a single RPC URL, an array of URLs for fallback, or an array of objects for custom headers.

```APIDOC
## Initialization

### Description
Initialize the StakeWiseSDK with the desired network and RPC endpoints. You can provide a single RPC URL, an array of URLs for fallback, or an array of objects for custom headers.

### Usage
```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const sdk = new StakeWiseSDK({
  network: Network.Mainnet, // Or other Network enum values
  endpoints: {
    web3: 'https://main-rpc.io' // Single RPC URL
    // OR
    // web3: [
    //   'https://main-rpc.io',
    //   'https://fallback-rpc.io' // Array of RPC URLs for fallback
    // ]
    // OR
    // web3: [
    //   { url: 'https://authenticated-rpc.io', headers: { 'Authorization': 'Bearer YOUR_API_KEY' } } // Object with custom headers
    // ]
  }
})
```

### Notes
- SDK instances are immutable per network. To switch networks, construct a new instance.
- Providing your own RPC endpoints is strongly recommended for reliability and rate limiting.
```

--------------------------------

### Initialize Operator Service Wallet

Source: https://docs.stakewise.io/operator/meta-vault/operate-meta-vault

Use this command to initialize a mnemonic for a new wallet. This is the first step when creating a new wallet for the Operator Service.

```bash
./operator init
```

--------------------------------

### Example Prometheus Metric Output

Source: https://docs.stakewise.io/operator/operator-monitoring

This is an example of a Prometheus metric exposed by the Operator Service. Metrics are prefixed with the configured namespace (default 'sw_operator_') and include a 'network' label.

```text
# TYPE sw_operator_slot_number gauge  
sw_operator_slot_number{network="hoodi"} 2.74352e+06  
```

--------------------------------

### Operator Service Help Command

Source: https://docs.stakewise.io/operator/alternative-key-management/api-mode

Access help information for the 'start-relayer' command to see all available parameters and options.

```bash
./operator start-relayer --help
```

--------------------------------

### Unboost OS Token with StakeWise SDK

Source: https://docs.stakewise.io/sdk/quick-start/unboost-os-token

Use this function to initiate the unboost process for a leveraged position. It checks for existing boosts, available balance, and existing unboost queues before proceeding. Ensure you have the necessary user and vault addresses.

```typescript
import { BrowserProvider, parseEther } from 'ethers'  

import { StakeWiseSDK, Network, OsTokenPositionHealth } from '@stakewise/v3-sdk'  

  

const eip1193Provider = window.ethereum  

  

const browserProvider = new BrowserProvider(eip1193Provider, {  

  chainId: Network.Mainnet,  

  name: 'mainnet',  

})  

  

const sdk = new StakeWiseSDK({  

  network: Network.Mainnet,  

  provider: browserProvider,  

})  

  

type Input = {  

  percent: number  

  userAddress: string  

  vaultAddress: string  

}  

  

type PermitParams = Parameters<typeof sdk.boost.lock>[0]['permitParams']  

  

const unboost = async (values: Input) => {  

  const { percent, userAddress, vaultAddress } = values  

  

  try {  

    const boost = await sdk.boost.getData({ userAddress, vaultAddress })  

  

    if (!boost.shares) {  

      throw new Error('You don\'t have a boost.')  

    }  

  

    if (percent > 100) {  

      throw new Error('Insufficient boost balance')  

    }  

  

    if (boost.exitingPercent) {  

      throw new Error(`  

        You already have a position in the queue for an unboost,  

        you must claim tokens before creating a new position for exit.  

      `)  

    }  

  

    const hash = await sdk.boost.unlock({  

      percent,  

      userAddress,  

      vaultAddress,  

    })  

  

    await sdk.provider.waitForTransaction(hash)  

  

    await sdk.utils.waitForSubgraph({ hash })  

  

    const unboostQueue = await sdk.boost.getQueuePosition({ userAddress, vaultAddress })  

  

    // After you have unboosted, your funds are placed in the withdrawal queue.  

    console.log('unboostQueue:', unboostQueue)  

  }  

  catch (error) {  

    console.error(error)  

  }  

}  

  
unboost({  

  percent: 50,  

  userAddress: 'USER_ADDRESS',  

  vaultAddress: 'VAULT_ADDRESS',  

})
```

--------------------------------

### Get Max Withdraw Amount

Source: https://docs.stakewise.io/sdk/api/vault/requests/getmaxwithdrawamount

Call this method to get the maximum amount a user can withdraw. Provide the vault address and the user's address as arguments. The returned value is a bigint representing the maximum withdrawable amount.

```javascript
await sdk.vault.getMaxWithdrawAmount({

  vaultAddress: '0x...',

  userAddress: '0x...',

})
```

--------------------------------

### Initialize SDK with Multiple Fallback RPC Endpoints

Source: https://docs.stakewise.io/sdk

Configure the SDK with a list of RPC endpoints for the web3 provider, enabling fallback mechanisms. This enhances reliability and rate limiting.

```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: {
    web3: [
      "https://main-rpc.io",
      "https://fallback-rpc.io",
    ]
  }
})
```

--------------------------------

### Direct Integration with Binance Wallet

Source: https://docs.stakewise.io/sdk/connecting

Integrates the SDK with the Binance wallet using its specific provider library. Requires enabling the provider and configuring RPC details.

```typescript
import { BrowserProvider } from 'ethers'
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'
import { getProvider } from '@binance/w3w-ethereum-provider'

const getBinanceProvider = async () => {
  const provider = getProvider({
    showQrCodeModal: true,
    lng: 'en-US',
    chainId: 1,
    rpc: {
      1: 'https://mainnet.infura.io/v3/...',
    },
  })

  await provider.enable()

  return provider
}

const eip1193Provider = await getBinanceProvider()

const browserProvider = new BrowserProvider(eip1193Provider, {
  chainId: Network.Mainnet,
  name: 'mainnet',
})

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  provider: browserProvider,
})
```

--------------------------------

### Encode and Estimate Unlock Transaction

Source: https://docs.stakewise.io/sdk/api/boost/transactions/unlock

When signing transactions on the backend for custodians, use `unlock.encode` to get transaction data. `upgradeLeverageStrategyTxData` is returned if a leverage strategy contract upgrade is needed. Use `unlock.estimateGas` to get an approximate gas cost for the transaction.

```javascript
// When you sign transactions on the backend (for custodians)
// `lockTxData` will always be returned, while `upgradeLeverageStrategyTxData` will be returned if the leverage strategy contract upgrade is required
const { lockTxData, upgradeLeverageStrategyTxData } = await sdk.boost.unlock.encode(params)
// Get an approximate gas per transaction
const gas = await sdk.boost.unlock.estimateGas(params)
```

--------------------------------

### Direct Integration with WalletConnect v2

Source: https://docs.stakewise.io/sdk/connecting

Integrates the SDK with wallets using WalletConnect v2. Requires initializing the EthereumProvider with project ID and RPC mapping.

```typescript
import { BrowserProvider } from 'ethers'
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'
import { EthereumProvider } from '@walletconnect/ethereum-provider'

const getWalletConnectProvider = async () => {
  const provider = await EthereumProvider.init({
    projectId: 'WALLET_CONNECT_ID' // from account (https://walletconnect.com/)
    disableProviderPing: true,
    isNewChainsStale: true,
    optionalChains: [ 1 ],
    showQrModal: true,
    rpcMap: {
      1: 'https://mainnet.infura.io/v3/...',
    }
  })

  return provider
}

const eip1193Provider = await getWalletConnectProvider()

const browserProvider = new BrowserProvider(eip1193Provider, {
  chainId: Network.Mainnet,
  name: 'mainnet',
})

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  provider: browserProvider,
})
```

--------------------------------

### Create ERC20 Contract Instance and Get Total Supply

Source: https://docs.stakewise.io/sdk/sdk-reference

Shows how to create an ERC20 contract instance for a given token address using SDK helpers and retrieve its total supply.

```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'
  
const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: { web3: 'https://main-rpc.io' },
})
  
const osTokenAddress = sdk.config.addresses.tokens.mintToken
const osToken = sdk.contracts.helpers.createErc20(osTokenAddress)
  
const totalSupply = await osToken.totalSupply()
```

--------------------------------

### getClaimAmount

Source: https://docs.stakewise.io/sdk/api/rewardSplitter/requests/getclaimamount

Calculates the amount of assets that the user can claim from the reward splitter. The method response is divided into 2 parts, in “active” you get data on the current reward splitter, in “inactive” you get data on the ones you used before.

```APIDOC
## getClaimAmount

### Description
Calculates the amount of assets that the user can claim from the reward splitter. The method response is divided into 2 parts, in “active” you get data on the current reward splitter, in “inactive” you get data on the ones you used before.

### Arguments
#### Path Parameters
- **userAddress** (string) - Required - The address of the user making the request
- **vaultAddress** (string) - Required - The address of the vault
- **rewardSplitterAddress** (string) - Required - The address of the reward splitter

### Returns
#### Success Response
- **active** (Item) - Data on the current reward splitter.
- **inactive** (Array<Item>) - Data on previously used reward splitters.

```json
type Item = {
  assets: bigint
  address: string
}

type Output = {
  active: Item
  inactive: Array<Item>
}
```

### Request Example
```javascript
const claimAmount = await sdk.rewardSplitter.getClaimAmount({
  vaultAddress: '0x...',
  userAddress: '0x...',
  rewardSplitterAddress: '0x...',
})
```
```

--------------------------------

### Consolidate Validators Using a File

Source: https://docs.stakewise.io/operator/manage-validators/consolidate-validators

For managing multiple validators, provide a file containing public keys (one per line) using `--source-public-keys-file`. Both 0x-prefixed and non-prefixed forms of public keys are accepted.

```bash
./operator consolidate \
  --vault=0x000... \
  --source-public-keys-file=public_keys.txt \
  --target-public-key=0x003
```

--------------------------------

### GnoErc20Vault Initialization Parameters

Source: https://docs.stakewise.io/contracts/api/vaults/gnosis/GnoErc20Vault

Struct for initializing the GnoErc20Vault contract with capacity, fee, name, symbol, and metadata.

```APIDOC
## Struct: GnoErc20VaultInitParams

### Description
Struct for initializing the GnoErc20Vault contract.

### Properties
- **capacity** (uint256) - The Vault stops accepting deposits after exceeding the capacity
- **feePercent** (uint16) - The fee percent that is charged by the Vault
- **name** (string) - The name of the ERC20 token
- **symbol** (string) - The symbol of the ERC20 token
- **metadataIpfsHash** (string) - The IPFS hash of the Vault's metadata file
```

--------------------------------

### Get All Sub-Vaults

Source: https://docs.stakewise.io/contracts/api/vaults/modules/VaultSubVaults

Retrieves a list of all registered sub-vault addresses.

```APIDOC
## getSubVaults

### Description
Function to get the list sub-vaults

### Method
PUBLIC VIEW

### Returns
- **address[]**: An array of addresses of the sub-vaults
```

--------------------------------

### Geth Execution Client Configuration

Source: https://docs.stakewise.io/operator/alternative-key-management/dvt/obol-setup

Sets up the Geth execution client, specifying the Docker image, restart policy, and command-line arguments for mainnet sync, data directory, RPC endpoints, and network ports. It also configures volume mounts for persistent data.

```yaml
geth:
  image: ethereum/client-go:v1.16.7
  restart: always
  command: >
    --mainnet
    --syncmode=snap
    --datadir=/data
    --db.engine=pebble
    --authrpc.jwtsecret=/data/jwtsecret --authrpc.addr=0.0.0.0 --authrpc.port=8551 --authrpc.vhosts=*
    --http --http.addr=0.0.0.0 --http.port=8445 --http.corsdomain=* --http.vhosts=*
    --port=30303
    --ipcdisable
  volumes: ["./data/geth:/data"]
  ports:
    - 30303:30303/tcp
    - 30303:30303/udp
  networks: [ cluster ]
```

--------------------------------

### Get Authenticator Address

Source: https://docs.stakewise.io/contracts/api/tokens/OsTokenVaultEscrow

Retrieves the address of the authenticator contract.

```solidity
function authenticator() external view returns (address);
```

--------------------------------

### Get Sub-Vaults Curator

Source: https://docs.stakewise.io/contracts/api/vaults/modules/VaultSubVaults

Retrieves the address of the contract designated as the sub-vaults curator.

```APIDOC
## subVaultsCurator

### Description
Sub-vaults curator contract

### Method
EXTERNAL VIEW

### Returns
- **address**: The address of the Sub-vaults curator contract
```

--------------------------------

### Initialize StakeWise SDK with Network and RPC Endpoint

Source: https://docs.stakewise.io/sdk/endpoints

Initialize the StakeWise SDK by providing the network and a custom RPC endpoint. The SDK automatically uses baked-in subgraph URLs for read methods.

```typescript
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'

const sdk = new StakeWiseSDK({
  network: Network.Mainnet,
  endpoints: { web3: 'https://main-rpc.io' },
})

const stats = await sdk.utils.getStakewiseStats()
```

--------------------------------

### Get Vault Implementation Version

Source: https://docs.stakewise.io/contracts/api/vaults/gnosis/GnoBlocklistVault

Returns the version of the Vault implementation contract.

```solidity
function version() public pure virtual override(IVaultVersion, GnoVault) returns (uint8);
```

--------------------------------

### Configure MEV-Boost with Multiple Relays

Source: https://docs.stakewise.io/operator/smoothing-pool-relays

Use the `-relays` flag with a comma-separated list of relay URLs to connect MEV-Boost to multiple relays. Alternatively, use the `-relay` flag multiple times for individual relays.

```bash
mev-boost -relays https://relay1,https://relay2
```

--------------------------------

### Get Vault Unique Identifier

Source: https://docs.stakewise.io/contracts/api/vaults/gnosis/GnoBlocklistVault

Returns the unique identifier for this Vault instance.

```solidity
function vaultId() public pure virtual override(IVaultVersion, GnoVault) returns (bytes32);
```

--------------------------------

### Get Ejecting Sub-Vault

Source: https://docs.stakewise.io/contracts/api/vaults/modules/VaultSubVaults

Retrieves the address of the sub-vault currently undergoing the ejection process.

```APIDOC
## ejectingSubVault

### Description
Ejecting sub-vault

### Method
EXTERNAL VIEW

### Returns
- **address**: The address of the ejecting sub-vault
```

--------------------------------

### Get Vault Version

Source: https://docs.stakewise.io/contracts/api/vaults/ethereum/custom/EthFoxVault

Returns the implementation version of the Vault contract. This is a pure function.

```solidity
function version() public pure virtual override(IVaultVersion, VaultVersion) returns (uint8);
```

--------------------------------

### Generate Validator Keys with Operator Service

Source: https://docs.stakewise.io/operator/validator-keys

Generate validator keystores from your mnemonic using the `create-keys` command. By default, a single `password.txt` file is created for all keystores. Use the `--per-keystore-password` flag to generate individual password files for each keystore. Protect password files as carefully as keystores.

```bash
./operator create-keys
```

--------------------------------

### Set Existing Wallet Private Key

Source: https://docs.stakewise.io/operator/meta-vault/operate-meta-vault

If you are using an existing wallet, export its private key and set it as an environment variable. This bypasses the need to create a new wallet.

```bash
export WALLET_PRIVATE_KEY="0xyour_private_key_here"
```

--------------------------------

### Get Swapped Assets

Source: https://docs.stakewise.io/contracts/api/tokens/OsTokenRedeemer

Retrieves the total amount of assets that have been swapped. This is a view function.

```solidity
function swappedAssets() external view returns (uint128);
```

--------------------------------

### Get Redeemed Assets

Source: https://docs.stakewise.io/contracts/api/tokens/OsTokenRedeemer

Retrieves the total quantity of assets that have been redeemed. This is a view function.

```solidity
function redeemedAssets() external view returns (uint128);
```

--------------------------------

### Create SDK Instance with Wagmi Connector

Source: https://docs.stakewise.io/sdk/installation-setup

Initialize the StakeWiseSDK using an existing wagmi connector. This approach is useful when integrating with wagmi for wallet management in React applications, providing both read and write access.

```typescript
import React, { useCallback } from 'react'
import { BrowserProvider, Eip1193Provider } from 'ethers'
import { StakeWiseSDK, Network } from '@stakewise/v3-sdk'
import { useAccount } from 'wagmi'

const useStakeWiseSDK = async () => {
  const { address, connector } = useAccount()
  
  const createSDK = useCallback(async () => {
    if (!address || typeof connector?.getProvider !== 'function') {
      return new StakeWiseSDK({ network: Network.Mainnet })
    }
  
    const library = await connector.getProvider() as Eip1193Provider
  
    return new StakeWiseSDK({
      network: Network.Mainnet,
      provider: new BrowserProvider(library, {
        chainId: Network.Mainnet,
        name: 'mainnet',
      }),
    })
  }, [])
  
  return createSDK

}

```

--------------------------------

### Get PriceFeed Version

Source: https://docs.stakewise.io/contracts/api/tokens/PriceFeed

Retrieves the version number of the PriceFeed aggregator. This is a constant value.

```solidity
uint256 public constant override version = 0  

```

--------------------------------

### EthFoxVaultInitParams Struct

Source: https://docs.stakewise.io/contracts/api/vaults/ethereum/custom/EthFoxVault

Defines the parameters for initializing an EthFoxVault contract. This includes setting the admin, MEV escrow, capacity, fee percentage, and metadata IPFS hash.

```solidity
struct EthFoxVaultInitParams {
    address admin;
    address ownMevEscrow;
    uint256 capacity;
    uint16 feePercent;
    string metadataIpfsHash;
}
```

--------------------------------

### Get Distributor Rewards

Source: https://docs.stakewise.io/sdk/api/distributorRewards/requests/getrewards

Retrieves the set of distributor rewards tokens that are currently claimable by a user.

```APIDOC
## getRewards

### Description
Returns the set of distributor rewards tokens that are currently claimable.

### Arguments
#### Query Parameters
- **userAddress** (string) - Required - The address of the user making the request

### Returns
#### Success Response (200)
- **proof** (string[]) - The Merkle tree proof. Used in sdk.distributorRewards.claim
- **tokens** (string[]) - An array of addresses of the tokens. Used in sdk.distributorRewards.claim
- **unclaimedAmounts** (string[]) - An array of unclaimed amounts of the tokens. A claim is available if at least one amount in the array is greater than zero.
- **cumulativeAmounts** (string[]) - An array of cumulative amounts of the tokens. Used in sdk.distributorRewards.claim

### Request Example
```javascript
const distributorRewards = await sdk.distributorRewards.getRewards({
  userAddress: '0x...'
});
```

### Response Example
```json
{
  "proof": ["0x...", "0x..."],
  "tokens": ["0x..."],
  "unclaimedAmounts": ["100"],
  "cumulativeAmounts": ["1000"]
}
```
```

--------------------------------

### OsTokenVaultEscrow Event: LiqConfigUpdated

Source: https://docs.stakewise.io/contracts/api/tokens/OsTokenVaultEscrow

Emitted when the liquidation configuration (threshold and bonus percentages) is updated.

```solidity
event LiqConfigUpdated(uint64 liqThresholdPercent, uint256 liqBonusPercent);
```

--------------------------------

### Get Vault Version

Source: https://docs.stakewise.io/contracts/api/vaults/gnosis/GnoBlocklistErc20Vault

Returns the version number of the Vault implementation contract. This is a pure function.

```solidity
function version() public pure virtual override(IVaultVersion, GnoErc20Vault) returns (uint8);
```

--------------------------------

### Withdraw Funds from Vault

Source: https://docs.stakewise.io/sdk/api/vault/transactions/withdraw

This example demonstrates how to withdraw funds from a vault. It includes fetching vault and stake data, calculating maximum withdrawable assets, checking withdrawal restrictions, sending the transaction, and waiting for confirmation. It also shows how to encode parameters and estimate gas for the withdrawal.

```javascript
const amountAssets = 200n // from input mb

const [
  { osTokenConfig: { ltvPercent, liqThresholdPercent } },
  stake,
] = await Promise.all([
  sdk.vault.getVault({
    vaultAddress: '0x...',
  }),
  sdk.vault.getStakeBalance({
    vaultAddress: '0x...',
    userAddress: '0x...',
  }),
])

const osToken = await sdk.osToken.getPosition({
  stakedAssets: stake.assets,
  vaultAddress: '0x...',
  userAddress: '0x...',
  liqThresholdPercent,
})

const maxWithdrawAssets = await sdk.vault.getMaxWithdraw({
  mintedAssets: osToken.minted.assets,
  stakedAssets: stake.assets,
  vaultAddress: '0x...',
  ltvPercent,
})

if (amountAssets > maxWithdrawAssets) {
  // There is a withdrawal restriction if you have an osToken.

  return
}

const params = {
  vaultAddress: '0x...',
  userAddress: '0x...',
  assets: amountAssets,
}

// Send transaction
const hash = await sdk.vault.withdraw(params)

// Wait for the transaction to be confirmed and indexed
await sdk.provider.waitForTransaction(hash)
await sdk.utils.waitForSubgraph({ hash })

// When you sign transactions on the backend (for custodians)
const { data, to } = await sdk.vault.withdraw.encode(params)
// Get an approximate gas per transaction
const gas = await sdk.vault.withdraw.estimateGas(params)
```

--------------------------------

### SSV Keys CLI Input Prompts

Source: https://docs.stakewise.io/operator/alternative-key-management/dvt/ssv-setup

When prompted by the ssv-keys CLI, provide the path to your keystore file(s), the keystore file password, and the desired output directory for the generated keyshares. This process splits your validator key into encrypted shares.

```bash
✔ Enter the path to your keystore file or directory containing multiple keystore files … /Users/user/.stakewise/0x43aee97f4122b4982915bcfd3d6acd0758fd1b52/keystores/keystore-m_12381_3600_0_0_0-1763993024.json
✔ Provide the keystore file password … ******************** <- type keystores password here
✔ Please provide a target path to generate the output to … /Users/user/ssv-keys/

1/1 ✅ keystore-m_12381_3600_0_0_0-1763993024.json

1 of 1 keystore files successfully validated. 0 failed validation

Generating Keyshares file, this might take a few minutes do not close terminal.
Key distribution successful! Find your key shares file at:
/Users/user/ssv-keys/keyshares-1763995534.json
```

--------------------------------

### Get Swapped OsToken Shares

Source: https://docs.stakewise.io/contracts/api/tokens/OsTokenRedeemer

Returns the number of OsToken shares that have been swapped. This is a view function.

```solidity
function swappedShares() external view returns (uint128);
```

--------------------------------

### EthMetaVaultConstructorArgs Struct

Source: https://docs.stakewise.io/contracts/api/vaults/ethereum/custom/EthMetaVault

Defines the arguments required for deploying the EthMetaVault contract. Includes addresses for keeper, registries, and configuration contracts, as well as a delay for claiming assets after exiting.

```solidity
struct EthMetaVaultConstructorArgs {
    address keeper;
    address vaultsRegistry;
    address osTokenVaultController;
    address osTokenConfig;
    address osTokenVaultEscrow;
    address curatorsRegistry;
    uint64 exitingAssetsClaimDelay;
}
```

--------------------------------

### Get PriceFeed Description

Source: https://docs.stakewise.io/contracts/api/tokens/PriceFeed

Returns a string describing the PriceFeed aggregator. This function is external and view.

```solidity
function description() external view returns (string memory);

```

--------------------------------

### GnoErc20Vault Constructor Arguments

Source: https://docs.stakewise.io/contracts/api/vaults/gnosis/GnoErc20Vault

Struct for initializing the GnoErc20Vault contract with various addresses and configuration parameters.

```APIDOC
## Struct: GnoErc20VaultConstructorArgs

### Description
Struct for initializing the GnoErc20Vault contract.

### Properties
- **keeper** (address) - The address of the Keeper contract
- **vaultsRegistry** (address) - The address of the VaultsRegistry contract
- **validatorsRegistry** (address) - The contract address used for registering validators in beacon chain
- **validatorsWithdrawals** (address) - The contract address used for withdrawing validators in beacon chain
- **validatorsConsolidations** (address) - The contract address used for consolidating validators in beacon chain
- **consolidationsChecker** (address) - The contract address used for checking consolidations
- **osTokenVaultController** (address) - The address of the OsTokenVaultController contract
- **osTokenConfig** (address) - The address of the OsTokenConfig contract
- **osTokenVaultEscrow** (address) - The address of the OsTokenVaultEscrow contract
- **sharedMevEscrow** (address) - The address of the shared MEV escrow
- **depositDataRegistry** (address) - The address of the DepositDataRegistry contract
- **gnoToken** (address) - The address of the GNO token
- **tokensConverterFactory** (address) - The address of the TokensConverterFactory contract
- **exitingAssetsClaimDelay** (uint256) - The delay after which the assets can be claimed after exiting from staking
```

--------------------------------

### Get Sub-Vault State

Source: https://docs.stakewise.io/contracts/api/vaults/modules/VaultSubVaults

Retrieves the state of a specific sub-vault, including its staked shares and queued shares.

```APIDOC
## subVaultsStates

### Description
Function to get the state of a sub-vault

### Method
EXTERNAL VIEW

### Parameters
#### Path Parameters
- **vault** (address) - Required - The address of the sub-vault

### Returns
- **SubVaultState**: The state of the sub-vault
```

--------------------------------

### EthVaultConstructorArgs Struct

Source: https://docs.stakewise.io/contracts/api/vaults/ethereum/EthVault

Defines the arguments required for deploying the EthVault contract. These include addresses for various registry, controller, and escrow contracts, as well as a delay for claiming exiting assets.

```solidity
struct EthVaultConstructorArgs {
    address keeper;
    address vaultsRegistry;
    address validatorsRegistry;
    address validatorsWithdrawals;
    address validatorsConsolidations;
    address consolidationsChecker;
    address osTokenVaultController;
    address osTokenConfig;
    address osTokenVaultEscrow;
    address sharedMevEscrow;
    address depositDataRegistry;
    uint64 exitingAssetsClaimDelay;
}
```

--------------------------------

### Get Vault Validators Manager Nonce

Source: https://docs.stakewise.io/contracts/api/vaults/modules/VaultValidators

Returns the nonce used by the validators manager for signing operations.

```solidity
function validatorsManagerNonce() external view returns (uint256);
```

--------------------------------

### Download and Make SSV Keys CLI Executable (Linux)

Source: https://docs.stakewise.io/operator/alternative-key-management/dvt/ssv-setup

Use this command to download the ssv-keys CLI for Linux and make it executable. This tool is used for generating encrypted keyshares offline.

```bash
curl -L https://github.com/ssvlabs/ssv-keys/releases/latest/download/ssv-keys-linux -o ssv-keys
chmod +x ssv-keys
```

--------------------------------

### Get Current Redemption Nonce

Source: https://docs.stakewise.io/contracts/api/tokens/OsTokenRedeemer

Returns the current nonce value used for redemptions. This is a view function.

```solidity
function nonce() external view returns (uint256);
```

--------------------------------

### Get Vault Unique Identifier

Source: https://docs.stakewise.io/contracts/api/vaults/ethereum/EthPrivErc20Vault

Returns the unique identifier for the Vault. This function is overridden from IVaultVersion and EthErc20Vault.

```Solidity
function vaultId() public pure virtual override(IVaultVersion, EthErc20Vault) returns (bytes32);
```
Tokens:
Raw