Guides

Ethereum Sepolia

Overview

Sepolia is a permissioned public testnet for Ethereum, used by developers to test smart contracts and protocol upgrades before deploying to Ethereum mainnet. It uses Proof of Stake (PoS) consensus, mirroring mainnet Ethereum's account model and ECDSA signature algorithm. Sepolia ETH (sepETH) has no monetary value and is only available for testing and development purposes.

Note: Sepolia is a test/staging network only - BitGo does not support a corresponding mainnet asset under this coin.

Explorer

https://sepolia.etherscan.io/

Wallets Types

BitGo enables holding sepETH in the following wallet types:

	Multisig Cold	Multisig Hot	MPC Cold	MPC Hot
Custody	✅	❌	✅	❌
Self-Custody	✅	✅	✅	✅

Ticker Symbols

Mainnet	Testnet
N/A	sepeth

Faucet

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

Faucet: https://cloud.google.com/application/web3/faucet/ethereum/sepolia

Units

sepETH is divisible by 10¹⁸ and the base unit is a wei:

1 sepETH = 1,000,000,000,000,000,000 wei
1 wei = 0.000000000000000001 sepETH

sepETH denotes gas fees in gwei. Gwei are divisible by 10⁹ and the base unit is also a wei:

1 gwei = 1,000,000,000 wei
1 wei = 0.000000001 gwei

Therefore:

1 sepETH = 1,000,000,000 gwei
1 gwei = 0.000000001 sepETH

sepETH balances are only in string format.

Tokens

The Sepolia testnet natively supports the ERC20 token standard, used to test ERC20 token integrations before deploying to Ethereum mainnet.

Fees

Sepolia fees are dynamic - there are no minimum or default fee rates. Instead, Sepolia uses:

Units of gas used: The more complex the transaction is, the more gas it uses.
Base fee: A fee set by the network to pay for a transaction.
Priority fee: An optional tip that incentivizes node operators to include your transaction.

The following equation determines the dynamic gas fee: units of gas used * (base fee + priority fee)

Create Wallet

You can create a Sepolia wallet using the Generate wallet Express endpoint. To learn more about creating wallets, see the Create Wallets guide.

Note: Sepolia wallets and addresses must initialize on chain before you can use them. Do not try to deposit into a wallet or address until it's confirmed on chain. Attempting to deposit while still pending on-chain initialization can result in loss of assets.

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="sepeth"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export LABEL="<YOUR_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
}'

async function createHotWalletSimple() {
    const newWallet = await bitgo.coin('sepeth').wallets().generateWallet({
        label: '<YOUR_WALLET_NAME>',
        passphrase: '<YOUR_BITGO_LOGIN_PASSPHRASE>',
        enterprise: '<YOUR_ENTERPRISE_ID>',
        walletVersion: 4,
    });
    console.log(JSON.stringify(newWallet, undefined, 2));
}

Create Address

You can create a Sepolia address using the Create address endpoint. To learn more about creating addresses, see the Create Addresses guide.

export COIN="sepeth"
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/address \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN"

bitgo
  .coin('sepeth')
  .wallets()
  .getWallet({ id: '<YOUR_WALLET_ID>' })
  .then(function (wallet) {
    return wallet.createAddress();
  })
  .then(function (newAddress) {
    // print new address details
    console.dir(newAddress);
  });

Consolidate Balance

sepETH held in a native MPC wallet ("walletVersion": 4) requires consolidating to the base address to use the maximum spendable amount. sepETH held in other wallet versions doesn't require manual consolidations, because those wallets use automatic forwarder smart contracts.

Consolidation transactions require gas, and therefore require sufficient sepETH in your gas tank. You can consolidate only one asset at a time. When making multiple consolidations, you must wait for confirmation of the prior consolidation before initiating a new consolidation transaction.

You can manually consolidate your balances to the base address using the Consolidate account (simple) Express endpoint. To learn more about consolidating, see the Consolidate Account Balance guide.

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="sepeth"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export ADDRESS_1="<RECEIVE_ADDRESS_1>"
export ADDRESS_2="<RECEIVE_ADDRESS_2>"
export WALLET_PASSPHRASE="<YOUR_WALLET_PASSPHRASE>"

curl -X POST \
  http://$BITGO_EXPRESS_HOST/api/v2/$COIN/wallet/$WALLET_ID/consolidateAccount \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "consolidateAddresses": [
    {
      "address": "'"$ADDRESS_1"'"
    },
    {
      "address": "'"$ADDRESS_2"'"
    }
  ],
    "walletPassphrase": "'"$WALLET_PASSPHRASE"'"
}'

Estimate Fee

You can estimate transaction fees using the Get Fee Estimate endpoint. To learn more about estimating fees, see the Estimate Fees guide.

export COIN="sepeth"
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 = 'sepeth';

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

You can use the sendMany function to send sepETH to multiple recipients in one transaction. However, this feature is unavailable for ERC-20 tokens, which only support single-recipient transactions.

For simple MPC flows, this feature uses the BitGo JavaScript SDK, to invoke the Create a signature share for the transaction request and Get transaction requests by wallet endpoints. To learn more about transacting, see the Withdraw guide.

import { BitGoAPI } from '@bitgo/sdk-api';
import { Sepeth } from '@bitgo/sdk-coin-eth';

const bitgo = new BitGoAPI({ env: 'test' });
bitgo.register('sepeth', Sepeth.createInstance);

async function main() {
  await bitgo.authenticateWithAccessToken({ accessToken: '<YOUR_ACCESS_TOKEN>' });
  const wallet = await bitgo.coin('sepeth').wallets().get({ id: '<YOUR_WALLET_ID>' });
  const res = await wallet.sendMany({
    walletPassphrase: '<YOUR_WALLET_PASSPHRASE>',
    recipients: [{ address: '<DESTINATION_ADDRESS>', amount: '<AMOUNT_IN_BASE_UNITS>' }],
    type: 'transfer',
  });
  console.log(res);
}

main().catch((err) => console.error(err));

export BITGO_EXPRESS_HOST="<YOUR_LOCALHOST>"
export COIN="sepeth"
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"'"
}'

Stake

You can stake sepETH in multiples of 32 sepETH to a whitelisted validator node for testing purposes. Validators propose and attest blocks, earning test rewards for securing the network.

You can stake sepETH from your self-custody wallets using the Create staking request endpoint. To learn more about staking, see the Staking guide.

export COIN="sepeth"
export WALLET_ID="<YOUR_WALLET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export CLIENT_ID="<CLIENT_ID>"
export AMOUNT="<AMOUNT_IN_BASE_UNITS>"
export GAS_PRICE="<GAS_PRICE>"
export TYPE="STAKE"

curl -X POST \
  http://api/staking/v1/$COIN/wallets/$WALLET_ID/requests \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "clientId": "'$CLIENT_ID'",
    "amount": "'$AMOUNT'",
    "gasPrice": "'$GAS_PRICE'",
    "type": "STAKE"
}'

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