HypeEVM

Overview

The Hyperliquid blockchain features two key parts: HyperCore and HyperEVM. HyperEVM is not a separate chain, but rather, secured by the same HyperBFT consensus as HyperCore. This lets HyperEVM interact directly with parts of HyperCore, such as spot and perp order books. Hyperliquid is a performant blockchain built with the vision of a fully onchain open financial system. Liquidity, user applications, and trading activity synergize on a unified platform that ultimately houses all of finance.

Explorer

https://hyperevm-explorer.vercel.app/

Wallets Types

BitGo enables holding HypeEVM in the following wallet types:

Ticker Symbols

Faucet

You can use a faucet to obtain free testnet HypeEVM for development and testing purposes.

Faucet: https://app.hyperliquid-testnet.xyz/drip

Units

Each HypeEVM consists of 1,000,000,000,000,000,000 (1018) wei, so not even a single hypeevm can be stored numerically without exceeding the range of JavaScript numbers. Gas fees use gwei.

• 1 hypeevm = 1018 wei
• 1 wei = 10-18 hypeevm
• 1 gwei = 10-9 hypeevm

For that reason, only string balance properties are available, which are balanceString, confirmedBalanceString, and spendableBalanceString.

Tokens

The HypeEVM blockchain natively supports tokens.

Create Wallet

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="thypeevm"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export LABEL="<DESIRED_WALLET_NAME>"
export PASSPHRASE="<YOUR_BITGO_LOGIN_PASSPHRASE>"
export ENTERPRISE_ID="<YOUR_ENTERPRISE_ID>"

curl -X POST \
 http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/generate \
 -H 'Content-Type: application/json' \
 -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "label": "'"$LABEL"'",
    "passphrase": "'"$PASSPHRASE"'",
    "enterprise": "'"$ENTERPRISE_ID"'",
    "walletVersion": 4
}'

bitgo
  .coin('thypeevm')
  .wallets()
  .generateWallet({
    label: 'My Test Wallet',
    passphrase: 'secretpassphrase1a5df8380e0e30',
    enterprise: '5612c2beeecf83610b621b90964448cd',
    walletVersion: 4,
  })
  .then(function (wallet) {
    // print the new wallet
    console.dir(wallet);
  });

Create Address

export WALLET="585c51a5df8380e0e3082e46"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X POST \
-H "Authorization: Bearer $ACCESS_TOKEN" \
https://app.bitgo-test.com/api/v2/thypeevm/wallet/$WALLET/address

bitgo
  .coin('thypeevm')
  .wallets()
  .getWallet({ id: '585c51a5df8380e0e3082e46' })
  .then(function (wallet) {
    return wallet.createAddress();
  })
  .then(function (newAddress) {
    // print new address details
    console.dir(newAddress);
  });

Consolidate Balance

Consolidation Fee Source: HypeEVM Gas Tank HypeEVM uses forwarders, so it does not support manual consolidation

Estimate Fee

export COIN="thypeevm"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X GET \
 https://app.bitgo-test.com/api/v2/$COIN/tx/fee \
 -H 'Content-Type: application/json' \
 -H "Authorization: Bearer $ACCESS_TOKEN"

const BitGoJS = require('../../../src/index.js');
const bitgo = new BitGoJS.BitGo({ env: 'test' });
const accessToken = '<YOUR_ACCESS_TOKEN>';
const coin = 'thypeevm';
async function getFeeEstimate() {
  try {
    await bitgo.authenticateWithAccessToken({ accessToken });
    const res = await bitgo.coin(coin).feeEstimate({ numBlocks: 2 });
    console.dir(res);
  } catch (err) {
    console.error('Error fetching fee estimate:', err);
  }
}
getFeeEstimate();

Transact

Withdrawal Fee Source: Wallet Base Address

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="thypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export ADDRESS="<DESTINATION_ADDRESS>"
export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"

curl -X POST \
 http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/sendcoins \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "address": "'"$ADDRESS"'",
    "amount": "'"$AMOUNT"'",
    "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
}'

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="thypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export ADDRESS_1="<DESTINATION_ADDRESS_1>"
export AMOUNT_1="<AMOUNT_1_IN_BASE_UNITS>"
export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"
curl -X POST \
  http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/sendmany \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "recipients": [
    {
      "address": "'"$ADDRESS_1"'",
      "amount": "'"$AMOUNT_1"'"
    }
  ],
    "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
}'

const tx = await fundedWallet.send({
    address: `<DESTINATION_ADDRESS>`,
    amount: `<AMOUNT>`,
    walletPassphrase: process.env.PASSWORD as string,
  });

let params = {
  recipients: [
    {
      amount: "<AMOUNT_1>",
      address: "<DESTINATION_ADDRESS_1>",
    }
  ],
  walletPassphrase: "<YOUR_WALLET_PASSPHRASE>",
};
wallet.sendMany(params).then(function (transaction) {
  // Print transaction details
  console.dir(transaction);
});

Bridge Funds

HypeEVM bridging moves native balance for a wallet from L1 chain (HyperLiquid) to HypeEvm, and consists of two distinct flows:

1. Enable Bridging (enableBridging) — ensures the wallet has enough native gas to cover bridging costs. Poll until the operation reaches a terminal state, as it runs asynchronously on the server.
2. Bridge transfer (bridgeFunds) — the actual transaction that moves a specified amount out of the wallet through the bridge, once gas is available.

Key Mechanics

• enableBridging is synchronous per call, but the funding it kicks off happens asynchronously on BitGo's side — you must call it repeatedly until it returns a terminal status.
• Terminal statuses: funded (success) and already_funded_insufficient (failure — no more funding available). Non-terminal statuses: funding_initiated and funding_pending — keep polling.
• bridgableBalance is a wallet-scoped endpoint (/api/v2/wallet/{walletId}/bridgableBalance), not coin-scoped like most other wallet routes.
• bridgeFunds requires the TSS wallet-version prerequisite noted above.

Enable Bridging (Wallet Funding)

Call enableBridging to check if the wallet's native balance is sufficient for gas and, if needed, trigger BitGo's auto-funding flow to fund it. No request body is required. This is a read/funding-check operation and doesn't require wallet-passphrase signing, so it can be called directly against the BitGo API or proxied through BitGo Express.

export COIN="thypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X POST \
  https://app.bitgo-test.com/api/v2/$COIN/wallet/$WALLET_ID/enableBridging \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

const coin = bitgo.coin('thypeevm');
const result = await bitgo
  .post(coin.url(`/wallet/${walletId}/enableBridging`))
  .send({})
  .result();
console.dir(result);

Step Result

{
  "status": "funding_initiated",
  "fundingJobId": "ee7c9eba-f4be-4fd4-bb06-cef030717721",
  "estimatedConfirmationSeconds": 30,
  "currentBalance": "0",
  "minimumRequired": "21500000000000",
  "message": "Retry this request once the funding transaction confirms."
}

Response fields:

Because funding is asynchronous, poll the same endpoint until you reach a terminal status:

async function pollEnableBridgingUntilDone(walletId, maxRetries = 30, delayMs = 5000) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    const result = await bitgo
      .post(coin.url(`/wallet/${walletId}/enableBridging`))
      .send({})
      .result();

    if (result.status === 'funded' || result.status === 'already_funded_insufficient') {
      return result;
    }

    await new Promise((resolve) => setTimeout(resolve, delayMs));
  }

  throw new Error('enableBridging polling timed out before reaching a terminal status');
}

Check Bridgable Balance

Once the wallet's gas tank is funded, check how much of the wallet's balance is eligible to bridge. Note that this route is wallet-scoped (/api/v2/wallet/...), not coin-scoped.

export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X GET \
  https://app.bitgo-test.com/api/v2/wallet/$WALLET_ID/bridgableBalance \
  -H "Authorization: Bearer $ACCESS_TOKEN"

const url = bitgo.url(`/wallet/${walletId}/bridgableBalance`, 2);
const balances = await bitgo.get(url).result();
console.dir(balances);

Step Result

{
  "thypeevm": {
    "balance": "170277031600000"
  }
}

The response is keyed by coin name; use balances[coin].balance to get the bridgable amount in base units.

Initiate a Bridge Transfer

Submit a bridgeFunds transaction for a specific amount (in base units, no greater than the bridgable balance from the previous step). This requires wallet-passphrase signing, so route it through BitGo Express.

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="thypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"

curl -X POST \
  http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/sendmany \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "type": "bridgeFunds",
    "intentAmount": { "value": "'"$AMOUNT"'", "symbol": "'"$COIN"'" },
    "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
}'

const wallet = await bitgo.coin('thypeevm').wallets().get({ id: walletId });
const result = await wallet.sendMany({
  type: 'bridgeFunds',
  intentAmount: { value: amount, symbol: 'thypeevm' },
  walletPassphrase: 'yourWalletPassphrase',
});
console.dir(result);

symbol is the coin's chain name itself (hypeevm on mainnet, thypeevm on testnet) — not a display ticker. value is the amount to bridge, in base units.

Bridge Funds API Reference

Stake

BitGo supports native HYPE staking from HypeEVM MPC wallets. Staking delegates HYPE to a Hyperliquid validator, and rewards accrue directly to the delegation, auto-compounding daily.

Because delegation happens on Hyperliquid L1 (HyperCore) while your wallet lives on HypeEVM, BitGo builds each staking or unstaking request as a sequence of three transactions sent from your wallet's base address: a transfer across the HyperCore bridge address (0x2222...2222) and calls to the CoreWriter contract (0x3333...3333). BitGo sequences them for you, so each transaction becomes ready only after the previous one confirms.

To learn more about staking assets with BitGo, see Staking Overview.

The examples below use mainnet (hypeevm on https://app.bitgo.com). For testnet, use thypeevm on https://app.bitgo-test.com.

Staking Parameters

To fetch the live parameters, including the current estimated APY, call the List coins available for staking endpoint and read the hypeevm entry.

Prerequisites

• Enable staking in your enterprise by contacting sales@bitgo.com.
• Activate the wallet on Hyperliquid L1, as described above. A staking request from an address that isn't yet activated fails with Please activate this wallet <address> on Hyperliquid L1 by sending a small amount (e.g. 0.001 HYPE).
• Keep enough HYPE in the wallet to cover gas for all six transactions. BitGo reserves gas for the three staking transactions plus the three future unstaking transactions, which is why netMax in the wallet's spendable attributes is lower than max.

You can read the wallet's current limits, fee reserve, and permissions from the Get staking wallet endpoint:

export COIN="hypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X GET \
  https://app.bitgo.com/api/staking/v1/$COIN/wallets/$WALLET_ID \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

Step Result

{
  "coin": "hypeevm",
  "walletId": "6971e4fffc36aae70c8fa39b407bee04",
  "stakingWalletId": "91ca8afa-ce98-4473-90cc-86e473f9d38a",
  "walletType": "hot",
  "delegated": "20000000000000000",
  "pendingUnstake": "0",
  "pendingStake": "0",
  "spendableAttributes": {
    "staking": {
      "fee": "19800000000000000",
      "max": "59449639444903742",
      "min": "10000000000",
      "netMax": "39649639444903742",
      "netMin": "19800010000000000"
    },
    "unstaking": {
      "fee": "9900000000000000",
      "max": "20000000000000000",
      "min": "10000000000",
      "multipleDelegations": true,
      "requiresAmount": true,
      "requiresDelegationId": true,
      "requiresDelegationIds": false
    }
  },
  "permissionAttributes": {
    "staking": { "enabled": true, "allowClientToUseOwnValidator": true },
    "unstaking": { "enabled": true },
    "wallet": {
      "hasEnoughAdmins": true,
      "numberOfRequiredAdmins": 1,
      "useValidatorList": true,
      "showValidatorAddress": true,
      "allowPartialUnstake": true
    }
  }
}

Choose a Validator

The validator field is required for HypeEVM staking requests, and BitGo verifies that the address is an active Hyperliquid validator before accepting the request. To list the validators available to your wallet, including any you already delegate to, call the List wallet validators endpoint:

export COIN="hypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X GET \
  https://app.bitgo.com/api/staking/v1/$COIN/wallets/$WALLET_ID/validators \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

Step Result

{
  "validators": [
    {
      "coin": "hypeevm",
      "delegationAddress": "0x1a53253c11881a8daa0dd41801af436530c14be8",
      "delegated": "20000000000000000",
      "rewards": "0",
      "type": "Go",
      "provider": "GO",
      "pendingStake": "0",
      "pendingUnstake": "0",
      "stakingType": "STAKE"
    }
  ],
  "page": 1,
  "totalPages": 1,
  "totalElements": 1
}

If your enterprise has bring-your-own-validator enabled, indicated by allowClientToUseOwnValidator: true in the wallet's permission attributes, you can pass any active Hyperliquid validator address instead.

Create a Staking Request

Endpoint: Create staking request

export COIN="hypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
export VALIDATOR="<VALIDATOR_ADDRESS>"
export CLIENT_ID="<CLIENT_ID>"

curl -X POST \
  https://app.bitgo.com/api/staking/v1/$COIN/wallets/$WALLET_ID/requests \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "type": "STAKE",
    "amount": "'"$AMOUNT"'",
    "validator": "'"$VALIDATOR"'",
    "clientId": "'"$CLIENT_ID"'"
}'

const stakingWallet = wallet.toStakingWallet();
const stakingRequest = await stakingWallet.stake({
  amount: '<AMOUNT_IN_BASE_UNITS>',
  validator: '<VALIDATOR_ADDRESS>',
  clientId: '<CLIENT_ID>',
});

Step Result

The request is created with status NEW and no transactions yet. BitGo builds the transactions within a few minutes.

{
  "id": "80b7a769-dda7-4cb9-a86d-571a17c1b161",
  "clientId": "docs-test-1",
  "requestingUserId": "64da06d9bfc233000791845e156df223",
  "type": "STAKE",
  "enterpriseId": "6971e3c5c0f824044c8f1dda3c6b11ed",
  "walletId": "6971e4fffc36aae70c8fa39b407bee04",
  "walletType": "hot",
  "withdrawalAddress": "0xc125b1c6d306a1d800cb81f3959556d4ada81f3a",
  "coin": "hypeevm",
  "status": "NEW",
  "statusModifiedDate": "2026-08-20T06:43:42.562468Z",
  "createdDate": "2026-08-20T06:43:42.562418Z",
  "delegations": [],
  "transactions": [],
  "totalStaked": "0",
  "amount": "20000000000000000",
  "validatorAddress": "0x1a53253c11881a8daa0dd41801af436530c14be8",
  "objectType": "BASE_WITH_VALIDATOR_ADDRESS"
}

If you stake again to a validator you already delegate to, BitGo reuses the existing delegation rather than creating a new one. Staking to a different validator creates an additional delegation.

Staking Transactions

Poll Get staking request to follow the request. HypeEVM staking runs three transactions in order:

Only the first transaction starts as READY. The next two stay in WAITING until the preceding transaction confirms, so you sign and send them as they become ready.

{
  "id": "80b7a769-dda7-4cb9-a86d-571a17c1b161",
  "status": "READY",
  "transactions": [
    {
      "id": "ced0d4e1-d4c2-4d97-aa4f-18244e3b7d6a",
      "delegationId": "afd7d4be-d174-4c3b-a413-cea1fdc48e68",
      "transactionType": "authorize",
      "status": "READY",
      "amount": "20000000000000000",
      "txRequestId": "01a01de9-4cd0-7d4b-8407-d674e72d9448"
    },
    {
      "id": "bf147367-83e3-474d-926b-7bc83c9141dd",
      "delegationId": "afd7d4be-d174-4c3b-a413-cea1fdc48e68",
      "transactionType": "authorize_validator",
      "status": "WAITING",
      "amount": "20000000000000000"
    },
    {
      "id": "76c49185-3a8a-4676-95d2-68465055aa18",
      "delegationId": "afd7d4be-d174-4c3b-a413-cea1fdc48e68",
      "transactionType": "delegate",
      "status": "WAITING",
      "amount": "20000000000000000"
    }
  ]
}

After delegate confirms, the request status becomes CONFIRMED, the delegation becomes ACTIVE, and totalStaked reflects the delegated amount. There's no warmup period, so rewards start accruing right away.

To sign and send each ready transaction, and to approve requests when your wallet policy requires it, follow Stake Assets.

Cancel a Staking Request

You can cancel a staking request while it's still pending, which rejects the request and its remaining transactions:

export COIN="hypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export STAKING_REQUEST_ID="<YOUR_STAKING_REQUEST_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"

curl -X DELETE \
  https://app.bitgo.com/api/staking/v1/$COIN/wallets/$WALLET_ID/requests/$STAKING_REQUEST_ID \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

Unstake

Unstaking HYPE also takes three transactions and includes a 7-day cooldown while Hyperliquid processes the withdrawal queue.

Requirements

• Delegation lock - You can't undelegate until 1 day after the delegation was created. Attempting it earlier fails with Delegation <id> is locked until <timestamp>.
• delegationId is required - HypeEVM unstakes one delegation at a time. Omitting delegationId fails validation. Use List wallet delegations to find the delegation and check its unstakeable flag.
• amount is required - Partial unstakes are supported. You can also start a new unstake while an earlier one is still in cooldown, as long as delegated - pendingUnstake - amount >= 0.

Create an Unstaking Request

Endpoint: Create staking request

export COIN="hypeevm"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
export DELEGATION_ID="<YOUR_DELEGATION_ID>"

curl -X POST \
  https://app.bitgo.com/api/staking/v1/$COIN/wallets/$WALLET_ID/requests \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "type": "UNSTAKE",
    "amount": "'"$AMOUNT"'",
    "delegationId": "'"$DELEGATION_ID"'"
}'

const stakingWallet = wallet.toStakingWallet();
const unstakingRequest = await stakingWallet.unstake({
  amount: '<AMOUNT_IN_BASE_UNITS>',
  delegationId: '<YOUR_DELEGATION_ID>',
});

Unstaking Transactions

As with staking, only undelegate starts as READY. queue_withdrawals becomes ready once undelegate confirms, and withdraw_undelegated becomes ready 7 days after queue_withdrawals confirms. The delegation stays ACTIVE throughout the cooldown, with the amount tracked in pendingUnstake.

{
  "id": "26dc05a9-f21b-47ea-9af8-6b15a221c169",
  "type": "UNSTAKE",
  "coin": "hypeevm",
  "walletId": "6971e4fffc36aae70c8fa39b407bee04",
  "withdrawalAddress": "0xc125b1c6d306a1d800cb81f3959556d4ada81f3a",
  "status": "CONFIRMED",
  "createdDate": "2026-01-28T20:35:37.384079Z",
  "statusModifiedDate": "2026-02-20T00:30:02.711202Z",
  "amount": "10000000000000000",
  "transactions": [
    {
      "id": "f4ad883e-e31f-405d-aaf2-21a4365b7568",
      "txHash": "0xafee250a5f561c5aef72b5e7b912667e911a0966337acc3775d53589d052aa25",
      "delegationId": "afd7d4be-d174-4c3b-a413-cea1fdc48e68",
      "transactionType": "undelegate",
      "status": "CONFIRMED",
      "statusModifiedDate": "2026-01-29T06:18:02.439885Z",
      "amount": "10000000000000000"
    },
    {
      "id": "b24b4c79-4860-4c3e-979f-4e76e642e295",
      "txHash": "0x7fea93b7c93e6679ef9793526bad80bfdde3963b38894bd8bf57777b7d2fd04f",
      "delegationId": "afd7d4be-d174-4c3b-a413-cea1fdc48e68",
      "transactionType": "queue_withdrawals",
      "status": "CONFIRMED",
      "statusModifiedDate": "2026-01-30T09:57:03.095366Z",
      "amount": "10000000000000000"
    },
    {
      "id": "83ccce29-1d24-4b83-8bff-43499382334f",
      "txHash": "0xd8501af6b15e7f4d91ec952b58518d62cc994f5fd4580ae807f679533d09902d",
      "delegationId": "afd7d4be-d174-4c3b-a413-cea1fdc48e68",
      "transactionType": "withdraw_undelegated",
      "status": "CONFIRMED",
      "statusModifiedDate": "2026-02-20T00:30:02.710765Z",
      "amount": "10000000000000000"
    }
  ],
  "objectType": "UNSTAKE"
}

For the full signing and approval steps, see Unstake Assets.

Rewards

HYPE staking rewards auto-compound: Hyperliquid adds them to your delegated balance rather than paying them to your wallet, so there are no separate claim transactions. BitGo polls each active delegation and records the increase as a reward event on a 24-hour cycle. To read accrued rewards, call List wallet delegations and check the rewards and delegated fields, or see View Rewards and Delegations.

See Also

• Staking Overview
• Stake Assets
• Unstake Assets
• View Rewards and Delegations
• Create MPC Wallets
• Trading Overview
• Withdraw from Wallet - Custody MPC
• Withdraw from Wallet - Self-Custody MPC (Manual)
• Withdraw from Wallet - Self-Custody MPC (Simple)