Similar to ETH, WETH and USDB on Blast is also rebasing and follows the same yield mode configurations.

However, unlike ETH where contracts have Disabled yield by default, WETH and USDB accounts have Automatic yield by default for both EOAs and smart contracts.

Users can change the yield mode of their WETH and USDB accounts by calling the configure function on the relevant token address.

enum YieldMode {

interface IERC20Rebasing {
  // changes the yield mode of the caller and update the balance
  // to reflect the configuration
  function configure(YieldMode) external returns (uint256);
  // "claimable" yield mode accounts can call this this claim their yield
  // to another address
  function claim(address recipient, uint256 amount) external returns (uint256);
  // read the claimable amount for an account
  function getClaimableAmount(address account) external view returns (uint256);

contract MyContract {
  // NOTE: these addresses differ on the Blast mainnet and testnet; the lines below are the mainnet addresses
  IERC20Rebasing public constant USDB = IERC20Rebasing(0x4300000000000000000000000000000000000003);
  IERC20Rebasing public constant WETH = IERC20Rebasing(0x4300000000000000000000000000000000000004);
  // NOTE: the commented lines below are the testnet addresses
  // IERC20Rebasing public constant USDB = IERC20Rebasing(0x4200000000000000000000000000000000000022);
  // IERC20Rebasing public constant WETH = IERC20Rebasing(0x4200000000000000000000000000000000000023);

  constructor() {
    USDB.configure(YieldMode.CLAIMABLE) //configure claimable yield for USDB
    WETH.configure(YieldMode.CLAIMABLE) //configure claimable yield for WETH

The WETH and USDB addresses will be slightly different on the Blast mainnet.

For applications that want exposure to WETH and USDB yield in a stable configuration, there are also non-rebasing nrETH and nrUSDB tokens that wrap ETH/WETH and USDB at their current value and can be unwrapped later to redeem their rebased value. They are the equivalent of wstETH to stETH.

interface INrETH {
  // wrap ETH to NrETH
  receive() external payable;

  // wrap WETH to NrETH
  function wrap(uint256 _amount) external returns (uint256);

  // unwrap NrETH to WETH
  function unwrap(uint256 _shares) external returns (uint256);

interface INrUSDB {
  // wrap USDB to NrUSDB
  function wrap(uint256 _amount) external returns (uint256);

  // unwrap NrUSDB to USDB
  function unwrap(uint256 _shares) external returns (uint256);

Getting WETH


To convert ETH to WETH on the Blast Sepolia Testnet from an EOA, you just need to send ETH to the WETH contract address on the L2, 0x4200000000000000000000000000000000000023. Don’t send funds to this address on the Sepolia L1, or they’ll be inaccessible. Smart contracts can do this as well, or they can call the deposit() public payable method and send the amount of ETH they’d like to wrap in the transaction.


The process will be the same on mainnet, but the WETH token address will be different. Be careful hardcoding the testnet WETH address for contracts you intend to deploy to mainnet.

The WETH address on mainnet is 0x4300000000000000000000000000000000000004.

Getting USDB


The Sepolia L1 has a mock USD token deployed at this address: 0x7f11f79DEA8CE904ed0249a23930f2e59b43a385. You can call the public mint(address to, uint256 amount) function to receive up to $10,000 mock USD tokens per call. The following examples use cast to send a mint transaction, but you can also send transactions visually here:

cast send --rpc-url= \
  --private-key=$PRIV_KEY \
  0x7f11f79DEA8CE904ed0249a23930f2e59b43a385 \
  "mint(address,uint256)" $ADDR 1000000000000000000000

If you’re using cast, you’ll need to provide your private key and wallet address in the above command and ensure that your address has enough Sepolia ETH to pay for the gas. The mock USD token has 18 decimals, so amount in the example command above,1000000000000000000000, represents $1000.

Once your mint transaction has been included in a block, you can check your mock USD token balance on the Sepolia L1 using the following command, filling in your address in $ADDR:

cast call --rpc-url= \
  0x7f11f79DEA8CE904ed0249a23930f2e59b43a385 \
  "balanceOf(address) returns (uint256)" $ADDR

Next, you’ll need to approve the L1 Blast Bridge contract to transfer your mock USD tokens. This is a standard ERC20 approval transaction. The following example approves the L1 Blast Bridge for a $1000 transfer.

cast send --rpc-url= \
  --private-key=$PRIV_KEY \
  0x7f11f79DEA8CE904ed0249a23930f2e59b43a385 \
  "approve(address,uint256)" "0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8" 1000000000000000000000

Finally, we have the bridging step. You can either bridge from the L1 to your same address on the L2 or to a different address. The following example will bridge $1000 to the same address, for simplicity:

cast send --rpc-url= \
  --private-key=$PRIV_KEY --gas-limit 500000 \
  0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8 \
  "bridgeERC20(address localToken,address remoteToken,uint256 amount,uint32,bytes)" \
  "0x7f11f79DEA8CE904ed0249a23930f2e59b43a385" \
  "0x4200000000000000000000000000000000000022" \
  1000000000000000000000 500000 0x

The first parameter, 0x7f11f79DEA8CE904ed0249a23930f2e59b43a385, is the mock USD token address on the Sepolia L1. The next address, 0x4200000000000000000000000000000000000022, is the USDB address on the Blast Sepolia Testnet L2. You might need to wait a little bit before your L1 bridge transaction takes effect on the L2. Once it’s been included, you can query your USDB balance via:

cast call --rpc-url= \
  0x4200000000000000000000000000000000000022 \
  "balanceOf(address) returns (uint256)" $ADDR

For reference, the following method allows you to bridge to an alternative address on the L2:

function bridgeERC20To(
  address _localToken,
  address _remoteToken,
  address to,
  uint256 _amount,
  uint32 _minGasLimit,
  bytes calldata _extraData
) public;


To get USDB on Blast mainnet, the process is similar, but you’ll need to bridge in a compatible stablecoin from Ethereum mainnet, like DAI, USDC, or USDT. Be careful hardcoding the testnet USDB address for contracts you intend to deploy to mainnet.

The USDB address on Blast mainnet is 0x4300000000000000000000000000000000000003.