Comment on page
FAQ
Frequently asked questions
Boba is a compute-focused Layer 2 (L2) solution built on top of the Layer 1 blockchain, Ethereum. Ethereum is similar to L1 blockchains like Avalanche, BNB, and Moonbeam, and acts as a base blockchain platform that executes all on-chain transactions. Boba scales and augments the core compute capabilities of Ethereum, reducing gas fees and improving transaction throughput - while retaining the security guarantees of Ethereum.
The complexity of smart contract algorithms can make them expensive and slow to execute at speed. To solve this, Boba has designed a Hybrid Compute architecture that enables smart contracts to trigger much more complex algorithms off-chain (similar to running an app on AWS for example), and then bring the result back into the on-chain smart contract. Hence, the Boba Hybrid compute model runs both on-chain and off-chain.
Boba is built on the Optimistic Rollup developed by Optimism. Boba chose to build on Optimism because it is essentially a modified version of Ethereum that makes it relatively easy to ensure Ethereum Virtual Machine (EVM) and Solidity compatibility. This minimizes the efforts required to migrate smart contracts from L1 to L2.
Boba is not a side chain. Side chains are their own blockchain systems with entirely separate consensus mechanisms. Boba Network lives inside of Ethereum as a series of smart contracts that are capable of executing Ethereum transactions. Side chains on the other hand rely on their own consensus mechanisms for security. Boba as a child chain instead relies on the security of Ethereum itself.
Boba is an augumentation over Ethereum. Just like you would on Ethereum, you can create and interact with Solidity smart contracts using the same wallet software you are already familiar with. However, Boba does not have a consensus algorithm of its own and relies on Ethereum.
Boba Network is just as safe as the Ethereum chain. Optimistic Rollups like Boba are safe as long as Ethereum itself is live (that is, not actively censoring transactions). In addition, Boba is in the process of implementing a security model backed by a system of fraud proofs, where users are paid to reveal bad transaction results published to the Boba Optimism based chain.
Boba has developed a swap-based mechanism to deliver a smooth user experience for moving funds across chains. Porting assets from L1 to L2, L2 to L1, or between two L2s (as long as they are both EVM-compatible), is fast and dependable.
The users who choose to take advantage of this bridging between L1 and L2 will pay a small convenience fee that is shared among the liquidity providers of the pools backing the swaps. Acting as liquidity providers is just the first of several staking opportunities Boba will roll out to the community. The higher level goal is to encourage broad participation in the operations and governance of Boba. As a tokenized, EVM-compatible L2, Boba is in a position to use the Boba token responsibly for the long-term sustainability of the network.
The high gas fees of Ethereum itself is a pretty strong incentive for developers to move to layer 2 networks like Boba. Boba not only helps Ethereum scale, but also allows contracts to tap into advanced off-chain compute capabilities that are not available on other chains. Boba also has plans to create an ecosystem fund to incentivize some of the early-stage projects that are just starting out and that plan to launch interesting apps. It’s going to take some time to put something like that together. That’s in our plans.
Many wallets now allow applications to trigger a popup to switch between networks. If your wallet supports this feature, you will be automatically prompted to switch networks when an application wants to use the Boba Ethereum network. You can use these bridges to add the Boba network to your wallet:
If your wallet does not support this feature, you will have to connect manually. The exact process for connecting your wallet to a Boba Ethereum network depends on the specific wallet software you are using. To get started on Boba/Ethereum, you can use the available community RPC endpoint.
To move assets into or out of an Optimistic Ethereum network you can use the Boba Gateway. Detailed instructions in our user documentation.
If you are a developer, you can choose any of these two methods: the classical bridge, or the fast bridge.
No, withdrawals currently cannot be cancelled once submitted.
Only if the centralized exchange supports Boba Network (at this time none of them do). Hence, you have to bridge your assets into a network they do support, such as L1.
Yes. However, you will have to deploy your own version.
The token decimals on Boba L2 are the same as on Ethereum L1. So if the token has 6 decimals on L1, it will have 6 decimals on L2.
You can also check the decimals by calling the token contracts:
const decimals = await this.ERC20_Contract.attach(tokenAddress).connect(this.L2Provider).decimals()
//typical values are 18 or, in some rare but important cases, 6
In the current release of the Boba Network protocol, there may be rare cases where the Sequencer submits a state root (transaction result), that is invalid and hence could be challenged. As a result, we have not yet deployed the Bond Manager contract which compensates Verifier nodes for gas spent when submitting state root challenges. Additionally, our upgrade keys have the ability to directly remove state roots without going through an uncompensated state root challenge.
A Sequencer node is a special node in an Optimistic Ethereum network that can order transactions on short timescales (on the order of minutes). This opens up the door to very fast transaction confirmation times with strong guarantees about finality. Eventually, the operator of the Sequencer node on a network will be determined by some governing mechanism. For now, Boba Network operates the only such node.
The Gas usage price on the Boba L2 updates every 10 minutes if the Ethereum L1 gas price changes (with some smoothing to reduce sharp discontinuities in the price from one moment to the next). The maximum percentage change from one value to another is capped at no more than 5% in the gas price oracle. For example, if the current
gasPrice is 10 Gwei then the next gasPrice will be between 9.5 and 10.5 Gwei. As on the Ethereum Mainnet, the current gas price can be obtained via .getGasPrice(), which is typically around 10 Gwei.Yes! ERC-2470 is deployed to
0xce0042B868300000d44A59004Da54A005ffdcf9f on the Boba L2. The address on the Boba L2 is the same as on Ethereum mainnet.- 1.use the Boba Blockexplorer (for L2), and Etherscan (for L1)
- 2.use the Boba
watcher-api - 3.run a typescript
watcher - 4.use third-party analytics
In addition to the docs in this Boba Developer Docs space, we have some examples that could provide more context.
Yes, we are working towards supporting Bedrock in the future.
In order to ease the withdrawal UX, we relay L2->L1 messages for users on L1 ourselves. The contracts
DiscretionaryExitFee.sol and L2BillingContract.sol are a way to compensate for the cost of relaying transactions on L1. However, they do not subsidize and take back the costs from the user.DiscretionaryExitFee is also a contract that we use to route Standard Exits through on our interface (the gateway). The purpose of this contract is to not burn native tokens for the compensation, but instead collect Boba token from the user. This contract uses the L2BillingContract to get the correct amount of exitFee, and then transfer the amount to the billing contract. The contract then proceeds with the withdrawal on the standard bridge. This again serves the purpose of voluntary collection.
Instead of deploying just one contract, you need to deploy several.
No, there is no difference.
Yes!
Boba network is a permission-less network and hence we cannot influence app creators about the disclosure of their source code. However, we do advise end users not to interact with smart contracts that use source code that is not verified in the Blockexplorer.
Unfortunately no, not at the moment.
Technically, an L1 token can have multiple representations on L2. This mean that an L1 token can be wrapped in distinct tokens: L2_token_A, or L2_token_B, both being valid and point to the same L1 token. But in order to standardize, the token list specifies only a single L2 token address for every corresponding L1 token.
Boba Network does have a testnet and it uses authentication through Twitter. Here’s a short walkthrough on how to get authenticated.
First, download MetaMask on your browser as a plug-in and set up a MetaMask wallet (do not be surprised by the fox that will follow your cursor when you first launch the application. He’s friendly!)
After you’ve set up your MetaMask account, you can connect to the Goerli network Testnet. After connecting, follow these steps:
- view your connection status displayed in the upper-right corner, along with a button that will allow you to select a chain to connect to.
- click on the Boba icon. MetaMask will prompt you to connect to the Rinkeby Boba network.
- click on the account you would like to use for your testnet. Hit Next.
- allow permissions by hitting Connect.
- make sure that all of the network details such as the Network name, URL, and Chain ID have all been auto-filled.
- Hit Approve.
- now that you’re connected to the network, you can authenticate with Twitter:
Boba Wallet
- hit the Tweet Now button to tweet your Boba Bubble token.
- once your tweet is shared, copy the link leading to it.
- paste the link to your tweet where you are prompted to do so.
NOTE: You can only make one fountain call per Twitter account, per day.
./scripts/wait-for-sequencer.sh is getting timed out. Any Solutions?Please run
docker-compose logs, as well as integration tests, and send us the output of the logs and test results via our Discord server.We have the graph node on Ethereum Mainnet L2 and Goerli L2. The Goerli graph node is public. The Mainnet graph node is hosted by The Graph team.
Although you will get an error message that says the gas limit is 1,000,000,000,000,000 Wei, the Boba Network will throw an error anytime the gas price is equal to, or more than three times the expected gas price for any given transaction.
When you make an Ethereum transaction, the user will be given an expected fee for the transaction. Say you are about to transfer some Ethereum into your friend’s account and you are given an expected transaction fee of 3 USD. Because the market changes quickly, the gas prices could sky-rocket, and the transaction fee is now 9 USD. In such cases you will receive an error message.
Here, Boba is looking out for you. Before that unexpected increased fee goes through, Boba throws an error message and prevents the payment from going through. If the transaction fee is at least three times what the expected cost was (in this example, your transaction fee of 3 USD jumped to 9 USD), the transaction will fail and saves you from the increased fee.
Try to increase or decrease Solc optimizations. For more information, check out the Solidity documentation. In addition, you can break down contracts into smaller chunks.
"creation of SCContract errored: [ethjs-query] while formatting outputs from RPC '{"value":{"code":-32603,"data":{"code":-32000,"message":"invalid transaction: exceeds block gas limit"}}}'As mentioned above, try to increase Solc optimizations. For more information, check out the Solidity documentation, or break down contracts into smaller chunks.
Here is the js code needed to utilize the Boba API:
const registerTx = await Boba_GasPriceOracle.useBobaAsFeeToken()
await registerTx.wait()
Boba Network fees can be paid either in Boba token, or in Eth. It is your choice to decide which to use.
When making a transaction on Boba and paying the transaction fee, the fee is first calculated in eth at a gas price of 1 gwei. This fee is then converted to Boba with a 25% discount.
Optimization does not mean that there’s a limit set to the number of transactions this contract can process.
There are multiple bridges available and are listed on our ecosystem page:
Yes, its possible on Boba as well. You could submit transactions directly on L1 by calling 'enqueue()' on the Canonical Transaction Chain (CTC). The sequencer is forced to include your transaction on L2, but you would still need it to be up and running.
Yes, state commitments are published on L1 approximately every hour. This applies to under-sized batches as well, which are published after waiting an interval.
The fault challenge period is 7 days.
Bridging multiple assets in one transaction and LP floating fee rate are two tweaks that have been made to the Liquidity Pool contracts.
Bridging multiple assets in one transaction involves extending the LP1 contract to allow bridging eth, and/or multiple tokens, to L2 in a single transaction call. This primarily enables users to bridge gas token along with their desired token to L2 in one transaction. This is a method that is applicable only on bridging (on-ramp) through the Liquidity Pools, and works for only the tokens that the LPs support. Contract methods that enforce this bridging are:
clientDepositL1Batch() on L1LP, and clientPayL2Batch() on L2LP.LP floating fee rate refers to the change in the fee logic on LPs. LP fee consists of
userRewardFee (fee distributed to liquidity providers), and ownerRewardFee (fee for the owner of the contract). Before the change, LPs had a configurable fixed value for both these fees. After the change, the userRewardFee is a dynamic value that depends on the pool balance, which moves between configured min/max ranges. The ownerRewardFeeRate continues to be a configurable fixed value.
Boba's Hybrid Compute Turing model:
- limits strings returned from external endpoints to 322 characters (5*64+2=322).
- allows only one Turing call per execution.
- imposes a 1200 ms timeout on API responses. Hence, please make sure that API responds promptly. If you are using AWS, note that some of their services take several seconds to spin up from a 'coldstart', and could result in persistent failure of the first call to your endpoint.
Hybrid Compute calls need to execute estimateGas first. This puts the API response in a short lived cache, out of which the result is fetched in transaction processing.
That's because the Hybrid Compute feature puts the Hybrid Compute response in a cache bucket. Your request including a Hybrid Compute request will put the response under a cache key that expires in 5 seconds:
const turingCacheExpire = 5 \* time.SecondNot directly at the moment. We propose all authenticated calls that need API keys and similar go through a proxy/gateway that would act as an authentication layer for the caller - if that's a suitable design.
Last modified 2mo ago