# About Blast Source: https://metalayerlabs.mintlify.app/about-blast Blast is the only Ethereum L2 with native yield for ETH and stablecoins. Hero Blast yield comes from ETH staking and RWA protocols. The yield from these decentralized protocols is passed back to Blast users automatically. The default interest rate on other L2s is 0%. On Blast, it's 4% for ETH and 5% for stablecoins. ## Why a new L2 After the merge, Ethereum provides 4% yield on ETH. On-chain T-Bill protocols provide 5% yield on stablecoins. If users do not match or beat these rates, they are losing money to a form of inflation. L2s today do not have this yield. Incorporating ETH and stablecoin yield natively requires a new L2 designed from the ground up. Blast is an EVM-compatible, optimistic rollup that raises the baseline yield for users and developers without changing the experience cryptonatives expect. This yield makes it possible to create new business models for Dapps that aren’t possible on other L2s. ## How Blast works ### Auto Rebasing ETH itself, not WETH, STETH, or any other ERC20, is natively rebasing on the L2. The ETH balance for EOAs is automatically rebasing. Smart contracts can opt-in to this rebasing, making it easy to existing Dapps to deploy on Blast without any changes. USDB, Blast’s native stablecoin, is automatically rebasing as well. Like ETH on Blast, USDB is automatically rebasing for EOAs. USDB is also automatically rebasing for smart contracts. Smart contracts can opt-out from this rebasing. ### L1 Staking Blast only became possible following Ethereum's Shanghai upgrade. ETH yield from L1 staking, initially Lido, is automatically transferred to users via rebasing ETH on the L2. In the future, the Blast community will have the power to supplement, or even fully replace, Lido Blast-native solutions or other third party protocols. ### T-Bill Yield Users who bridge stablecoins receive USDB, Blast's auto-rebasing stablecoin. The yield for USDB comes from MakerDAO's on-chain T-Bill protocol. USDB can be redeemed for DAI when bridging back to Ethereum. In the future, the Blast community will have the power to supplement, or even fully replace, MakerDAO with Blast-native solutions or other third party protocols. ### Gas Revenue Sharing Other L2s keep revenue from gas fees for themselves. Blast gives net gas revenue back to Dapps programmatically. Dapps developers can keep this revenue for themselves or use it to subsidize gas fees for users. # Points API (Retired) Source: https://metalayerlabs.mintlify.app/airdrop/mainnet-points-api/overview Throughout Phase 1 and Phase 2 of the Blast Airdrop, the Points API allowed Blast dapps to redistribute Blast points and Gold to users. With the launch of the Phase 2 Airdrop and Blast Mobile, **the Points API will be officially retired** as we transition to updated tokenomics featuring liquid BLAST rewards. Under this new system users will no longer accrue points/Gold and dapps will no longer be required to manage and redistribute them. Moving forward, users can earn liquid BLAST rewards through Blast Mobile's Earn App and dapp incentives will take the form of liquid BLAST grants awarded by the Blast Foundation. # Bridged Token Addresses Source: https://metalayerlabs.mintlify.app/building/bridged-token-addresses # Mainnet | Token Name | Token Address | | ---------- | --------------------------------------------------------------------------------------------------------------------- | | **WETH** | [0x4300000000000000000000000000000000000004](https://blastscan.io/address/0x4300000000000000000000000000000000000004) | | **USDB** | [0x4300000000000000000000000000000000000003](https://blastscan.io/address/0x4300000000000000000000000000000000000003) | | **NrETH** | [0x9D020B1697035d9d54f115194c9e04a1e4Eb9aF7](https://blastscan.io/address/0x9D020B1697035d9d54f115194c9e04a1e4Eb9aF7) | | **NrUSDB** | [0x96F6b70f8786646E0FF55813621eF4c03823139C](https://blastscan.io/address/0x96F6b70f8786646E0FF55813621eF4c03823139C) | | **WBTC** | [0xF7bc58b8D8f97ADC129cfC4c9f45Ce3C0E1D2692](https://blastscan.io/address/0xF7bc58b8D8f97ADC129cfC4c9f45Ce3C0E1D2692) | ## Testnet | Token Name | Token Address | | ---------- | --------------------------------------------------------------------------------------------------------------------------------- | | **WETH** | [0x4200000000000000000000000000000000000023](https://sepolia.blastexplorer.io/address/0x4200000000000000000000000000000000000023) | | **USDB** | [0x4200000000000000000000000000000000000022](https://sepolia.blastexplorer.io/address/0x4200000000000000000000000000000000000022) | For more details on working with WETH and USDB, check out the guide [here](https://docs.blast.io/building/guides/weth-yield#getting-usdb). # FAQ Source: https://metalayerlabs.mintlify.app/building/bridges/faq Transferring from Ethereum to Blast only takes a few minutes. Transferring from Blast to Ethereum takes approximately 7 days. This is a security feature designed to help secure Blast. Yes, but only if certain conditions are met. Verification of these conditions is the responsibility of the user. [See here](/building/bridges/mainnet#third-party-bridges) for details. # Mainnet Source: https://metalayerlabs.mintlify.app/building/bridges/mainnet # How to deposit to Blast ## Overview To deposit ETH to Blast, simply transfer the ETH to the relevant Blast Bridge address on the L1. After the deposit transaction is mined, the balance will be credited on the L2 as soon as the Blast Sequencer indexes the transaction. ### ETH Transfer ETH via the tool of your choice to the following bridge address on Ethereum Mainnet: `0x3a05E5d33d7Ab3864D53aaEc93c8301C1Fa49115`. ### WETH, STETH, USDC, USDT, DAI To depositing Mainnet WETH, STETH, USDC, USDT, DAI, use the bridge UI at Blast.io Instructions on how to bridge programmatically will be shared soon. ### Other tokens Blast supports bridging arbitrary tokens in a similar manner to Optimism. Refer to the Optimism docs to learn how to bridge arbitrary tokens. Instructions on how to bridge programmatically will be shared soon. ## Deposit via UI (recommended) Go to [blast.io/bridge](https://blast.io/bridge) to bridge via the UI. ## Third-Party Bridges To ensure the security of your funds and guarantee expected yield and points accumulation, we recommend using the official Blast bridge. However, there several third-party bridges that can be used to bridge assets to Blast. As long as the bridge used results in the correct assets being credited to your account on Blast, you will receive the same yield and points accumulation as if you had used the official bridge. See documentation on [Auto Rebasing](about-blast#auto-rebasing) for a better understanding of why this is the case. Before using a third-party bridge to bridge native ETH or yield bearing USD tokens, it is critical that you verify the following: ### Native ETH, WETH, STETH When bridging native ETH, WETH, or STETH the third-party bridge must credit your account on Blast with native ETH (not a wrapped ERC20 version) in order for you to recieve yield and points. ### USDC, USDT, DAI When bridging supported USD denominated stable coins (USDC, USDT, DAI), the third-party bridge must credit your account on Blast with [USDB](about-blast#t-bill-yield) in order for you to earn yield. # How to withdraw from Blast Withdrawals from Blast require multiple steps. The process is similar to withdrawing from Optimism. Withdrawals take approximately 7 days to complete. Detailed instructions/code samples will be shared soon. In the meantime, you can use the UI at [blast.io/bridge](https://blast.io/bridge) to withdraw. # Testnet Source: https://metalayerlabs.mintlify.app/building/bridges/testnet # How to deposit to Blast ## Overview To deposit ETH to Blast, simply transfer the ETH to the relevant Blast Bridge address on the L1. After the deposit transaction is mined, the balance will be credited on the L2 as soon as the Blast Sequencer indexes the transaction. ### ETH Transfer ETH via the tool of your choice to the following bridge address on Ethereum Sepolia: `0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8`. Do not transfer mainnet ETH to this address. ### WETH, STETH, USDC, USDT, DAI Depositing Ethereum Sepolia WETH, STETH, USDC, USDT, DAI will be supported in the future, but is currently not supported on the Blast Sepolia testnet. Blast Sepolia ETH can be wrapped to WETH directly on the L2 (see Foundry example below). ### Other tokens Blast supports bridging arbitrary tokens in a similar manner to Optimism. Refer to the Optimism docs to learn how to bridge arbitrary tokens. Note: this guide is for the Blast Sepolia Testnet. Do not bridge mainnet tokens to these addresses. Bridge address for arbitrary ERC20 tokens (L1StandardBridge): `0xDeDa8D3CCf044fE2A16217846B6e1f1cfD8e122f` Bridge address for arbitrary ERC721 tokens (L1ERC721Bridge): `0x993385F8A2aD69dfa0884287801191DE9805Ff37` ## Deposit programmatically You can use any tool/wallet to send the transfer transaction to the Blast Bridge address. Here are some examples: ### Foundry The following code snippet shows how to use [Foundry’s](https://github.com/foundry-rs/foundry) cast tool to send ETH from Ethereum Sepolia to Blast Sepolia, and then convert that ETH to WETH. ```bash # Depositing Sepolia ETH cast send -i 0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8 --value 0.1ether --rpc-url https://sepolia.infura.io/v3/$INFURA_KEY # Confirming the bridged Sepolia ETH on Blast cast balance $YOUR_ADDRESS --rpc-url https://sepolia.blast.io # Converting to WETH (Rebasing) on testnet; do not transfer mainnet ETH to this address cast send -i 0x4200000000000000000000000000000000000023 --value 0.1ether --rpc-url https://sepolia.blast.io ``` ### ethers.js The following code snips shows how to use ethers.js to send ETH from Ethereum Sepolia to Blast Sepolia. ```tsx const { ethers } = require("ethers"); const INFURA_KEY = "YOUR_INFURA_KEY"; const PRIVATE_KEY = "YOUR_PRIVATE_KEY"; // This is for Blast Sepolia Testnet, not Blast mainnet const BlastBridgeAddress = "0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8"; // Providers for Sepolia and Blast networks const sepoliaProvider = new ethers.providers.JsonRpcProvider(`https://sepolia.infura.io/v3/${INFURA_KEY}`); const blastProvider = new ethers.providers.JsonRpcProvider("https://sepolia.blast.io"); // Wallet setup const wallet = new ethers.Wallet(PRIVATE_KEY); const sepoliaWallet = wallet.connect(sepoliaProvider); const blastWallet = wallet.connect(blastProvider); // Transaction to send 0.1 Sepolia ETH const tx = { to: BlastBridgeAddress, value: ethers.utils.parseEther("0.1") }; const transaction = await sepoliaWallet.sendTransaction(tx); await transaction.wait(); // Confirm the bridged balance on Blast const balance = await blastProvider.getBalance(wallet.address); console.log(`Balance on Blast: ${ethers.utils.formatEther(balance)} ETH`); ``` # How to withdraw from Blast Withdrawals from Blast require multiple steps. The process is similar to withdrawing from Optimism. Withdrawals take approximately 7 days to complete. # Contract Verification Source: https://metalayerlabs.mintlify.app/building/contract-verification ## Where To Verify Blast has a several [block explorers](/tools/block-explorers) to choose from. Which explorer you choose to spend the most time with is a matter of personal preference, but one common question from new builders is **where do I verify my contracts?**. Out of the available options, **[blastscan.io](https://blastscan.io)** and **[blastexplorer.io](https://blastexplorer.io)** are where most people verify their contracts, so that's what we'd recommend. The following guide will help you steer clear common issues while verifying your contracts with Foundry and Hardhat. ## Do I Need An API Key? Whether or not you need valid API key depends on (a) which network you're using and (b) which API you're targeting. Blastexplorer's API will let you verify on testnet and mainnet without requiring a valid API key, but blastscan does require one when verifying on mainnet. You can get a blastscan API key by creating a free account [here](https://blastscan.io/login), and navigating to the "API-KEYs" section of your profile. | Explorer | Testnet | Mainnet | | :--------------- | :--------------------------: | :--------------------------: | | blastscan.io | no | yes | | blastexplorer.io | no | no | `forge` requires a value for the `--etherscan-api-key` option even in cases where a *valid* API key is not required. Just use a placeholder here. ## Verification Endpoints Once you've decided where to verify, ensure that you are making your verification request to the correct API endpoint. In Hardhat, this "verification endpoint" is the `apiUrl` specified in config; in Foundry, this is the `--verifier-url` you'll need to provide in your forge command: | blastscan       | | | :-------------- | :------------------------------------- | | Testnet | `https://api-sepolia.blastscan.io/api` | | Mainnet | `https://api.blastscan.io/api` | | blastexplorer | | | :------------ | :-------------------------------------------------------------------- | | Testnet | `https://api.routescan.io/v2/network/testnet/evm/168587773/etherscan` | | Mainnet | `https://api.routescan.io/v2/network/mainnet/evm/81457/etherscan` | ## Verification Examples ### Foundry Use these examples, filling in appropriate values as discussed above, to verify your contracts during deployment using `forge script` or to verify an existing deployment with `forge verify-contract`. ```yaml forge script --verify --verifier-url \ --etherscan-api-key --rpc-url \ --verify --broadcast -vvvv ``` ``` forge verify-contract
\ --verifier-url \ --etherscan-api-key --watch ``` *** ### Hardhat Whether using `hardhat-ignition-ethers` or `hardhat-verify`, successful verification in Hardhat is primarily a matter of setting up your `hardhat.config.ts` or `hardhat.config.js` file correctly. You'll need to configure the `networks` and `etherscan` properties as demonstrated below. In order to specify the correct verification endpoint from the [table above](#verification-endpoints), you will also need to configure the `etherscan.customChains` property. ```javascript hardhat.config.ts import { HardhatUserConfig } from "hardhat/config"; import "@nomicfoundation/hardhat-toolbox"; import "@nomicfoundation/hardhat-ignition-ethers"; import { vars } from "hardhat/config"; const PRIVATE_KEY = vars.get("PRIVATE_KEY"); const config: HardhatUserConfig = { solidity: "0.8.24", networks: { "blast-sepolia": { url: "https://sepolia.blast.io", accounts: [PRIVATE_KEY] }, "blast-mainnet": { url: "https://rpc.blast.io", accounts: [PRIVATE_KEY] }, }, etherscan: { apiKey: API_KEY, customChains: [ { network: "blast-sepolia", chainId: 168587773, urls: { apiURL: , browserURL: } }, { network: "blast-mainnet", chainId: 81457, urls: { apiURL: , browserURL: } } ], enabled: true } }; export default config; ``` ```javascript hardhat.config.js require("@nomicfoundation/hardhat-toolbox"); require("@nomicfoundation/hardhat-toolbox"); require("@nomicfoundation/hardhat-ignition-ethers"); const { vars } = require("hardhat/config"); const PRIVATE_KEY = vars.get("PRIVATE_KEY"); module.exports = { solidity: "0.8.24", networks: { "blast-sepolia": { url: "https://sepolia.blast.io", accounts: [PRIVATE_KEY] }, "blast-mainnet": { url: "https://rpc.blast.io", accounts: [PRIVATE_KEY] }, }, etherscan: { apiKey: API_KEY, customChains: [ { network: "blast-sepolia", chainId: 168587773, urls: { apiURL: , browserURL: } }, { network: "blast-mainnet", chainId: 81457, urls: { apiURL: , browserURL: } } ], enabled: true } }; ``` ``` npx hardhat ignition deploy ignition/modules/Example.ts \ --network --verify ``` Using `ignition deploy` and `ignition veriry` ```yaml # 1. Deploy contract making sure to specify a deployment-id npx hardhat ignition deploy ignition/modules/Example.ts \ --network --deployment-id # 2. Use deployment-id to verify the corresponding deployment npx hardhat ignition verify ``` Using `hardhat verify` ``` npx hardhat verify
--network ``` # Blast Contracts Source: https://metalayerlabs.mintlify.app/building/contracts # Mainnet ### L1 Blast Contracts Core Blast contracts deployed on **Ethereum Mainnet**. | Name | Address | | ------------------------------------------------------------------------------------------------- | -------------------------------------------- | | [L1StandardBridge](https://etherscan.io/address/0x697402166Fbf2F22E970df8a6486Ef171dbfc524) | `0x697402166Fbf2F22E970df8a6486Ef171dbfc524` | | [L1BlastBridge](https://etherscan.io/address/0x3a05E5d33d7Ab3864D53aaEc93c8301C1Fa49115) | `0x3a05E5d33d7Ab3864D53aaEc93c8301C1Fa49115` | | [L1ERC721Bridge](https://etherscan.io/address/0xa45A0c7C47DB8C6e99b2d7C4939F7f7Cf69C8975) | `0xa45A0c7C47DB8C6e99b2d7C4939F7f7Cf69C8975` | | [OptimismPortal](https://etherscan.io/address/0x0Ec68c5B10F21EFFb74f2A5C61DFe6b08C0Db6Cb) | `0x0Ec68c5B10F21EFFb74f2A5C61DFe6b08C0Db6Cb` | | [L1CrossDomainMessenger](https://etherscan.io/address/0x5D4472f31Bd9385709ec61305AFc749F0fA8e9d0) | `0x5D4472f31Bd9385709ec61305AFc749F0fA8e9d0` | | [L2OutputOracle](https://etherscan.io/address/0x826D1B0D4111Ad9146Eb8941D7Ca2B6a44215c76) | `0x826D1B0D4111Ad9146Eb8941D7Ca2B6a44215c76` | | [ETHYieldManager](https://etherscan.io/address/0x98078db053902644191f93988341E31289E1C8FE) | `0x98078db053902644191f93988341E31289E1C8FE` | | [USDYieldManager](https://etherscan.io/address/0xa230285d5683C74935aD14c446e137c8c8828438) | `0xa230285d5683C74935aD14c446e137c8c8828438` | | [LidoYieldProvider](https://etherscan.io/address/0x4316A00D31da1313617DbB04fD92F9fF8D1aF7Db) | `0x4316A00D31da1313617DbB04fD92F9fF8D1aF7Db` | | [DsrYieldProvider](https://etherscan.io/address/0x0733F618118bF420b6b604c969498ecf143681a8) | `0x0733F618118bF420b6b604c969498ecf143681a8` | ### L2 Blast Contracts Core Blast contracts deployed on **Blast**. | Name | Address | | -------------------------------------------------------------------------------------------------------- | -------------------------------------------- | | [L2StandardBridge](https://blastscan.io/address/0x4200000000000000000000000000000000000010) | `0x4200000000000000000000000000000000000010` | | [L2BlastBridge](https://blastscan.io/address/0x4300000000000000000000000000000000000005) | `0x4300000000000000000000000000000000000005` | | [L2ERC721Bridge](https://blastscan.io/address/0x4200000000000000000000000000000000000014) | `0x4200000000000000000000000000000000000014` | | [L2CrossDomainMessenger](https://blastscan.io/address/0x4200000000000000000000000000000000000007) | `0x4200000000000000000000000000000000000007` | | [L2ToL1MessagePasser](https://blastscan.io/address/0x4200000000000000000000000000000000000016) | `0x4200000000000000000000000000000000000016` | | [OptimismMintableERC20Factory](https://blastscan.io/address/0x4200000000000000000000000000000000000012) | `0x4200000000000000000000000000000000000012` | | [OptimismMintableERC721Factory](https://blastscan.io/address/0x4200000000000000000000000000000000000017) | `0x4200000000000000000000000000000000000017` | ### Token Contracts Token contracts deployed on **Blast**. | Name | Address | | --------------------------------------------------------------------------------- | -------------------------------------------- | | [WETH](https://blastscan.io/address/0x4300000000000000000000000000000000000004) | `0x4300000000000000000000000000000000000004` | | [USDB](https://blastscan.io/address/0x4300000000000000000000000000000000000003) | `0x4300000000000000000000000000000000000003` | | [BLAST](https://blastscan.io/address/0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad) | `0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad` | | [WBTC](https://blastscan.io/address/0xF7bc58b8D8f97ADC129cfC4c9f45Ce3C0E1D2692) | `0xF7bc58b8D8f97ADC129cfC4c9f45Ce3C0E1D2692` | | [NrETH](https://blastscan.io/address/0x9D020B1697035d9d54f115194c9e04a1e4Eb9aF7) | `0x9D020B1697035d9d54f115194c9e04a1e4Eb9aF7` | | [NrUSDB](https://blastscan.io/address/0x96F6b70f8786646E0FF55813621eF4c03823139C) | `0x96F6b70f8786646E0FF55813621eF4c03823139C` | ### Utility Contracts Commonly used utility contracts deployed on **Blast**. Blast `CREATE2` factory contract deployments: | Name | Address | | ---------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | | [pcaversaccio/create2deployer](https://github.com/pcaversaccio/create2deployer) | `0x13b0D85CcB8bf860b6b79AF3029fCA081AE9beF2` | | [pcaversaccio/createx](https://github.com/pcaversaccio/createx) | `0xba5Ed099633D3B313e4D5F7bdc1305d3c28ba5Ed` | | [Arachnid/deterministic-deployment-proxy](https://github.com/Arachnid/deterministic-deployment-proxy) | `0x4e59b44847b379578588920ca78fbf26c0b4956c` | | [Zoltu/deterministic-deployment-proxy](https://github.com/Zoltu/deterministic-deployment-proxy) | `0x7A0D94F55792C434d74a40883C6ed8545E406D12` | | [INEFFICIENT\_IMMUTABLE\_CREATE2\_FACTORY\_ADDRESS](https://github.com/ProjectOpenSea/seaport/blob/main/docs/Deployment.md#relevant-addresses) | `0xcfA3A7637547094fF06246817a35B8333C315196` | | [IMMUTABLE\_CREATE2\_FACTORY\_ADDRESS](https://github.com/ProjectOpenSea/seaport/blob/main/docs/Deployment.md#relevant-addresses) | `0x0000000000ffe8b47b3e2130213b802212439497` | Blast Multicall3 deployment (on block `88189`) : | Name | Address | | ----------------------------------------------- | -------------------------------------------- | | [Multicall3](https://github.com/mds1/multicall) | `0xcA11bde05977b3631167028862bE2a173976CA11` | *** # Testnet ### L1 Blast Contracts Core Blast testnet contracts deployed on **Sepolia**. | Name | Address | | --------------------------------------------------------------------------------------------------------- | -------------------------------------------- | | [L1StandardBridge](https://sepolia.etherscan.io/address/0xDeDa8D3CCf044fE2A16217846B6e1f1cfD8e122f) | `0xDeDa8D3CCf044fE2A16217846B6e1f1cfD8e122f` | | [L1BlastBridge](https://sepolia.etherscan.io/address/0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8) | `0xc644cc19d2A9388b71dd1dEde07cFFC73237Dca8` | | [L1ERC721Bridge](https://sepolia.etherscan.io/address/0x993385F8A2aD69dfa0884287801191DE9805Ff37) | `0x993385F8A2aD69dfa0884287801191DE9805Ff37` | | [OptimismPortal](https://sepolia.etherscan.io/address/0x2757E4430e694F27b73EC9C02257cab3a498C8C5) | `0x2757E4430e694F27b73EC9C02257cab3a498C8C5` | | [L1CrossDomainMessenger](https://sepolia.etherscan.io/address/0x9338F298F29D3918D5D1Feb209aeB9915CC96333) | `0x9338F298F29D3918D5D1Feb209aeB9915CC96333` | | [L2OutputOracle](https://sepolia.etherscan.io/address/0x311fF72DfE214ADF97618DD2E731637E8F41bD8c) | `0x311fF72DfE214ADF97618DD2E731637E8F41bD8c` | | [ETHYieldManager](https://sepolia.etherscan.io/address/0xed530ba33b4dc14572864bb9a776c9a42cf89fa5) | `0xed530ba33b4dc14572864bb9a776c9a42cf89fa5` | | [TestnetYieldProvider](https://sepolia.etherscan.io/address/0x26B1B9Ff3A25a7D6e4468fA94696e45d066c7d08) | `0x26B1B9Ff3A25a7D6e4468fA94696e45d066c7d08` | ### L2 Blast Contracts Core Blast testnet contracts deployed on the **Blast Sepolia**. | Name | Address | | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | | [L2StandardBridge](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000010) | `0x4200000000000000000000000000000000000010` | | [L2BlastBridge](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000024) | `0x4200000000000000000000000000000000000024` | | [L2CrossDomainMessenger](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000007) | `0x4200000000000000000000000000000000000007` | | [L2ToL1MessagePasser](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000016) | `0x4200000000000000000000000000000000000016` | | [OptimismMintableERC20Factory](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000012) | `0x4200000000000000000000000000000000000012` | | [L2ERC721Bridge](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000014) | `0x4200000000000000000000000000000000000014` | | [OptimismMintableERC721Factory](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000017) | `0x4200000000000000000000000000000000000017` | ### Token Contracts Testnet USDB can be acquired by bridging the (mock) USD stablecoin below, deployed on **Sepolia**, to Blast Sepolia. More information can be found [HERE](/building/guides/weth-yield#testnet-2). | Name | Address | | --------------------------------------------------------------------------------------------- | -------------------------------------------- | | [(mock) USD](https://sepolia.etherscan.io/address/0x7f11f79DEA8CE904ed0249a23930f2e59b43a385) | `0x7f11f79DEA8CE904ed0249a23930f2e59b43a385` | Token contracts deployed on **Blast Sepolia**. | Name | Address | | --------------------------------------------------------------------------------------- | -------------------------------------------- | | [WETH](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000023) | `0x4200000000000000000000000000000000000023` | | [USDB](https://sepolia.blastscan.io/address/0x4200000000000000000000000000000000000022) | `0x4200000000000000000000000000000000000022` | There is no BLAST token deployment testnet, any ERC20 can be used in its place for testing purposes. # Receive and claim ETH yield Source: https://metalayerlabs.mintlify.app/building/guides/eth-yield # Overview Blast is an L2 that modifies the native ETH token to be rebasing. Blast users and smart contracts can earn \~4% from beacon chain staking yield. EOAs automatically receive ETH yield via rebasing. Smart contract accounts have three Yield Modes for their rebasing mode: * **Void (DEFAULT):** ETH balance never changes; no yield is earned * **Automatic:** native ETH balance rebases (increasing only) * **Claimable:** ETH balance never changes; yield accumulates separately Smart contracts must interact with the Blast yield contract located at `0x4300000000000000000000000000000000000002` to change their Yield Mode. # Yield Modes ## Void Yield (DEFAULT) Smart contract accounts default to **Disabled** yield in order to maintain compatibility with existing Ethereum Mainnet dapps and EVM-compatible L2 dapps. Any normal dapp can be deployed to Blast and Just Work™ without any changes needed. ## Automatic Yield If 1 ETH is deposited to a dapp with **Automatic** yield enabled, the dapp's balance will grow to 1.04 ETH in a year. This is useful for dapps that want to pass yield on to their users such that there's no opportunity cost for the user to deposit ETH to the dapp. ```solidity interface IBlast{ // See IBlast interface source code below } contract MyContract { constructor() { IBlast(0x43...02).configureAutomaticYield() //contract balance will grow automatically } } ``` ## Claimable Yield If 1 ETH is deposited to a dapp with **Claimable** yield enabled, the dapp’s balance will remain at 1 ETH even after a year. The dapp will accrue a yield balance of 0.04 ETH which can be claimed asynchronously. ```solidity interface IBlast{ // See IBlast interface source code below } contract MyContract { constructor() { IBlast(0x43...02).configureClaimableYield() } function claimYield(address recipient, uint256 amount) external { //This function is public meaning anyone can claim the yield IBlast(0x43...02).claimYield(address(this), recipient, amount); } function claimAllYield(address recipient) external { //This function is public meaning anyone can claim the yield IBlast(0x43...02).claimAllYield(address(this), recipient); } } ``` # Governor The governor is the address that’s allowed to claim the contract’s yield and gas, which might be the contract’s own address, its owner, or anything else. By default, the governor is the contract’s own address. After contract creation, only the governor can reconfigure the contract’s yield and gas mode. ```solidity interface IBlast{ // See IBlast interface source code below } contract MyContract { constructor(address gov) { IBlast(0x43...02).configureClaimableYield() IBlast(0x43...02).configureGovernor(gov) //only this address can claim yield } } ``` # FAQ ## Can an EOA forward its yield to another address? An **Automatic** yield mode EOA or contract cannot forward its yield to another account. On yield distribution events, the balance of an automatically rebasing account will automatically increase. A **Claimable** account's yield is not counted as part of the EVM balance. The yield must be claimed via the Blast pre-deploy's `claimYield()` or `claimAllYield()` functions. Both these interfaces allow the caller to specify a recipient for the yield. In this way, yield accumulating to a **Claimable** account can be claimed to another address directly. Note that this does not happen automatically -- a contract call must be made to claim. Additionally, an EOA can set its governor to another address, which would allow that address to make these `claimYield` calls without any interactions from the EOA. ## How often do balances update due to yield? On mainnet, ETH balances will update approximately daily. On testnet, ETH balances will update hourly at a rate of \~0.01% per day. # IBlast Interface In the interface below, when you see a function like `configureX` with corresponding `configureXOnBehalf` version, the difference is that `configureX` configures the caller and `configureXOnBehalf` configures the contract corresponding to the `contractAddress` parameter. ```solidity enum YieldMode { AUTOMATIC, VOID, CLAIMABLE } enum GasMode { VOID, CLAIMABLE } interface IBlast{ // configure function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external; function configure(YieldMode _yield, GasMode gasMode, address governor) external; // base configuration options function configureClaimableYield() external; function configureClaimableYieldOnBehalf(address contractAddress) external; function configureAutomaticYield() external; function configureAutomaticYieldOnBehalf(address contractAddress) external; function configureVoidYield() external; function configureVoidYieldOnBehalf(address contractAddress) external; function configureClaimableGas() external; function configureClaimableGasOnBehalf(address contractAddress) external; function configureVoidGas() external; function configureVoidGasOnBehalf(address contractAddress) external; function configureGovernor(address _governor) external; function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external; // claim yield function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256); function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256); // claim gas function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256); function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256); function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256); function claimGas(address contractAddress, address recipientOfGas, uint256 gasToClaim, uint256 gasSecondsToConsume) external returns (uint256); // read functions function readClaimableYield(address contractAddress) external view returns (uint256); function readYieldConfiguration(address contractAddress) external view returns (uint8); function readGasParams(address contractAddress) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode); } ``` # Receive and claim gas fees Source: https://metalayerlabs.mintlify.app/building/guides/gas-fees # Overview Existing L2s like Optimism and Arbitrum keep sequencer fees for themselves. Blast redirects sequencer fees to the dapps that induced them, allowing smart contract developers to have an additional source of revenue. Contracts have two options for their Gas Mode: * **Void (DEFAULT):** base + priority fees go to the sequencer operator * **Claimable:** base + priority fees spent on this contract can be claimed by the contract, net of L1 fees Smart contracts must interact with the Blast contract located at `0x4300000000000000000000000000000000000002` to change their Gas Mode. # Setting Gas Mode to Claimable The entity that is allowed to claim the gas fees spent on a contract is known as its "governor". By default, the governor of a smart contract is the contract itself. The following example sets the Gas Mode to claimable and exposes a function to allow anybody to claim this contract's gas fees. ```solidity interface IBlast { // Note: the full interface for IBlast can be found below function configureClaimableGas() external; function claimAllGas(address contractAddress, address recipient) external returns (uint256); } contract MyContract { IBlast public constant BLAST = IBlast(0x4300000000000000000000000000000000000002); constructor() { // This sets the Gas Mode for MyContract to claimable BLAST.configureClaimableGas(); } // Note: in production, you would likely want to restrict access to this function claimMyContractsGas() external { BLAST.claimAllGas(address(this), msg.sender); } } ``` Alternatively, you can specify an external governor. Once the governor is changed away from the contract itself, only the governor can set the gas mode, claim gas fees, and reconfigure the governor. In the following example, the governor could be an EOA belonging to the contract creator or another smart contract. ```solidity interface IBlast { // Note: the full interface for IBlast can be found below function configureClaimableGas() external; function configureGovernor(address governor) external; } contract MyContract { IBlast public constant BLAST = IBlast(0x4300000000000000000000000000000000000002); constructor(address governor) { BLAST.configureClaimableGas(); // This sets the contract's governor. This call must come last because after // the governor is set, this contract will lose the ability to configure itself. BLAST.configureGovernor(governor); } } ``` The governor now has the ability to claim the gas fees for this contract by sending a `claimAllGas` transaction to the Blast contract. ```solidity BLAST.claimAllGas(myContractAddress, recipient); ``` # Claiming Gas Fees If you claim the gas fees for a contract immediately after the fees are earned, then 50% of the fees will be sent to the claim recipient and 50% will be sent to the sequencer operator. This is known as the "claim rate", and it starts at 50% and increases to 100% over time. For mainnet, the parameters will be set to a 50% initial claim rate, 30 day maturity period, and 100% final claim rate. You can think of each transaction's gas fees as having their own claim rate that evolves independently. As an example, suppose you have 1 ETH in fees from January 1st and 1 ETH in fees from January 15th. When you claim 1 month later on February 1st, you'll be able to claim 100% of your January 1st fees and 75% of your January 15th fees. Only half a month has passed since your January 15th fees, so the claim rate has increased halfway to its max potential, from 50% to 75%. Your average claim rate for the full 2 ETH of fees will be the weighted average of these two claim rates: 87.5%. Thinking about the effective claim rate can get very confusing when you have many transactions over time, so for convenience, there are a handful of utility methods to make the claiming process easy. #### claimAllGas ```solidity function claimAllGas(address contractAddress, address recipient) external returns (uint256); ``` To claim all of your contract's gas fees, regardless of your resulting claim rate, you can call `claimAllGas`. Your resulting claim rate may be anywhere from 50% to 100% depending on how long it has been since the fees were earned. #### claimMaxGas ```solidity function claimMaxGas(address contractAddress, address recipient) external returns (uint256); ``` If you'd like to maximize the amount of gas fees claimed and you're okay waiting for the fees to mature, then you can use `claimMaxGas` to guarantee a 100% claim rate. By guaranteeing the claim rate, you may not be able to claim all of your gas fees though. Any remaining fees after calling this function will remain in the Blast Gas contract for you to claim later. #### claimGasAtMinClaimRate ```solidity function claimGasAtMinClaimRate( address contractAddress, address recipient, uint256 minClaimRateBips ) external returns (uint256); ``` This helper allows you to claim the maximum amount of gas fees while guaranteeing a specific claim rate. If you're comfortable with an 80% claim rate, that translates to 8000 bips, so you would call `claimGasAtMinClaimRate(contractAddress, recipient, 8000)`. Calling this function with a 100% min claim rate is the same as calling `claimMaxGas`. # How Gas Fees Are Allocated The gas fees spent on Blast transactions can be broken up into three components: L1 data availability fees, L2 base fees, and L2 priority fees. The L1 data availability fee ensures that other nodes can trustlessly recover the state of the Blast L2, and it gets burned on the Ethereum L1. The L2 base and priority fees ("sequencer fees") however either go to the sequencer operator or to the smart contracts that caused the gas to be spent. Blast allocates sequencer fees to contracts based on the amount of gas that contract consumed in the transaction. This means that contracts that make nested calls to other smart contracts will get a proportional amount of the total gas fees spent on the transation, not the total amount. In cases where `delegatecall` is used, gas fees are allocated to the contract that initiated the `delegatecall` and not the target contract where the implementation logic lives. ### Example: Nested Calls To further demonstrate how gas fees are allocated across nested calls, consider the following example: * Contract A (30,000 gas) * Contract B (50,000 gas) * Contract C (20,000 gas) * Contract A (30,000 gas) * Contract D (40,000 gas) Suppose that only contracts A and D have set their Gas Mode to claimable. In this sample transaction, contract A would be allocated 30,000 + 30,000 = 60,000 gas worth of fees, and contract D would be allocated 40,000 gas worth of fees. The gas spent on contracts B and C, 50,000 + 20,000 = 70,000, would be allocated to the sequencer operator. ### Example: Proxy / Delegatecall Now, suppose that contract D is a proxy contract that forwards calls via `delegatecall` to an implementation contract, contract E. * Contract A (30,000 gas) * Contract B (50,000 gas) * Contract C (20,000 gas) * Contract A (30,000 gas) * (Proxy) Contract D (1,000 gas) * `delegatecall` Contract E (39,000 gas) In this modified example, contract D will still be allocated 1,000 + 39,000 = 40,000 gas worth of fees because the execution of contract E's code happens within the context of contract D. ### Calculating Claimable ETH To determine the maximum amount of ETH that contract A would be able to claim from the examples above, you need to multiply the gas amount by the gas price. If the gas price for this transaction was 15 gwei (10 gwei base + 5 gwei priority), then the ETH amount contract A would be able to claim a maxiumum of 60,000 gas \* 15 gwei/gas = 0.0009 ETH. # How Gas Fees and Claim Rates Are Tracked This section contains low level details on how the Blast Gas contract works. You don't need to read or understand this section to configure your contracts or claim your gas, but if you're interested in a optimizing your integration, or just a bit curious, read on. The Blast Gas contract keeps track of the integral of your contract's unclaimed fees over time. If you had 1 ETH of unclaimed fees for 1 day, the resulting integral would be 1 ether-day. If you instead had 2 ETH of unclaimed fees for 1 week, then the integral would be 14 ether-days. To make this integration process clear, let's build on top of this second scenario. If you suddenly accumulated 1 additional ETH of fees, your contract's unclaimed fee balance would be 3 ETH, but the integral would still be 14 ether-days. If you waited 1 more day, then the integral would be 17 ether-days. The Blast Gas contract uses this integral to determine the effective maturity of your unclaimed fee balance. ## Blast Gas Claim Parameters There are five parameters that determine how your contract's accumulated ether-days relates to your claim rate: * `zeroClaimRate`: your claim rate immediately after earning gas fees * `baseGasSeconds`: the number of seconds your gas fees need to mature to receive the `baseClaimRate` * `ceilGasSeconds`: the number of seconds your gas fees need to mature to receive the `ceilClaimRate` Represented visually, this looks like: Abstract gas parameters The intended mainnet parameters look like this: Abstract gas parameters ## Custom Gas Fee Claims The following function is the lowest level claim helper. It allows you to specify exactly how much ETH you'd like to claim and how many ether-seconds you'd like to use to contribute to your claim rate. ```solidity function claimGas( address contractAddress, address recipient, uint256 etherToClaim, uint256 etherSecondsToConsume ) external returns (uint256); ``` Claiming 1 ETH at the `ceilClaimRate` requires `ceilGasSeconds` ether-seconds. Providing fewer `ceilGasSeconds` than this would result in an effective claim rate less than the `ceilClaimRate`, based on the `zeroClaimRate` and `baseClaimRate` parameters. # IBlast Interface In the interface below, when you see a function like `configureX` with corresponding `configureXOnBehalf` version, the difference is that `configureX` configures the caller and `configureXOnBehalf` configures the contract corresponding to the `contractAddress` parameter. ```solidity enum YieldMode { AUTOMATIC, VOID, CLAIMABLE } enum GasMode { VOID, CLAIMABLE } interface IBlast { // configure function configureContract(address contractAddress, YieldMode _yield, GasMode gasMode, address governor) external; function configure(YieldMode _yield, GasMode gasMode, address governor) external; // base configuration options function configureClaimableYield() external; function configureClaimableYieldOnBehalf(address contractAddress) external; function configureAutomaticYield() external; function configureAutomaticYieldOnBehalf(address contractAddress) external; function configureVoidYield() external; function configureVoidYieldOnBehalf(address contractAddress) external; function configureClaimableGas() external; function configureClaimableGasOnBehalf(address contractAddress) external; function configureVoidGas() external; function configureVoidGasOnBehalf(address contractAddress) external; function configureGovernor(address _governor) external; function configureGovernorOnBehalf(address _newGovernor, address contractAddress) external; // claim yield function claimYield(address contractAddress, address recipientOfYield, uint256 amount) external returns (uint256); function claimAllYield(address contractAddress, address recipientOfYield) external returns (uint256); // claim gas function claimAllGas(address contractAddress, address recipientOfGas) external returns (uint256); function claimGasAtMinClaimRate(address contractAddress, address recipientOfGas, uint256 minClaimRateBips) external returns (uint256); function claimMaxGas(address contractAddress, address recipientOfGas) external returns (uint256); function claimGas(address contractAddress, address recipientOfGas, uint256 gasToClaim, uint256 gasSecondsToConsume) external returns (uint256); // read functions function readClaimableYield(address contractAddress) external view returns (uint256); function readYieldConfiguration(address contractAddress) external view returns (uint8); function readGasParams(address contractAddress) external view returns (uint256 etherSeconds, uint256 etherBalance, uint256 lastUpdated, GasMode); } ``` # Indexing Account Balances Source: https://metalayerlabs.mintlify.app/building/guides/indexing-balances # Overview If you're building a product that indexes ETH balances on Blast, it's important that you understand how Blast's account model differs from other EVM chains. Instead of representing ETH balances as integer values, Blast represents them in terms of **shares**. Each account has some number of shares associated with it and that number is multiplied by a **global share price** to determine its ETH balance. In this way, Blast account balances are capable of automatically rebasing as new yield is reported and the global share price increases. For the most accurate indexing of account balances, we recommend saving individual account shares along with the global share price instead of saving account balances directly. At read time an account's balance can then be derived by multiplying its shares with the global share price. The rest of this document describes how to accurately index every account's ETH balance on Blast using this method. If you only need to index a small number of account balances and would prefer to avoid this custom indexing logic, you can opt out of rebasing on those accounts (see [yield modes](#yield-modes) below) and index their balances as you would normally. # Yield Modes Blast accounts support three different yield modes, giving the user / builder control over how they want to handle rebasing when new yield is reported: | Yield Mode | Description | | ----------- | ------------------------------------------------------------------------ | | `AUTOMATIC` | ETH balance automatically rebases (increasing only) | | `VOID` |  ETH balance never changes in response to yield; no yield is earned | | `CLAIMABLE` | Yield accumulates separately and can be claimed to any recipient address | ### Defaults By default, all accounts on Blast are set to `AUTOMATIC` yield mode, which means their ETH balances will rebase automatically. However, when a smart contract is deployed to an address, the account is switched to `VOID` mode. In practice, this means that smart contract accounts default to `VOID` mode and EOAs default to `AUTOMATIC` mode. We say "in practice" because it is possible (but very uncommon) for ETH to be held by an account before a smart contract is deployed to it. Both smart contracts and EOAs can change their yield modes (e.g. a smart contract opting in or an EOA opting out) using the [Blast yield predeploy](https://blastscan.io/address/0x4300000000000000000000000000000000000002) at address  `0x4300000000000000000000000000000000000002`. See our article on [Receiving and claiming ETH Yield](/building/guides/eth-yield) for details. ## Blast's Account Model Blast uses a modified version of `op-geth` (`blast-geth`) to represent balances in terms of shares and enable all accounts to update as yield is reported. More specifically, `blast-geth` modifies the underlying `StateAccount` struct that represents account state to accomplish this: ```diff type StateAccount struct { Nonce uint64 Root common.Hash CodeHash []byte - Balance *big.Int } ``` ```diff type StateAccount struct { Nonce uint64 Root common.Hash CodeHash []byte + Flags uint8 + Fixed *big.Int + Shares *big.Int + Remainder *big.Int } ``` The desired yield mode is stored in the `Flags` field and the `Fixed`, `Shares`, and `Remainder` fields store the data required to calculate account balances in each of the three yield modes as follows: In `AUTOMATIC` mode, balances increase automatically as yield is reported to the L2: ```solidity balance = account.shares * sharePrice + account.remainder claimable = 0 ``` In this mode, `account.remainder` will be a dusty value to enable wei-level precision. It will always be the case that `account.remainder < sharePrice` (otherwise, `account.shares` would just be higher). In `VOID` mode, the balance remains static and no yield can be claimed: ```solidity balance = account.fixed claimable = 0 ``` In `CLAIMABLE` mode, yield accumulates separately from the account's balance and can be claimed to any recipient address any point by the account's [governor](/building/guides/eth-yield#governor). In this case the balance would be: ```solidity balance = account.fixed claimable = account.shares * sharePrice + account.remainder - account.fixed ``` The `claimable` value refers to yield that this account can claim. There is no `Transfer` event emitted when yield is claimed which can sometimes lead to confusion. While modifying the type of the state trie is a significant change, there is no difference from the perspective of a single transaction; Blast's `BALANCE` opcode behaves the same as it normally does, so smart contracts don't need to consider their account's shares. To remain EVM compatible, Blast's share system guarantees wei-level precision, allowing accounts with rebasing balances to transfer precise amounts of wei to accounts with non-rebasing balances and vice versa. # Global Share Price The global share price that determines how much ETH each share is worth is stored in the [SharesBase](https://blastscan.io/address/0x4300000000000000000000000000000000000000#readProxyContract) predeploy at address `0x4300000000000000000000000000000000000000`. This contract tracks the share price, the total number of shares, and the total amount of ETH that has yet to be reflected in the share price. You can read the current ETH share price by calling `SharesBase::price()` as demonstrated below using `cast call` or the `eth_call` RPC: ```bash cast call Example cast call 0x4300000000000000000000000000000000000000 "price()(uint256)" \ --block 2097152 --rpc-url https://rpc.blast.io \ | awk '{ printf "%.9f gwei/share\n", $1 / 1e9 }' ``` ```bash eth_call RPC Example curl \ --data '{"id":0,"jsonrpc":"2.0","method":"eth_call","params":[{"from":null,"to":"0x4300000000000000000000000000000000000000","data":"0xa035b1fe"}, "0x200000"]}' \ --header "Content-Type: application/json" https://rpc.blast.io \ --silent | jq '.result' | xargs printf '%0.2f\n' | jq -r '"\(./1e9) gwei/share"' ``` In these examples we pipe the output into `awk` and `jq` for styling purposes to show the units of the return value. You can also index the `NewPrice(uint256 price)` event emitted by this contract to get the new global share price whenever an update occurs. Generally, this update happens every day at midnight UTC, but this schedule is not guaranteed in code and may be subject to change. # Indexing Account Shares As mentioned above, for the most accurate results it is recommended that you index account shares instead of account balances directly. For the most part, this works the same way as indexing balances on ETH mainnet: we first identify which accounts were touched in the transactions within a given block and then re-fetch the balances of those accounts on that block. Usually, these ETH balances are re-fetched using the `eth_getBalance` RPC method, but on Blast we need to be able to read and save the account's `shares` value instead. Blast nodes expose a new RPC method, `eth_getBalanceValues`, to support indexing the `flags`, `shares`, `remainder`, and `fixed` fields for accounts. ### `eth_getBalanceValues` This RPC method exposes the Blast-specific fields of the `StateAccount` struct. #### Request Same as `eth_getBalance` Same as `eth_getBalance`; hex or `“latest”`, `“pending”`, etc Unique request identifier **Request Example** ```bash curl -s -X POST \ -H "Content-Type: application/json" \ --url --data '{ "jsonrpc":"2.0", "method":"eth_getBalanceValues", "params":["0x4200000000000000000000000000000000000000","latest"], "id":1 }' ``` #### Response String representing RPC version number Object containing `fixed`, `flags`, `remainder`, and `shares` Hex number string, e.g. `"0x1"` Hex number string representing one of three [yield modes](#yield-modes):
* `"0x0"`: AUTOMATIC * `"0x1"`: VOID * `"0x2"`: CLAIMABLE
Hex number string, e.g. `"0x1"` Hex number string, e.g. `"0x1"`
Unique request identifier **Response Example** ```bash { "jsonrpc": "2.0", "result": { "fixed": "0x0", "flags": "0x1", "remainder": "0x0", "shares": "0x0" }, "id": 1 } ``` ## Edge Cases On Ethereum mainnet, `selfdestruct` allows ETH to be sent to a beneficiary address without triggering any code at that address. As a result, the beneficiary account's balance changes without there being any `call` made. Indexers must handle this edge case to ensure perfect accounting. Blast introduces a similar edge case that indexers should be aware of. Accounts set to `CLAIMABLE` yield mode can claim accumulated yield to an arbitrary beneficiary address. This claim operation works the same as `selfdestruct` in that it can increase an arbitrary account's balance without a `call`. While this edge case is exceptionally rare and not particularly important to handle, we include it here for completeness. # Advanced Setup Source: https://metalayerlabs.mintlify.app/building/guides/node/advanced Deploying a Blast node follows the same process as other OP Stack-based chains. This document is based on the `master` branch of the [Blast repository](https://github.com/blast-io/blast). This guide is intended for advanced users who want to build Blast from source. If you prefer to use prebuilt Docker images, refer to the [Docker Compose Setup](./basic) documentation. # Initial Setup ### Download Blast `genesis.json` & `rollup.json` In addition to the Blast repository containing `blast-geth` and `blast-optimism`, you will also need to obtain the chain configuration files from the deployment repository. These files contain the essential chain configuration parameters for initializing your Blast node. Ensure you select the correct files based on the network (Mainnet or Sepolia) you want to connect to. This step is crucial for aligning your node with the chosen network’s protocol settings. ```bash git clone git@github.com:blast-io/deployment.git ``` To run a Sepolia node, use the `sepolia-testnet branch` of the Blast repository. The `master` branch is not compatible with the Blast Sepolia testnet. ### Building the Docker Images #### blast-geth ```bash cd blast-geth/ docker build . -t blast-geth ``` #### op-node This step creates a Docker image of the `op-node`, tagged for development use. This image will be used later when running the node. ```bash cd blast-optimism/ # This will build an image with tag: blast.io/blast-optimism/op-node:dev REGISTRY=blast.io REPOSITORY=blast-optimism docker buildx bake --load -f docker-bake.hcl op-node ``` ### Generate the jwt secret ```bash openssl rand -hex 32 | tr -d "\n" > /jwt.txt ``` ### Initialize the blast-geth data directory Use the following command to initialize the data directory. Ensure you have downloaded the appropriate `genesis.json` file. ```bash geth init \ --datadir=$GETH_DATA_DIR \ config/genesis.json ``` # Running ### Set up env vars The sequencer URL and bootnode address must be configured to connect your Blast node to the appropriate peer network and the transaction sequencer. To do this, you will need to expose the sequencer URL and bootnode address environment variables as follows: ```yaml # For Mainnet export GETH_ROLLUP_SEQUENCERHTTP=https://sequencer.blast.io export OP_NODE_P2P_BOOTNODES=enr:-J64QGwHl9uYLfC_cnmxSA6wQH811nkOWJDWjzxqkEUlJoZHWvI66u-BXgVcPCeMUmg0dBpFQAPotFchG67FHJMZ9OSGAY3d6wevgmlkgnY0gmlwhANizeSHb3BzdGFja4Sx_AQAiXNlY3AyNTZrMaECg4pk0cskPAyJ7pOmo9E6RqGBwV-Lex4VS9a3MQvu7PWDdGNwgnZhg3VkcIJ2YQ,enr:-J64QDge2jYBQtcNEpRqmKfci5E5BHAhNBjgv4WSdwH1_wPqbueq2bDj38-TSW8asjy5lJj1Xftui6Or8lnaYFCqCI-GAY3d6wf3gmlkgnY0gmlwhCO2D9yHb3BzdGFja4Sx_AQAiXNlY3AyNTZrMaEDo4aCTq7pCEN8om9U5n_VyWdambGnQhwHNwKc8o-OicaDdGNwgnZhg3VkcIJ2YQ # For Sepolia # export GETH_ROLLUP_SEQUENCERHTTP=https://sequencer.s2.testblast.io # export OP_NODE_P2P_BOOTNODES=enr:-J-4QM3GLUFfKMSJQuP1UvuKQe8DyovE7Eaiit0l6By4zjTodkR4V8NWXJxNmlg8t8rP-Q-wp3jVmeAOml8cjMj__ROGAYznzb_HgmlkgnY0gmlwhA-cZ_eHb3BzdGFja4X947FQAIlzZWNwMjU2azGhAiuDqvB-AsVSRmnnWr6OHfjgY8YfNclFy9p02flKzXnOg3RjcIJ2YYN1ZHCCdmE,enr:-J-4QDCVpByqQ8nFqCS9aHicqwUfXgzFDslvpEyYz19lvkHLIdtcIGp2d4q5dxHdjRNTO6HXCsnIKxUeuZSPcEbyVQCGAYznzz0RgmlkgnY0gmlwhANiQfuHb3BzdGFja4X947FQAIlzZWNwMjU2azGhAy3AtF2Jh_aPdOohg506Hjmtx-fQ1AKmu71C7PfkWAw9g3RjcIJ2YYN1ZHCCdmE ``` ### blast-geth ```bash geth \ --datadir=$GETH_DATA_DIR \ --http \ --http.corsdomain="*" \ --http.vhosts="*" \ --http.addr=0.0.0.0 \ --http.port=$RPC_PORT \ --http.api=web3,debug,eth,txpool,net,engine \ --ws \ --ws.addr=0.0.0.0 \ --ws.port=$WS_PORT \ --ws.origins="*" \ --ws.api=debug,eth,txpool,net,engine \ --authrpc.addr="0.0.0.0" \ --authrpc.port="8551" \ --authrpc.vhosts="*" \ --authrpc.jwtsecret=/jwt.txt \ --syncmode=full \ --gcmode=archive \ --nodiscover \ --maxpeers=0 \ --rollup.disabletxpoolgossip=true --override.canyon=0 --override.ecotone=1716843599 ``` ### op-node ```bash op-node \ --l1=$L1_RPC_URL \ --l1.rpckind=$L1_RPC_KIND \ --l2=ws://blast-geth:8551 \ --l2.jwt-secret=/jwt.txt \ --rollup.config=config/rollup.json --l1.beacon=$L1_BEACON_API_URL ``` To fully participate in P2P, ensure TCP/UDP is allowed on port `9003` and set `--p2p.advertise.ip=$PUBLIC_IP`. Blast Mainnet and Testnet have activated the Ecotone upgrade to benefit from EIP-4844. It's important that you provide a beacon chain API URL (`$L1_BEACON_API_URL`) in addition to the `$L1_RPC_URL` so your node can read blob data. # Upgrades ### Using pre-built docker images 1. First, pull latest code from the [deployment repository](https://github.com/blast-io/deployment). 2. Next, restart the containers with the new Docker image. ```bash docker compose pull --policy=always # restart all of the containers docker compose down docker compose up -d ``` ### Building the docker images from source code 1. Pull the latest code from [https://github.com/blast-io/blast](https://github.com/blast-io/blast) 2. Build new Docker images by following the instructions in the [Building the Docker Images](#building-the-docker-images) section. Ensure your `genesis.json` and `rollup.json` files are up-to-date in case of any changes (e.g., a hard fork timestamp). 3. Restart the `blast-geth` and `op-node` containers as described in the [Running](#running) section. # Additional RPC methods ### eth\_getBalanceValues To facilitate rebasing ETH balances, accounts on Blast store more fields than just balance in the state trie. This RPC method exposes the underlying parameters that control an account's rebasing ETH balance. See our article on [Indexing Account Shares](/building/guides/indexing-balances#indexing-account-shares) for a detailed overview of this RPC method. # Docker Compose Setup Source: https://metalayerlabs.mintlify.app/building/guides/node/basic This guide explains how to deploy a Blast node using `docker compose` with pre-built Docker images. This method is ideal for users who prefer not to build from source and want a straightforward setup. ## Prerequisites Before you begin, ensure that you have [Docker](https://www.docker.com/) and [Docker Compose](https://docs.docker.com/compose/) installed on your machine. You will also need access to a valid L1 RPC endpoint, such as those provided by Alchemy, Infura, or other services. ## Usage Instructions Start by cloning the Blast deployment repository, which contains the necessary Docker Compose configurations: ```bash git clone git@github.com:blast-io/deployment.git cd deployment ``` Copy the .env.example file to .env and configure the following variables: ```bash cp .env.example .env ``` Edit the .env file to set the required variables: * `NETWORK`: Set to `mainnet` or `sepolia` depending on the network you want to connect to. * `GETH_DATA_DIR`: Set the path where you want to store the blockchain data. * `L1_RPC_URL`: Your L1 RPC endpoint URL. * `L1_RPC_KIND`: The type of RPC provider (`alchemy`, `infura`, etc.). * `OP_NODE_L1_BEACON`: Your L1 Beacon api endpoint. Required as of Ecotone upgrade. These variables are essential for configuring the node to connect to the appropriate network and storage locations. Once the environment variables are set, you can start the containers using Docker Compose: ```bash docker compose up -d ``` This command pulls the latest versions of the pre-built Docker images and starts the necessary containers, including `blast-geth` and `op-node`. The `-d` flag runs the containers in detached mode, allowing them to run in the background. To test your node, you can run the following command to query the latest L2 block. ```bash curl -d '{ \ "id":0, "jsonrpc":"2.0", "method":"eth_getBlockByNumber", "params":["latest",false] }' -H "Content-Type: application/json" http://localhost:9545 ``` You will need to wait for your node to fully sync before this command will return the actual latest block. You can monitor the running containers with: ```bash docker compose ps ``` If you need to stop the containers, use: ```bash docker compose down ``` To update to the latest versions of the images, use: ```bash docker compose pull --policy=always docker compose up -d ``` ## Additional Considerations To fully participate in p2p, please ensure TCP/UDP is allowed on port `9003`, and add the argument `--p2p.advertise.ip=` to the `op-node` service in the `docker-compose.yml file.` For more details, refer to the official [Blast deployment repository](https://github.com/blast-io/deployment). # Node Snapshot Source: https://metalayerlabs.mintlify.app/building/guides/node/snapshot This guide explains how to download and use our pre-built node snapshot to stand up a mainnet Blast node as quickly as possible. The snapshot, available at `https://pub-0509dd39c2df4aeda4e82ff320667d97.r2.dev/` is updated weekly to minimize required sync times. Testnet snapshots are not available at this time. ## Usage Instructions First, navigate to your `geth` data directory where the blockchain data is stored: ```bash cd ``` You can download the latest snapshot using `wget`: ``` wget -O geth.tgz https://pub-0509dd39c2df4aeda4e82ff320667d97.r2.dev/$(curl https://pub-0509dd39c2df4aeda4e82ff320667d97.r2.dev/LATEST) ``` Alternatively, for faster download speeds, especially for large files like this snapshot (1.5 TB+), consider using `aria2c`: ``` aria2c --file-allocation=none -c -x 10 -s 10 -o geth.tgz https://pub-0509dd39c2df4aeda4e82ff320667d97.r2.dev/$(curl https://pub-0509dd39c2df4aeda4e82ff320667d97.r2.dev/LATEST) ``` ### About `aria2c` `aria2c` is a lightweight command-line download utility that can significantly speed up large file downloads by splitting the file into multiple segments and downloading them concurrently. Here's what the options example above do: * `--file-allocation=none`: Disables file pre-allocation, allowing the download to start immediately. * `-c`: Resumes an incomplete download. * `-x 10`: Sets the maximum number of connections per server to 10. * `-s 10`: Splits the file into 10 segments, downloading them simultaneously. * `-o geth.tgz`: Renames the output file which may otherwise vary based on the latest version. Once the download is complete, unarchive the snapshot to your geth data directory: ```bash tar -xvzf geth.tgz ``` This command extracts the files to the appropriate directory for your node to use. Finally, (assuming you're using the [Docker Compose setup](./basic)), start your node containers: ```bash cd .. docker compose up -d ``` Your node should now be up and running using the latest blockchain snapshot. ## Getting Help If you run into any issues following the instructions above, please don't hesitate to reach out on our [Developer Discord](https://discord.com/invite/blastdevelopers) for help. # Receive and claim WETH and USDB yield Source: https://metalayerlabs.mintlify.app/building/guides/weth-yield 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. ```solidity enum YieldMode { AUTOMATIC, VOID, CLAIMABLE } 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 ## Testnet 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. ## Mainnet 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 ## Testnet 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](https://book.getfoundry.sh/cast/) to send a mint transaction, but you can also send transactions visually [here](https://sepolia.etherscan.io/address/0x7f11f79DEA8CE904ed0249a23930f2e59b43a385#writeContract): ```bash cast send --rpc-url=https://rpc.sepolia.org \ --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`: ```bash cast call --rpc-url=https://rpc.sepolia.org \ 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. ```bash cast send --rpc-url=https://rpc.sepolia.org \ --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: ```bash cast send --rpc-url=https://rpc.sepolia.org \ --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: ```bash cast call --rpc-url=https://sepolia.blast.io/ \ 0x4200000000000000000000000000000000000022 \ "balanceOf(address) returns (uint256)" $ADDR ``` For reference, the following method allows you to bridge to an alternative address on the L2: ```solidity function bridgeERC20To( address _localToken, address _remoteToken, address to, uint256 _amount, uint32 _minGasLimit, bytes calldata _extraData ) public; ``` ## Mainnet 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`. # Network Information Source: https://metalayerlabs.mintlify.app/building/network-information ## Blast Mainnet | Name | Value | | --------------- | -------------------------------------------- | | Network Name | **Blast Mainnet** | | RPC Endpoint | `https://rpc.blast.io` | | Chain ID | **81457** | | Currency Symbol | **ETH** | | Block Explorer | [https://blastscan.io](https://blastscan.io) | ### Additional Mainnet Public RPC Endpoints 1. `https://blast.din.dev/rpc` 2. `https://blastl2-mainnet.public.blastapi.io` ## Blast Testnet (Sepolia) | Name | Value | | --------------- | ------------------------------------------------------------ | | Network Name | **Blast Sepolia** | | RPC Endpoint | `https://sepolia.blast.io` | | Chain ID | **168587773** | | Currency Symbol | **ETH** | | Block Explorer | [https://sepolia.blastscan.io](https://sepolia.blastscan.io) | ### Additional Testnet Public RPC Endpoints 1. `https://testnet.blast.din.dev/rpc` 2. `https://blastl2-sepolia.public.blastapi.io` # Predeploys & Precompiles Source: https://metalayerlabs.mintlify.app/building/predeploys-and-precompiles Predeployed and precompiled contracts, or simply **predeploys** and **precompiles**, are a special class of contracts at predetermined addresses that come with Blast out-of-the-box without ever having been explicitly deployed by an EOA. These contracts implement core functionalities such as the L2 side of bi-directional message passing between Blast and Ethereum, as well as the bridging logic built on top of it. They are also unique in that Blast's node can interface directly with them to initiate transactions in response to messages received from Ethereum mainnet. In this article, we will identify the differences between predeploys and precompiles, examine how precompiles can cause problems during local development and testing, and provide examples of workarounds for these issues. Predeploys and precompiles are not unique to Blast. Most of Blast’s precompiles are common across all EVM chains, and most of its predeploys are common to all OP Stack chains. # Predeploys Predeploys are smart contracts with bytecode deployed to predetermined addresses at genesis. You can identify a predeploy by its common addressing pattern: * `0x4200...0000` - Predeploys shared with other OP Stack chains * `0x4300...0000` - Predeploys unique to Blast You can find a complete listing of Blast’s predeploys [here](https://github.com/blast-io/blast/blob/706acdde2b3a6614a9a7dbfceb82660789d5e7b8/blast-optimism/packages/contracts-bedrock/src/libraries/Predeploys.sol#L4). # Precompiles Precompiles are accessed at predetermined addresses but are implemented directly within the execution client. As a result, **there is no bytecode deployed to precompile addresses**. For example, when calls are made to Blast's `Yield` contract at `0x0000...0100`, Blast's execution client (Blast Geth) uses [an internal Go implementation](https://github.com/blast-io/blast/blob/706acdde2b3a6614a9a7dbfceb82660789d5e7b8/blast-geth/core/vm/contracts.go#L1182C1-L1303) for execution rather than any bytecode deployed at that address. # Local Development ## The Problem When running scripts or tests on a forked execution environment, the chain state—including the bytecode of existing contracts—is copied into the testing environment. Interacting with predeploys when forking Blast is generally not an issue since their bytecode is copied over like any other contract. However, because precompiles lack bytecode at their addresses, any attempts to interact with them will revert. New Blast builders often encounter this issue during fork tests or when deploying contracts that [configure or claim native ETH yield](/building/guides/eth-yield), as these operations [interact with Blast's `Yield` precompile](https://github.com/blast-io/blast/blob/706acdde2b3a6614a9a7dbfceb82660789d5e7b8/blast-optimism/packages/contracts-bedrock/src/L2/Blast.sol#L105-L114). ```shell Ran 1 test for test/Blast.t.sol:MyBlastTest [FAIL. Reason: setup failed: EvmError: Revert] setUp() (gas: 0) Traces: [45933] MyBlastTest::setUp() ├─ [13601] → new @0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f │ ├─ [10701] 0x4300000000000000000000000000000000000002::configureClaimableYield() │ │ ├─ [5690] 0xc0D3C0d3c0d3C0d3c0D3c0D3C0D3C0D3C3d30002::configureClaimableYield() [delegatecall] │ │ │ ├─ [0] 0x0000000000000000000000000000000000000100::configure(0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f, 2) │ │ │ │ └─ ← [Stop] │ │ │ └─ ← [Revert] EvmError: Revert │ │ └─ ← [Revert] EvmError: Revert │ └─ ← [Revert] 0 bytes of code └─ ← [Revert] EvmError: Revert Suite result: FAILED. 0 passed; 1 failed; 0 skipped; finished in 1.35s (0.00ns CPU time) ``` ## Workaround The current workaround for this issue is to deploy a mock version of the `Yield` predeploy to `0x0000000000000000000000000000000000000100` within the local environment. This `YieldMock` contract doesn't need to fully implement the `Yield` precompile; it simply needs to satisfy the `IYield` interface so that calls to it do not revert. The following is an example of a minimal YieldMock contract that satisfies the `IYield` interface. ```solidity interface IYield { function configure(address contractAddress, uint8 flags) external returns (uint256); function claim(address contractAddress, address recipientOfYield, uint256 desiredAmount) external returns (uint256); function getClaimableAmount(address contractAddress) external view returns (uint256); function getConfiguration(address contractAddress) external view returns (uint8); } contract YieldMock is IYield { mapping(address => uint8) public getConfiguration; function configure(address contractAddress, uint8 flags) external returns (uint256) { return 0; } function claim(address, address, uint256) external pure returns (uint256) { return 0; } function getClaimableAmount(address) external pure returns (uint256) { return 0; } } ``` ### Foundry Using Foundry, you can deploy bytecode to an arbitrary address using the [`vm.etch` cheatcode](https://book.getfoundry.sh/cheatcodes/etch#using-vmetch-for-enabling-custom-precompiles). ```solidity address constant YIELD_CONTRACT = 0x0000000000000000000000000000000000000100; // 1. Deploy an instance of `YieldMock` as you would any other contract. YieldMock yieldMock = new YieldMock(); // 2. Cache the bytecode that was just deployed. bytes memory code = address(yieldMock).code; // 3. Use `vm.etch` to set the bytecode at `YIELD_CONTRACT` vm.etch(YIELD_CONTRACT, code); ``` This method works for both testing and running scripts against Blast. This issue occurs when using `forge script`, because Foundry attempts local and forked simulations before broadcasting any transactions. The `--skip-simulation` flag can be used to opt out of forked simulations, but local simulation cannot be skipped. When using `vm.etch` with `forge script`, ensure that you are not calling `vm.etch` in any code that will be broadcasted. ### Hardhat Builders using Hardhat can use the same approach with the Hardhat node's [`hardhat_setCode` RPC method](https://hardhat.org/hardhat-network/docs/reference#hardhat_setcode). Just like `vm.etch`, this method allows us to set the bytecode at an arbitrary address. ```typescript const YIELD_CONTRACT = "0x0000000000000000000000000000000000000100"; // 1. Deploy an instance of `YieldMock` as you would any other contract. const YieldMock = await hre.ethers.getContractFactory("YieldMock"); const yieldMock = await YieldMock.deploy(); // 2. Cache the bytecode that was just deployed. const code = await hre.ethers.provider.getCode(await yieldMock.getAddress()) // 3. Use `hardhat_setCode` to set the bytecode at `YIELD_CONTRACT` // YIELD_CONTRACT = 0x0000000000000000000000000000000000000100 await hre.ethers.provider.send("hardhat_setCode", [YIELD_CONTRACT, code]); ``` # Transaction Finality Source: https://metalayerlabs.mintlify.app/building/transaction-finality The status of transactions on Blast varies based on where they are in the process of being included in the blockchain. # Pending **Instant after being sent to Sequencer** Right after being sent to the Sequencer, a transaction is categorized as "pending" until it gets included in a block. This initial status indicates that the transaction hasn't become part of the blockchain yet, and there's no assurance of its inclusion. To obtain a list of all pending transactions, you can use the standard JSON-RPC method `eth_getBlockByNumber` with the block number parameter set to `pending`. # Sequencer Confirmed / Unsafe **Typically within 2-4 seconds** A transaction is labeled as "sequencer confirmed" or "unsafe" once it's been included in a block by the Sequencer, but that block hasn't been published to Ethereum yet. Despite being in a block, there's still a chance for the transaction to be excluded from the final blockchain if the Sequencer doesn't publish the block promptly. Applications should be mindful of this possibility when presenting information about transactions in this state. To obtain the latest "sequencer confirmed" block, use the standard JSON-RPC method `eth_getBlockByNumber` with the block number parameter set to `safe`. Compare this with the result returned for the `latest` block. If the `safe` block lags behind the `latest` block, the earliest "sequencer confirmed" block is the `safe` block plus one. # Published to Ethereum / Safe **Typically within 5-10 minutes, up to 24 hours** A transaction is deemed "safe" when it has been included in a block by the Sequencer, and that block has been published to Ethereum, but that block is not yet finalized. Once a block is published to Ethereum, there is a high likelihood of it being included in the final blockchain. However, there is still a possibility of a re-org. To get the latest "safe" block, use the standard JSON-RPC method `eth_getBlockByNumber` with the block number parameter set to `safe`. Transactions usually become "safe" status within a few minutes of being "sequencer confirmed." # Finalized **Typically within 15-20 minutes, up to 24 hours** A transaction is "finalized" when it has been included in a block by the Sequencer, that block has been published to Ethereum, and that block has been finalized. The latest "finalized" block can be retrieved by calling the standard JSON-RPC method `eth_getBlockByNumber` with the parameter `finalized` as the block number. # Governance Source: https://metalayerlabs.mintlify.app/governance # Bylaws ### 1. Bylaws Adopted These bylaws are adopted on the June 25, 2024 (the “**Effective Date**” pursuant to a directors' resolution by the directors of the Blast Foundation (the “**Foundation**”) in accordance with the Foundation Articles. Capitalized terms used but not otherwise defined herein shall have the meanings ascribed to such terms in the Foundation Articles. ### 2. Governance Tools Tokenholders have certain tools at their disposal to encourage the proposal, discussion, and participation in the Blast Network and Foundation governance. The following are the governance tools available to Tokenholders and other Blast Network participants at the time of the adoption of these Bylaws. Note that these governance tools may change over time as Blast Network and Foundation governance evolves, and any such updates will be communicated through the Foundation’s publicly available channels of communication: * Proof of Wealth (“**POW**”) is a mobile application available on [Blast Mobile](mobile/overview) where Blast community members can present, review, and discuss governance proposals through posts and live chat. * [Blast Foundation Proposal Template](#blip-template) provides Tokenholders with a template to craft governance proposals in accordance with these Bylaws (the “**BLIP Template**”). * Blast Foundation Snapshot available at [https://snapshot.org/#/blastfoundation.eth](https://snapshot.org/#/blastfoundation.eth) (the “**Foundation Snapshot**”) allows Tokenholders to vote on governance proposals. ### 3. Definitions
  1. **“BLIP”** means a Blast Improvement Proposal, which is a proposal put forth by a Tokenholder to a vote by all Tokenholders in accordance with the BLIP Process.
  2. **“BLIP Process”** means the rules and procedures of submitting and voting on BLIPs as described in Section 5 and Section 6, as applicable, herein.
  3. **“Blast Network”** or **“Blast”** means the series of smart contracts that create the layer-two blockchain scaling solution known as **“Blast”** (the **“Layer-Two Network”**) and permits users to transact on the Layer-Two Network, including, but not limited to, bridge to and from Ethereum mainnet to the Layer-Two Network.
  4. **"Bylaws"** means these bylaws of the Foundation as may be amended from time to time in accordance with the Foundation Articles.
  5. **"Cayman Law"** means the rules, regulations and laws of the Cayman Islands, including as they are modified, from time to time.
  6. **“Foundation Articles”** means the Memorandum and Articles of Association of the Foundation (as may be amended from time to time).
  7. **"Foundation Director(s)"** means the director(s) of the Foundation, which have certain powers and duties pursuant to Cayman Law and as further described in the Foundation Articles.
  8. **"Foundation Supervisor"** means the supervisor of the Foundation, which has certain powers and duties pursuant to Cayman Law and as further described in the Foundation Articles.
  9. **“Moderator(s)”** means an individual(s) engaged by the Foundation to, among other things, assist with the governance processes set forth herein.
  10. **“Quorum Requirements”** means at least six billion (6,000,000,000) Tokens are cast in the applicable vote.
  11. **“Token”** means the native token governing the Blast Network, known as \$BLAST and as identified by the following smart contract address on the Blast Network: [0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad](https://blastscan.io/token/0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad).
  12. **“Tokenholder(s)”** means the holder(s) of the Token from time to time, or individuals who have been delegated Tokens, as evidenced by the Blast Network.
### 4. Tokenholder BLIP Categories Pursuant to these Bylaws, Tokenholders may propose, and vote on BLIPs subject to, and in accordance with, the BLIP Process to: * Make adjustments to the following parameters of the Blast Network: * General risk management frameworks. * USDB-backing composition. * ETH liquid staking providers. * Fees on ETH yield. * Fees on USDB yield. * Gas fee accrual. * Creation of a reserve fund. * Yield distribution allocation between ETH, USDB and the reserve fund. * Appoint and remove members of the Progress Council. * Increase the number of members of the Progress Council. * Make changes to the inflation adjustment, provided however, that no such changes shall take effect on the date prior to the date that is four (4) years from the date of the public launch of the Token. * Consent to any proposed changes to the Foundation's Articles which only to the extent that such proposed changes adversely affect in a material way the rights or powers conferred on the Tokenholders under the Foundation's Articles. * Consent to any proposed changes to these Bylaws only to the extent that such proposed changes which adversely affect in a material way the rights or powers conferred on the Tokenholders under these Bylaws. * Approve any other action in accordance with successful BLIPs. The results of any Tokenholder votes and the approval of any BLIPs shall be taken under advisement by the Foundation so long as they fall within the Foundation’s power to effectuate the same, provided that the Foundation shall not be obligated to effectuate the results of the same. Tokenholders are encouraged to submit proposals, send and seek feedback, and fine-tune proposals prior to ultimate submission in accordance with the requirements and procedures described in Section 6 herein. ### 5. Tokenholder BLIPs Any Tokenholder who wishes to submit a BLIP for Foundation consideration is required to comply with the following:
  1. *Phase One - Research and Community Feedback*
    1. Any Tokenholder who wishes to submit a BLIP (“**Tokenholder BLIP**”) to the Foundation shall first post a draft of the proposed TBLIP on POW for review by the Blast community. The draft TBLIP should be reviewed and discussed by the Blast community for a period of no less than seven (7) calendar days (the “**Community Feedback Period**”). The TBLIP shall be in the form of the BLIP Template.
  2. *Phase Two - Progress Council Review*
    1. After the expiration of the Community Feedback Period, the Tokenholder shall (1) update the draft TBLIP as necessary to incorporate community feedback and (2) post the draft TBLIP for Progress Council review via POW. The Progress Council will review Submitted TBLIPs every other Friday. TBLIPs submitted by Tokenholders who are delegated less than 2,000,000 Tokens will not be considered by the Progress Council.
    2. In reviewing Submitted TBLIPs, the Progress Council may (1) allow the Submitted TBLIP to progress to Phase Three; (2) direct the Tokenholder(s) who submitted the TBLIP to provide additional information or update the Submitted TBLIP; or (3) reject the Submitted TBLIP in accordance with the following paragraph. These decisions will be communicated in discussions on POW.
    3. The Progress Council may choose to reject the Submitted TBLIP if, in consultation with legal counsel, it is determined that the Submitted TBLIP is not safe, not secure, or not consistent with the purposes of the Foundation or may not be capable of being implemented in a legally compliant manner. For the Progress Council to successfully veto a Submitted TBLIP, a majority of the members of the Progress Council must vote in favor of the veto.
  3. *Phase Three - Snapshot Voting*
    1. After review and approval of the Submitted TBLIP by the Progress Council, the Submitted TBLIP will be added to the Foundation Snapshot, at which point the Submitted TBLIP becomes a “**Live BLIP**.”
    2. Once live on Snapshot, the Live BLIP will be open to voting until the voting period closes, which is seven (7) calendar days later (the “**Voting Period**”). To confirm that each Tokenholder BLIP has gone through the appropriate approval processes set forth herein, Moderators are the only persons who can post Submitted TBLIPs to the Snapshot.
    3. One (1) Token is equal to one (1) vote on any Live BLIP. The voting options for any Live BLIP shall be “**In favor**,” “**Against**,” and “**Abstain**.”
    4. Live BLIPs that (1) satisfy the Quorum Requirements and (2) receive a majority of the votes cast in favor of it shall be considered to be “**Approved Tokenholder BLIPs**.” A Live BLIP that either (i) does not meet the Quorum Requirements or (ii) meets the Quorum Requirements but fails to receive a majority of votes cast in favor of it shall be considered a “**Failed Tokenholder BLIP**”.
    5. Approved Tokenholder BLIPs will move to Phase 4. Failed Tokenholder BLIPs may be resubmitted for Foundation consideration only after sixty (60) days have elapsed from the date the Tokenholder BLIP was considered to be a Failed Tokenholder BLIP.
  4. *Phase Four - Implementation*
    1. Subject to Section (ii) below, Approved Tokenholder BLIPs shall be taken under advisement by the Foundation and so long as they fall within the Foundation’s power to effectuate, shall be considered for implementation by the Foundation in a commercially reasonable time and manner.
    2. If, following the approval of a BLIP by the Tokenholders in accordance with the BLIP Process, a majority of the Foundation Director(s) acting in the best interests of the Foundation reasonably determine(s) that such BLIP, if implemented, would:
      1. Compromise the Foundation Director(s’) fiduciary duties as they are owed to the Foundation.
      2. Be in violation of any part of these Bylaws or the Foundation Articles, the BLIP Process, any statutory requirements of Cayman Law or the laws or regulations of any other applicable jurisdiction.
      3. Cause the Foundation to be in breach of any contracts, agreements or any other arrangements.
      4. Be against the best interests of the Foundation or the Blast Network.
      Such Foundation Director(s) may direct the Progress Council to take such other steps as are required to amend, augment, reject or remediate the enactment of such BLIP.
### 6. Progress Council BLIPs Any member of the Progress Council who wishes to submit a BLIP for Foundation consideration shall comply with the following:
  1. *Phase One - Progress Council Review and Vote*
    1. Any member of the Progress Council can submit a BLIP (a “**Progress Council BLIP**”) to the other members of the Progress Council by posting in POW. The Progress Council BLIP shall be in the form of the BLIP Template.
    2. Within seven (7) calendar days of the Progress Council BLIP being posted, the Progress Council shall review and vote on it. A majority of the members of the Progress Council are required to vote in favor of the Progress Council BLIP for it to be approved (an “**Approved Progress Council BLIP**”).
    3. In the event there are less than five (5) members on the Progress Council at any time, any Progress Council BLIP shall require at least a majority of the seats then filled to vote in favor to become an Approved Progress Council BLIP. In the event there is a tie, the Progress Council BLIP may be approved by the Foundation Director(s) in which case it shall move to Phase Two, immediately below.
  2. *Phase Two - Tokenholder Veto*
    1. Within three (3) calendar days of passing an Approved Progress Council BLIP, a Moderator shall post the Approved Progress Council BLIP on the Foundation Snapshot with the “**veto**” option. If (i) the Quorum Requirements on the applicable veto vote are satisfied and (ii) more than a majority of the votes cast are in favor of vetoing the Approved Progress Council BLIP, the proposal will not be enacted. The veto period shall be seven (7) calendar days from the posting of the Approved Progress Council BLIP (the “**Veto Period**”).
  3. *Phase Three - Implementation*
    1. Subject to Section (ii) below, Approved Progress Council BLIPs that have not otherwise been vetoed during the Veto Period will be implemented by the Foundation in a commercially reasonable time and manner.
    2. If, following the approval of a BLIP by the Progress Council in accordance with the BLIP Process, a majority of the Foundation Director(s) acting in the best interests of the Foundation reasonably determine(s) that such BLIP, if implemented, would:
      1. Compromise the Foundation Director(s’) fiduciary duties as they are owed to the Foundation.
      2. Be in violation of any part of the Governance Documentation, the BLIP Process, any statutory requirements of Cayman Law or the laws or regulations of any other applicable jurisdiction.
      3. Cause the Foundation to be in breach of any contracts, agreements or any other arrangements.
      4. Be against the best interests of the Foundation or the Blast.
      Such Foundation Director(s) may take such other steps as are required to amend, augment, reject or remediate the enactment of such BLIP.
### 7. Progress Council
  1. The Progress Council (the “**Progress Council**”) is tasked with serving as a steward for the Tokenholders and for providing oversight of the Foundation on behalf of the Tokenholders.
  2. Initially, the Progress Council shall be made-up of five (5) seats. Those seats will initially be filled by five (5) individuals appointed by the Foundation Director(s). At all times, one (1) seat shall be filled by an individual appointed by the Foundation Director(s) to serve as a representative of the Foundation (the “**Foundation Nominee**” and the other members, the “**Tokenholder Nominees**”).
  3. The Blast Foundation Progress Council members are each paid \$50,000, on an annual basis. The Blast Foundation feels that this amount represents a fair fee for the time and dedication that each member is providing to the Blast Foundation and the Blast ecosystem.
  4. Tokenholders may vote to remove a Tokenholder Nominee through, and subject to, the BLIP Process outlined in Section 5 herein. If, at any time, one or several Tokenholder Nominee members are removed in accordance with this Section 7(d), such that a vacancy exists on the Progress Council, the Foundation Director(s) shall, acting in the best interests of the Foundation, have the authority to nominate and appoint replacement members to the Progress Council who shall serve as Tokenholder Nominees until such time as they resign or are otherwise removed by Tokenholders subject to a BLIP.
  5. Members of the Progress Council may resign at any time by providing written notice to the Foundation Director(s). In such an event, the remaining members of the Progress Council shall identify an individual to fill the vacant seat and then shall put forth a Progress Council BLIP (in accordance with Section 6) nominating such individual.
  6. If no Tokenholder BLIP is made to nominate a new Progress Council member, or to remove an existing Progress Council member, then the existing Progress Council members shall continue their service until such time as they resign or are removed or voted out by the Tokenholders pursuant to the BLIP Process.
  7. All members of the Progress Council will be required to pass a screening process before being added to the Progress Council. This process may include KYC/AML obligations, sanctions screening or other obligations as may be required under Cayman Law from time to time, and a requirement that the member sign a standard contract, which will be implemented at the discretion of the Foundation.
### 8. Safety Committee
  1. The Safety Committee is a committee of five (5) members who appointed by the Foundation Directors and who are signers of a multi-sig wallet, which has powers to perform certain Emergency Actions as set forth herein (the “**Safety Committee**”).
  2. The Safety Committee has the power to (i) execute any software upgrade or perform other required actions with no delay in order to respond to a security emergency, should one arise without specific governance approvals or (ii) veto any Approved Tokenholder BLIP or Approved Progress Council BLIP (such actions, "**Emergency Actions**"). Performing any Emergency Action requires a majority approval from the Safety Committee. The Safety Committee must not use its power to perform Emergency Actions except in a true security emergency, such as a critical vulnerability.
  3. After performing any Emergency Action, the Safety Committee shall in reasonable time and course, depending on the facts and circumstances of the Emergency Action, including the time that has elapsed, and in reasonable consultation with Foundation’s legal counsel, issue a transparency report to explain what actions were taken and why such Emergency Action was justified.
  4. The Foundation Director(s), in consultation with Foundation’s legal counsel, are able to curtail or eliminate the Safety Committee’s power to perform Emergency Actions.
### 9. Governance Administration
  1. The Foundation will facilitate the administration of the governance procedures described in these Bylaws with the aim of ensuring that the Tokenholders may participate thoughtfully in governance. Such administrative services may include:
    1. Moderation of governance proposals to ensure they are validly submitted and voted upon.
    2. Removal of proposals that reasonably appear to be fraudulent, spam-oriented, defamatory, hateful, or otherwise inappropriate or inconsistent with the values of the Foundation.
    3. Monitoring of votes, voting power, and voting periods for purposes of determining whether quorums and approval thresholds are met or accurately reflected;
    4. Management of mutually contradictory proposals that are submitted simultaneously or in close proximity to one another.
    5. Administration of network maintenance, such as emergency bug fixes or release rollbacks (with or without a governance vote).
    6. Such other things as the Foundation deems appropriate in connection with the above.
  2. Subject to applicable law, the Foundation Articles and these Bylaws, the Foundation Director(s) will take any Approved Tokenholder BLIP or Approved Progress Council BLIP under advisement and, to the extent they desire to adopt such vote, are authorized to take any actions reasonably necessary on behalf of the Foundation to give effect to an Approved Tokenholder BLIP or Approved Progress Council BLIP including passing any director resolutions to memorialize such Approved Tokenholder BLIP or Approved Progress Council BLIP; provided that any Foundation Director may veto a proposal or place such limitations on its observation and implementation a Foundation Director in its discretion, deems necessary or appropriate to:
    1. Ensure compliance with any applicable law or regulation of any jurisdiction.
    2. Ensure that the Foundation acts in accordance with the Foundation Articles and these Bylaws.
    3. To prevent any harm (including reputational harm) to the Foundation.
### 10. Blast Foundation & Contributors
  1. The Tokenholders are represented by the Foundation, which represent the Tokenholders' interests in connection with contractual and legal processes, including regulatory compliance and those other matters set forth in the Foundation Articles.
  2. The Blast Foundation has engaged with certain third parties to provide services as the Foundation Director(s), as required by Cayman Law. In accordance with the terms of the Foundation Articles and these Bylaws, and subject to Cayman Law, the Foundation Director(s) are required to take input for the Tokenholders in respect of certain matters.
  3. The Tokenholders have the authority to propose certain decisions in relation to the Foundation as set forth in these Bylaws and the Foundation Articles.
  4. The Foundation Director(s) are authorized to take any actions reasonably necessary on behalf of the Foundation to give effect to a vote of the Tokenholders including passing any director resolutions to memorialize such vote.
  5. To the extent there is ever a conflict between the provisions of the Bylaws and/or the Foundation Articles, the Foundation Articles will prevail in respect to the provisions of the Bylaws.
### 11. Dispute Resolution
  1. Should a controversy, dispute or claim arise out of or in relation to these Bylaws ("**Dispute**"), the Foundation, the Foundation Director(s), the Progress Council and/or the Foundation Supervisor (as appropriate) must give thirty (30) days' notice of such Dispute to the relevant party/ies (the "**Notice of Dispute**"). Should the Dispute not be resolved at the expiration of thirty (30) days after service of the Notice of Dispute, the relevant party may commence arbitration proceedings in accordance with Section 2(b) of these Bylaws. In any dispute involving the actions of the Foundation Director(s), the Foundation Supervisor may commence arbitration proceedings against the Foundation Director(s) in accordance with this Section 2. For the avoidance of doubt, this Section 2 does not provide Tokenholders with a right of action against the Foundation or the Foundation Director(s).
  2. Should the Dispute remain at the expiration of thirty (30) days after service of the Notice of Dispute, the Dispute shall be settled by arbitration administered by the International Centre for Dispute Resolution in accordance with its International Arbitration Rules (the "Rules"). The arbitration shall be seated in George Town, Grand Cayman and governed by Cayman Law. The language of the arbitration shall be English. The arbitration shall be determined by a sole arbitrator to be appointed in accordance with the Rules. Any award or decision made by the arbitrator shall be in writing and shall be final and binding on the parties without any right of appeal, and judgment upon any award thus obtained may be entered in or enforced by any court having jurisdiction thereof. No action at law or in equity based upon any claim arising out of or related to these Bylaws shall be instituted in any court of any jurisdiction.
# BLIP Template | Proposal Title | BLIP - Proposal Title | | --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Proposal Type** | Governance proposals must fall under one of the categories set forth in Section 4 of the Blast Foundation’s Governance Bylaws. | | **Executive Summary** | This section should include a short summary of the BLIP, the impacted stakeholders and the expected outcomes. | | **Motivation** | This should explain why you are submitting the proposal and why the Blast community should adopt and implement the BLIP. | | **Proposal Details** | Please include a comprehensive description of the proposed changes, including any relevant code changes and associated audits (see “code changes” under Additional Guidelines below). | | **Implementation** | Please include all details on how you expect the proposal to be implemented, including anticipated timing, contingency plans, milestones and targeted completion dates. | | **Associated Costs** | The total anticipated costs to implement the BLIP. This section should include a breakdown of the total cost of the BLIP. Consider both fixed costs and recurring costs. | | **Prior Proposals** | See “Prior Proposals” under Additional Guidelines below. | # Additional Guidelines ### True and Complete By submitting a BLIP, you represent and warrant to the Progress Council and the Blast Foundation that all the information it contains is true and complete to the best of your knowledge. ### Prior Proposals Sometimes, BLIPs aren't passed on their initial submissions. If a BLIP is not passed, the proposer may resubmit the BLIP after sixty (60) days and should address the concerns of the community. The proposer should include the following additional sections in the resubmitted BLIP: * **A link to the previous BLIP** - The link to the previous BLIP should be included in the resubmitted BLIP. * **Reasons why the BLIP was not passed** - The reasons why the BLIP was not passed should be included in the resubmitted BLIP. * **Changes made to the BLIP** - The changes made to the BLIP should be included to address the concerns raised during the previous BLIP submission. * **Additional information** - More detailed intentions, specifics and implication details can help the community understand the revised BLIP, increasing the chances of it being passed. ### Code Changes Proposals that require code changes should include external references to the code that will be executed when the proposal is passed. This code should handle the data structures, logic, executable data, and execution of the proposal. All code changes should include audit reports. # Earn BLAST Source: https://metalayerlabs.mintlify.app/mobile/earn-app Blast Mobile's **Earn App** is here! No more farming points, waiting for Gold, or anticipating the next airdrop to earn BLAST rewards. Simply deposit some USDB into the Earn App to start earning yield in the form of liquid BLAST emissions. As you earn and your BLAST balance increases over time, so will the multiplier applied to the APY earned on your USDB deposits. Alternatively, skip straight to the maximum 6x multiplier by depositing additional BLAST. ## Getting Started If you don't already have a USDB balance available on your Blast Mobile account, use the **Deposit App** to quickly onboard funds through any of the available options: * Deposit via Coinbase, Binance, or other exchanges * Deposit via card * Transfer funds from another Blast account Open up the **Earn App** and click the "Deposit To Earn" button to deposit USDB into the app. Your multiplier will gradually increase over time as the ratio of BLAST to USDB increases in your Earn App. If you'd prefer not to wait, **you can immediately earn the maximum 6x multiplier by depositing more BLAST**. To get the maximum 6x multiplier, your BLAST balance in the Earn App must be equal in value to 30% of your USDB deposits. Every 6 hours, the app distributes yield on USDB deposits as liquid BLAST rewards. Withdraw your USDB deposits or BLAST rewards anytime. Withdrawing BLAST will **reset your multiplier** to 1x. # FAQ Source: https://metalayerlabs.mintlify.app/mobile/faq ## General During setup, Blast Mobile creates a new smart wallet for you, secured with passkey authentication. Unlike externally owned accounts (EOAs), which are derived from a seed phrase and use a private key to sign transactions, smart wallets are deployed as smart contracts on the blockchain. Since smart wallets do not have private keys, they rely on an externally owned account (EOA) as a ‘signer’ to authorize transactions. The seed phrase you can export from Blast Mobile belongs to this signer account, not the Blast Mobile smart wallet itself. Blast Mobile uses passkey authentication, which requires your device to support passkey creation and backup. * On iOS: Ensure that iCloud is enabled and that iCloud Keychain is set up to back up your passkeys securely. * On Android: Confirm that your device is configured to use Google Password Manager for storing and managing passkeys. See the FAQ section below on Passkey Authentiction for more info. Your Blast Mobile wallets are linked to the passkey created during setup. As long as you retain access to your passkey, your wallets can be recovered. Passkeys are securely backed up to iCloud Keychain (for iOS) or Google Password Manager (for Android), allowing you to restore access on any device signed in with the same Apple or Google account. Blast Mobile is designed to simplify and improve the user experience when interacting with dapps. Its smart wallets enable passkey authentication, eliminate the need to manage private keys, let us sponsor gas for your transactions, and allow seamless transactions without confirmations using Pro Mode. To maintain these benefits, Blast Mobile does not currently support importing EOAs, as they can't take full advantage of these features. However, we understand this may be a significant change from your previous experience and are exploring the possibility of enabling EOA imports in a future update. Enabling Blast Mobile's Pro Mode allows you to interact with trusted dapps in Blast Mobile *without* having to confirm/sign transactions for a smoother user experience. Blast Mobile’s initial launch focuses on helping users get familiar with the platform and introducing our updated tokenomics through the Earn App. We are actively working with dapps across the Blast ecosystem and will be rolling out their integrations on Blast Mobile soon. Stay tuned! Yes! There have been no changes to Blast’s native yield. You will continue to earn yield on ETH, WETH, and USDB as before. Native yield is earned in the same currency as your balance—for example, ETH on your ETH balances and USDB on your USDB balances. This differs from the Earn App, a new yield-earning opportunity launched with Blast Mobile. By depositing USDB into the Earn App, you can earn a significantly higher APY (50%+). However, yield from the Earn App is paid in **BLAST**. ## Earn App See our Earn App Overview for step-by-step instructions on getting started. In the Earn App, you earn yield only on your USDB deposits, but the yield is paid out in BLAST. For example, if you earn \$100 of yield on your USDB deposits, you would receive that yield as \$100 worth of BLAST. While your BLAST balance doesn’t earn yield in the Earn App, it does affect your multiplier, which can boost your earnings. Check related FAQs on maximizing your multiplier for more details. You can withdraw your USDB and BLAST at any time. BLAST rewards earned through the Earn App are liquid and can be withdrawn / sold as soon as you've earned them. Please note that withdrawing *any* amount of BLAST from the Earn App will reset your multiplier to 1x. Your multiplier starts at 1x and increases linearly to 6x based on the relative value (denominated in USD) of BLAST to USDB that you've deposited into the Earn App. You will reach the maximum multiplier of 6x when your BLAST deposits are equivalent in value to 30% of your USDB deposits. The amount of BLAST required to maximize your multiplier is relative to how much USD you've deposited into the Earn App. To maximize your multiplier, your BLAST balance needs to be equivalent to 30% of the value of your USD deposit. * New USDB deposits: Your multiplier may go up or down depending on the ratio of your total BLAST (in USD) to USDB. * New BLAST deposits: Adding more BLAST will always raise or maintain (but never reduce) your current multiplier. * Earning BLAST over time: As you earn BLAST rewards in the Earn App, your BLAST balance grows while your USDB balance stays the same, automatically increasing your multiplier over time. Your multiplier will not automatically decrease when BLAST’s price goes down. The price of BLAST only matters if you make additional deposits of USDB or BLAST, at which point the app checks BLAST’s price (via an oracle) to recalculate your multiplier. * When you deposit more USDB: Your multiplier may drop if your BLAST-to-USDB ratio (in USD) has gotten smaller—either because of (a) the extra USDB, (b) a lower BLAST price since last deposit, or both. * When you deposit more BLAST: The current price is used to determine how much extra BLAST value you’re adding compared to your USDB deposits. This never reduces your existing multiplier—only boosts it or leaves it unchanged. If you do not deposit or withdraw, BLAST price changes alone will not affect your multiplier. ## Passkey Authentication A passkey is a secure, passwordless login method that lets you sign in using your device's biometrics (like Face ID or a fingerprint). It's easy to use, resistant to phishing, and your login information is safely stored on your device and backed up in iCloud or Google Password Manager for seamless access across devices. No, Blast Mobile currently only supports: * iOS Users: iCloud Keychain * Android User: Google Password Manager # Overview Source: https://metalayerlabs.mintlify.app/mobile/overview Blast Mobile combines a passkey-authenticated smart wallet with a dapp launchpad, delivering a seamless experience of the full-stack chain to your favorite iOS or Android device. At launch, Blast Mobile will feature a suite of core utility applications including the Earn App, which lets users earn liquid BLAST rewards on their USDB deposits. Following the initial release, Blast Mobile's launchpad will expand to integrate with Blast's leading dapp teams, enabling users to enjoy features like gas sponsorship and Pro Mode across the entire Blast ecosystem. ## Key Features * **Integrated Smart Wallet** - Each user receives a newly generated smart wallet upon installation. * **Gas Sponsorship** - Benefit from gas sponsorship on the Blast App across all dapps. * **Pro Mode** - Enable Pro Mode to simplify interactions by automating transaction approvals for trusted apps. * **Push Notifications** - Stay locked-in with personalized notifications for each app. * **Passkey Authentication** - Ensure security with passkey authentication powered by your device's biometrics.. ## Blast Mobile Utility Apps * **Deposit** - Onboard funds from popular exchanges, debit card, or transfers from existing Blast accounts. * **Earn** - Earn liquid BLAST rewards on your USDB deposits. Learn more here. * **Send** - Simple utility for transferring tokens to other Blast accounts. * **Feedback** - Share your Blast Mobile experience with us and help us continue to improve it. # Seed Phrase Recovery Source: https://metalayerlabs.mintlify.app/mobile/recovery Learn how to use your exported seed phrase to recover a Blast Mobile account if you no longer have access to your original passkey. ## About Your Seed Phrase Blast Mobile uses ERC-4337 smart contract accounts, which depend on external signer EOAs (Externally Owned Accounts) to authorize transactions. The seed phrase exported from Blast Mobile corresponds specifically to this signer EOA, not directly to your Blast Mobile smart contract account. Importing this seed phrase into another wallet (e.g., MetaMask) will result in a different address from your Blast Mobile account and is therefore not recommended. Instead, seed phrases exported from Blast Mobile should only be used for account recovery, as described below. ## How to Export Your Seed Phrase You can export your seed phrase in two ways: 1. **Initial Setup:** You'll be prompted to back up your seed phrase when you first install and log into Blast Mobile. 2. **From Settings:** At any time, open **Settings** by clicking the three-dot icon in the top-right of your screen, and select **Export Seed Phrase**. ## Seed Phrase Recovery Steps Create or log into an existing Blast Mobile account using a passkey you currently have access to, in order to begin recovery. Open **Settings** by clicking the three-dot icon in the top-right of your screen, then select **Import Seed Phrase**. Alternatively, you can click **Import** from the wallet selection menu. Confirm that you understand seed phrase import is intended only for seed phrases generated by Blast Mobile. Enter or paste your saved seed phrase and click **Import**. Logging out of Blast Mobile will erase any imported accounts, **including those recovered using a seed phrase**. You'll need to re-import them after logging back in, so ensure you maintain a secure backup of your seed phrase. ## Managing Imported Accounts After importing your seed phrase, your accounts will be grouped by seed phrase in the wallet selection menu. You can add additional accounts to any of these groups by clicking the corresponding **Add Wallet** button. # Tokenomics Source: https://metalayerlabs.mintlify.app/tokenomics | | | | ------------- | ------------------------------------------------------------------------------------------------------------------- | | Ticker | **BLAST** | | Total Supply | **100 Billion** | | Token Address | [0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad](https://blastscan.io/token/0xb1a5700fA2358173Fe465e6eA4Ff52E36e88E2ad) | # Token Allocation Token Distribution ### Community - 50,000,000,000 (50%) Blast's success is only due to the community of users and builders that contribute to the ecosystem. 50% of the total BLAST supply is reserved for the community and will be distributed through incentive campaigns. 100% of this allocation will go directly to the community. The community allocation unlocks linearly over 3 years from the date of the TGE and any distributions will be according to schedules determined by the Blast Foundation. ### Core Contributors - 25,480,226,842 (25.5%) All tokens distributed to core contributors are subject to a 4 year lockup period, with 25% of the core contributor tokens unlocked 1 year after the date of the TGE, followed by a linear unlock each month over the following 3 years. ### Investors - 16,519,773,158 (16.5%) All tokens distributed to investors are subject to a 4 year lockup period, with 25% of the investor tokens unlocked 1 year after the date of the TGE, followed by a linear unlock each month over the following 3 years. ### Blast Foundation - 8,000,000,000 (8%) The Foundation allocation will be held in reserve to be used towards critical infrastructure and further growing the Blast ecosystem. The Foundation allocation is unlocked linearly over a 4 year period from the date of the TGE. # Phase 1 Airdrop Abstract gas parameters ### Blast Points - 7,000,000,000 (7%) Users that bridged ETH or USDB to Blast bootstrapped the initial liquidity on the Blast ecosystem and earned Blast Points throughout Phase 1. These users will be rewarded with 7% of the total BLAST supply. ### Blast Gold - 7,000,000,000 (7%) Users that contributed to the success of Dapps earned Blast Gold and will be rewarded with 7% of the total BLAST supply. ### Vesting The top 0.1% users (\~1000 wallets) will vest part of their airdrop linearly over 6 months. Vesting is subject to reaching a monthly Points threshold based on Phase 1 activity. Further details will be available on June 26. ### Blur Foundation - 3,000,000,000 (3%) The Blur Foundation will receive 3% of the total BLAST supply to distribute to the Blur community for both retroactive and future airdrops. # Phase 2 Airdrop Phase 2 was originally scheduled to end in June 2025, running for 12 months with an allocation of 10 billion BLAST. However, with the release of Blast Mobile, we are transitioning to new tokenomics that allow users and dApps to earn liquid BLAST rewards directly, rather than through points and Gold. As part of this transition, Phase 2 will now conclude in January 2025 with a prorated allocation of 5 billion BLAST. ### Blast Points - 2,500,000,000 (2.5%) Users that helped to maintain liquidity across the blast ecosystem by bridging and holding balances of ETH, USDB, and/or BLAST earned Blast Points throughout Phase 2. These users will be rewarded with 2.5% of the total BLAST supply. ### Blast Gold - 2,500,000,000 (2.5%) Users that contributed to the success of Dapps earned Blast Gold and will be rewarded with 2.5% of the total BLAST supply. # Analytics Source: https://metalayerlabs.mintlify.app/tools/analytics ## Arkham [Arkham](https://platform.arkhamintelligence.com/) is a public blockchain intelligence platform accessible via url that provides data on the entities and individuals behind crypto market activity by using AI to identify the owners of blockchain addresses. Features include a searchable database of onchain profiles, visualizer, tracer, alerts, custom dashboards, and an API. **Supported Networks** * Blast Mainnet *** ## Dune [Dune](https://dune.com) is a blockchain analytics platform for querying, visualizing, and sharing on-chain data. It enables users to create custom dashboards and analyses using SQL-based queries. **Supported Networks** * Blast Mainnet *** ## Flipside Crypto [Flipside Crypto](https://flipsidecrypto.xyz/) is an analytics provider that is similar to Dune, but typically faster for running complicated queries. **Supported Networks** * Blast Mainnet # Block Explorers Source: https://metalayerlabs.mintlify.app/tools/block-explorers ## Blastscan (Etherscan) | Network | URL | | ----------- | -------------------------------------------------------------- | | **Mainnet** | [https://blastscan.io/](https://blastscan.io/) | | **Testnet** | [https://sepolia.blastscan.io/](https://sepolia.blastscan.io/) | ## Blastexplorer (Routescan) | Network | URL | | ----------- | -------------------------------------------------------------------- | | **Mainnet** | [https://blastexplorer.io](https://blastexplorer.io) | | **Testnet** | [https://sepolia.blastexplorer.io](https://sepolia.blastexplorer.io) | ## Parsec | Network | URL | | ----------- | -------------------------------------------------------- | | **Mainnet** | [https://voyager.parsec.fi/](https://voyager.parsec.fi/) | ## DexGuru | Network | URL | | ----------- | ------------------------------------------------------------ | | **Mainnet** | [https://blast.dex.guru/](https://blast.dex.guru/) | | **Testnet** | [https://blast-test.dex.guru/](https://blast-test.dex.guru/) | ## Blockscout | Network | URL | | ----------- | -------------------------------------------------------------- | | **Mainnet** | [https://blast.blockscout.com/](https://blast.blockscout.com/) | ## Arkham | Network | URL | | ----------- | ------------------------------------------------------------------------------------ | | **Mainnet** | [https://platform.arkhamintelligence.com/](https://platform.arkhamintelligence.com/) | # Data Indexers Source: https://metalayerlabs.mintlify.app/tools/data-indexers ## GhostGraph [GhostGraph](https://GhostGraph.xyz/) makes it easy to build blazingly fast indexers (subgraphs) for smart contracts. GhostGraph is the first indexing solution that lets you write your index transformations in **Solidity**. Blast dApps can query data with GraphQL using our hosted endpoints. To get started, you can [sign up for an account](https://app.ghostlogs.xyz/ghostgraph/sign-up) and follow [this quickstart](https://docs.ghostlogs.xyz/category/-getting-started-1) guide on how to create, deploy, and query a GhostGraph. **Supported Networks** * Blast Mainnet *** ## Goldsky Goldsky offers high-performance subgraphs and realtime data replication pipelines, making Blast data accessible to developers via hosted API endpoints, or directly within your own infrastructure. Blast subgraphs deployed to Goldsky can also be replicated directly into [internal datastores](https://docs.goldsky.com/mirror/sinks/supported-sinks) via Goldsky Mirror, enabling alternative access patterns to the data, and for it to be joined seamlessly with other application/user data. For instructions on deploying subgraphs to Goldsky, visit Goldsky's dedicated indexing [quickstart page](https://docs.goldsky.com/chains/blast) for Blast. **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## The Graph [The Graph](https://thegraph.com/) is an indexing protocol for organizing blockchain data and making it easily accessible with GraphQL. Blast dapps can use GraphQL to query open APIs called subgraphs, to retrieve data that is indexed on the network. Learn how to use The Graph via their [documentation](https://thegraph.com/docs/en/) or [this quickstart](https://thegraph.com/docs/en/cookbook/quick-start/). **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## SQD [SQD](https://www.sqd.dev/) is a decentralized hyper-scalable data platform optimized for providing efficient, permissionless access to large volumes of data. It currently serves historical on-chain data, including event logs, transaction receipts, traces, and per-transaction state diffs. SQD offers a powerful toolkit for creating custom data extraction and processing pipelines, achieving an indexing speed of up to 150k blocks per second. Comment Edit from here To get started, visit their [documentation](https://docs.sqd.dev/) or see their [EVM examples](https://github.com/subsquid-labs/squid-evm-examples) of what you can build with SQD. **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## SubQuery SubQuery provides developers with fast, flexible, universal, open source and decentralised APIs for web3 projects. One of SubQuery's competitive advantages is the ability to aggregate data not only within a chain but across multiple blockchains all within a single project. Learn how to use SubQuery via their [documentation](https://academy.subquery.network/) or this [quickstart guide](https://academy.subquery.network/indexer/quickstart/quickstart.html). **Supported Networks** * Blast Mainnet * Blast Sepolia # null Source: https://metalayerlabs.mintlify.app/tools/faucets ## Blast Sepolia Faucets ### Quicknode [QuickNode Blast Faucet](https://faucet.quicknode.com/blast/sepolia) is an easy to use Multi-Chain Faucet that drips Blast Sepolia ETH. ### Blast API (No Affiliation to Blast L2) [Blast API Blast Faucet](https://blastapi.io/faucets/blastl2-testnet) is an easy to use faucet with no registration required that you can use to claim Blast Sepolia ETH for free. ## Ethereum Sepolia Faucets ### Quicknode [QuickNode Ethereum Faucet](https://faucet.quicknode.com/ethereum/sepolia) is an easy to use Multi-Chain Faucet that drips Ethereum Sepolia ETH. ### Blast API (No Affiliation to Blast L2) [Blast API Ethereum Faucet](https://blastapi.io/faucets/ethereum-sepolia) is an easy to use faucet with no registration required that you can use to claim Sepolia ETH for free. ## Bridging Sepolia ETH to Blast Sepolia Once you've acquired some Sepolia ETH, you can transfer it to use on Blast Sepolia by sending it to the Blast L1StandardBridge as demonstrated [here](https://sepolia.etherscan.io/tx/0x756d57214b500dedf5e5f9d5baaf9738f59f3492e242185bd51f31ae12b5573b). # Governance Source: https://metalayerlabs.mintlify.app/tools/governance ## Tally [Tally](https://docs.tally.xyz/) is a DAO launch and operations platform. DAOs use Tally to share control over protocols, treasuries and public goods. # Misc Tools Source: https://metalayerlabs.mintlify.app/tools/misc ## Biconomy [Biconomy](https://docs.biconomy.io/) is an Account Abstraction toolkit that enables Blast developers to provide the simplest UX for dapps or wallets. It offers modular smart accounts, as well as paymasters and bundlers as a service for sponsoring gas and executing transactions at scale. **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## Gelato Gelato provides Blast developers with native integrations with Gelato’s industry-leading Web3 middleware services including VRF, Account Abstraction, Web3 functions, and Relay to enable superior UX. Learn more [here](https://docs.gelato.network/). **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## Tenderly [Tenderly](https://tenderly.co/) is a full-stack Web3 development platform featuring RPC services, smart contract debugging, simulations, monitoring, alerting, and analytics. **Supported Networks** * Blast Mainnet # Node Providers Source: https://metalayerlabs.mintlify.app/tools/node-providers ## Quicknode [Quicknode](https://quicknode.com) provides public and private rpc endpoints for Blast, along with websocket support. **Supported Networks** * Blast Mainnet - Public RPC: [https://rpc.blast.io](https://rpc.blast.io) * Blast Sepolia - Public RPC: [https://sepolia.blast.io](https://sepolia.blast.io) *** ## Infura [Infura](https://infura.io) provides public and private rpc endpoints for Blast. **Supported Networks** * Blast Mainnet - Public RPC: [https://blast.din.dev/rpc](https://blast.din.dev/rpc) * Blast Sepolia - Public RPC: [https://testnet.blast.din.dev/rpc](https://testnet.blast.din.dev/rpc) *** ## Blast API (no affiliation to Blast L2) [Blast API](https://blastapi.io) provides public and private rpc endpoints for Blast. **Supported Networks** * Blast Mainnet - Public RPC: [https://blastl2-mainnet.public.blastapi.io](https://blastl2-mainnet.public.blastapi.io) * Blast Sepolia - Public RPC: [https://blastl2-sepolia.public.blastapi.io](https://blastl2-sepolia.public.blastapi.io) *** ## How to run your own nodes If you want to self host Blast nodes, then you can follow the guide here which uses docker compose for a painless setup process: [https://github.com/blast-io/deployment](https://github.com/blast-io/deployment) The above repo also links to more advanced documentation if you have custom deployment needs that require building the Blast software from source. # null Source: https://metalayerlabs.mintlify.app/tools/oracles ## API3 The [API3 Market](https://market.api3.org/blast) provides access to 200+ price feeds on [Blast Mainnet](https://market.api3.org/blast) and [Testnet](https://market.api3.org/blast-sepolia-testnet). The price feeds operate as a native push oracle and can be activated instantly via the Market UI. The price feeds are delivered by an aggregate of [first-party oracles](https://docs.api3.org/explore/airnode/why-first-party-oracles.html) using signed data and support [OEV recapture](https://docs.api3.org/explore/introduction/oracle-extractable-value.html). API3 also offers on-chain randomness on Blast via their [QRNG](https://docs.api3.org/guides/qrng/). **Supported networks** * Blast Mainnet * Blast Sepolia *** ## Pyth [Pyth Network](https://www.pyth.network/) offers price feeds and randomness on Blast. Pyth provides real-time price data sourced directly from [first part data providers](https://www.pyth.network/publishers). It introduces a [pull](https://docs.pyth.network/price-feeds/pull-updates) mechanism where any developer can permissionless consume prices ever 400 ms, making Pyth fast on-chain oracle. A developer can consume consume [these prices](https://www.pyth.network/developers/price-feed-ids) on Blast network in just 3 lines of solidity code. Checkout our price feed guide [here](https://docs.pyth.network/price-feeds/use-real-time-data/evm). Check our Entropy [guide](https://docs.pyth.network/entropy/generate-random-numbers/evm) here to get pure random numbers on Blast. **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## Redstone Redstone offers push-based price feeds for Blast. Learn how to use Redstone feeds with [this guide](https://docs.redstone.finance/docs/introduction). **Supported Networks** * Blast Mainnet * Blast Sepolia *** ## Supra Supra provides decentralized oracle price feeds for Blast. Learn how to use Supra price feeds [here](https://supra.com/docs/readme/). Supra also offers on-chain randomness on Blast via their [distributed Verifiable Random Function (dVRF)](https://supra.com/docs/vrf) solution. **Supported networks** * Blast Mainnet * Blast Sepolia # Safes Source: https://metalayerlabs.mintlify.app/tools/safes ## Protofire Protofire has deployed and maintained Gnosis Safe infrastructure across numerous L2 networks, including zkSync, zkScroll, Mantle, Linea, and others. You can create new safes on Blast or import existing Blast safes at [https://app.safe.protofire.io/](https://app.safe.protofire.io/). Be sure to check out the Blast Yield safe app for easy monitoring and management of Blast's native yield. **Supported Networks** * Blast Mainnet * Blast Sepolia # Using Blast Source: https://metalayerlabs.mintlify.app/using-blast ## Mainnet Blast Mainnet can be added as a custom network to any EVM-compatible wallet (i.e. [MetaMask](https://metamask.io)). ### Public RPC Endpoints 1. [https://rpc.blast.io](https://rpc.blast.io) 2. [https://blastl2-mainnet.public.blastapi.io](https://blastl2-mainnet.public.blastapi.io) 3. [https://blast.din.dev/rpc](https://blast.din.dev/rpc) 4. [https://blast.blockpi.network/v1/rpc/public](https://blastl2-mainnet.public.blastapi.io) ### MetaMask Quick Instructions To add Blast Mainnet as a custom network to MetaMask: 1. Go to the Blast Explorer at [blastscan.io](https://blastscan.io). 2. Scroll to the bottom and click the **Add Blast Mainnet** button in the footer. 3. Approve adding the network in the MetaMask prompt that opens. ### MetaMask Manual Instructions To add Blast Mainnet as a custom network to MetaMask: 1. Open the MetaMask browser extension. 2. Open the network selection dropdown menu by clicking the dropdown button at the top of the extension. 3. Click the **Add network** button. 4. Click **Add a network manually**. 5. In the **Add a network manually** dialog that appears, enter the following information for Blast Mainnet.
Network Name: **Blast**
RPC Endpoint: [https://rpc.blast.io](https://rpc.blast.io)
Chain ID: **81457**
Currency Symbol: **ETH**
Block Explorer: [https://blastscan.io](https://blastscan.io)
6. Tap the Save button to save Blast Mainnet as a network. You should now be able to connect to the Blast Mainnet by selecting it from the network ## Testnet Blast Sepolia can be added as a custom network to any EVM-compatible wallet (i.e. [MetaMask](https://metamask.io)). ### MetaMask Quick Instructions To add Blast Sepolia as a custom network to MetaMask: 1. Go to the Blast Testnet Explorer at [sepolia.blastexplorer.io](https://sepolia.blastexplorer.io). 2. Scroll to the bottom and click the **Add Blast Testnet Sepolia Network** button in the footer. 3. Approve adding the network in the MetaMask prompt that opens. ### MetaMask Manual Instructions To add Blast Sepolia as a custom network to MetaMask: 1. Open the MetaMask browser extension. 2. Open the network selection dropdown menu by clicking the dropdown button at the top of the extension. 3. Click the **Add network** button. 4. Click **Add a network manually**. 5. In the Add a network manually dialog that appears, enter the following information for the Blast Sepolia testnet.
Network Name: **Blast Sepolia**
RPC Endpoint: [https://sepolia.blast.io](https://sepolia.blast.io)
Chain ID: **168587773**
Currency Symbol: **ETH**
Block Explorer: [https://sepolia.blastexplorer.io](https://sepolia.blastexplorer.io)
6. Tap the Save button to save Blast Sepolia as a network. You should now be able to connect to the Blast testnet by selecting it from the network selection dropdown menu.