Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.

AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Blockchain
Exam Format
Registration
Validity
Skills this practice test covers
- Calculate what a transaction costs in gas under the EIP-1559 fee rules.
- Write and compile Solidity contracts with mappings, modifiers, events and custom errors.
- Find reentrancy, overflow and front-running flaws in contract code and fix them.
- Unit test contracts with Mocha and Chai, then deploy them to a testnet and to mainnet.
- Connect a web front end to a contract with web3.js and a MetaMask wallet.
- Run an Ethereum node on a development machine and pick the right network for each task.
Explore related topics
CBDE exam content
5 domains · 8 topics · 204 of 212 questions sorted by domain
Ethereum Fundamentals and Architecture38 questions
This domain covers how Ethereum works beneath the contracts: nodes, network types, the Ethereum Virtual Machine (EVM) and the gas system. Candidates also run a node on a development machine and work out what a transaction costs.
Skills tested
- Explain how the EVM runs bytecode and why each opcode costs gas.
- Calculate gas costs from the gas used, the gas price and the EIP-1559 fee rules.
- Choose between mainnet, testnets and private networks for a task.
- Run an Ethereum node on a development machine.
Official topics
- Ethereum Blockchain Basics
- Gas and Transaction Management
Solidity Programming65 questions
Solidity is the language that Ethereum contracts are written in. This domain covers data types, storage and memory, functions and modifiers, inheritance, events and error handling.
Skills tested
- Choose value types, reference types, mappings and arrays, and decide between storage and memory.
- Set function visibility and state mutability, and write modifiers that control access.
- Build contracts with inheritance, interfaces, abstract contracts and libraries.
- Emit events and handle errors with require, assert, revert and custom errors.
Official topics
- Solidity Language Fundamentals
- Smart Contract Development
Smart Contract Security40 questions
Many contracts hold real funds, and anyone can call them. This domain covers common attack vectors, such as reentrancy, integer overflow/underflow, front-running and denial of service, and the secure coding patterns that block them.
Skills tested
- Spot reentrancy, integer overflow/underflow, front-running and denial of service risks in contract code.
- Apply the Checks-Effects-Interactions pattern and pull over push payments.
- Restrict sensitive functions with access control checks.
- Reuse audited building blocks from libraries such as OpenZeppelin.
Official topics
- Security Vulnerabilities
Development Tools and Testing37 questions
This domain covers the tools around a contract: an editor, a local blockchain, a test framework and a deployment process. Candidates unit test contracts and deploy them to both test and live Ethereum networks.
Skills tested
- Compile and try contracts in Remix IDE, then connect a MetaMask wallet.
- Set up a project with Hardhat, or with Truffle and a local Ganache chain.
- Write unit tests with Mocha and Chai and measure test coverage.
- Deploy contracts to a testnet and to mainnet, then verify them on Etherscan.
Official topics
- Development Environment
- Testing and Deployment
Web3 and DApp Development24 questions
A decentralized application (DApp) joins a web front end to contracts on the chain. This domain covers web3.js and ethers.js, provider and wallet connections, contract calls and event listening.
Skills tested
- Connect a front end to a contract with web3.js or ethers.js through a provider.
- Read contract data and send transactions that the user's wallet signs.
- Listen for contract events and update the interface when they arrive.
- Handle wallet connections with MetaMask or WalletConnect.
Official topics
- Web3.js Implementation
Requirements
- No formal prerequisites: anyone can book the exam.
- Recommended: software development experience, ideally in JavaScript or a similar language.
- Recommended: a basic understanding of blockchain technology and programming concepts.
About the CBDE exam
CBDE tests whether a developer can write, test and deploy secure Solidity smart contracts on Ethereum. The Blockchain Training Alliance (BTA) awards the Certified Blockchain Developer - Ethereum credential to those who pass. The skills it checks include calculating gas costs, unit testing contracts, running an Ethereum node on a development machine and implementing web3.js. Software engineers with JavaScript or similar experience are the usual candidates.
In the PlanetCert practice test, Solidity Programming draws the most questions, with Smart Contract Security next. Reading each explanation pays off most on the security questions, such as those on reentrancy or a weak tx.origin check. Study Mode suits the code-reading questions, where one keyword such as payable, view or calldata changes the answer. Brainy AI Assistant can trace a call between two contracts step by step or explain how EIP-1559 sets the fee.
How to earn the certification
- Earns
- Certified Blockchain Developer - Ethereum (CBDE)Professional
- After
- CBSA Certified Blockchain Solutions Architect
BTA's architect certification. It moves from writing contracts to planning complete blockchain solutions.
- CBSA Certified Blockchain Solutions Architect
How to prepare for CBDE
- 1
Break a contract in Remix, then fix it
Write a small contract in Remix IDE that holds ether, then drain it with a reentrant call from a second contract. Apply Checks-Effects-Interactions and run the attack again to see it fail.
- 2
Price each function in gas
Deploy a contract to a local chain and note the gas each function uses. Compare a storage write with a memory operation, and work out the fee a user would pay under EIP-1559.
- 3
Test before every deployment
Set up Hardhat, or Truffle with a Ganache chain, and write Mocha and Chai tests for each function, failure paths included. Then deploy to a testnet and verify the source on Etherscan.
- 4
Wire a small DApp to the contract
Connect a simple web page to the contract with web3.js or ethers.js and MetaMask. Read a value, send a transaction and react to an emitted event.
- 5
Close with security drills and a timed run
Work through Smart Contract Security in Study Mode on the CBDE practice test, then take a full run in Timed Mode. Ask Brainy AI Assistant to walk through any attack path that is still unclear.
Start a timed CBDErun
Who CBDE is for
- Software engineers who are moving from web or backend work into Ethereum development.
- JavaScript developers who need to write, test and deploy Solidity contracts.
- Application architects who plan systems in which smart contracts hold data or value.
Typical job titles: Blockchain developer · Smart contract developer · Solidity engineer · DApp developer · Software engineer
CBDE glossary
19 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Bytecode
- The compiled, low-level form of a contract that the EVM actually runs.
- Checks-Effects-Interactions
- A coding pattern that checks conditions first, then updates state, and only then calls other contracts, which blocks reentrancy.
- Custom errors
- Named errors declared in a contract and raised with revert. They cost less gas than long error strings.
- EIP-1559
- The change to Ethereum's fee market that added a base fee, which is burned, and an optional priority fee for the block producer.
- Ethereum Virtual Machine (EVM)
- The runtime on every Ethereum node that executes contract bytecode one opcode at a time.
- Etherscan
- A block explorer for Ethereum that shows transactions and lets developers publish verified contract source code.
- Fallback functions
- Functions that run when a contract receives a call that matches no other function.
- Front-running
- Getting a transaction included ahead of a known pending one, often by paying a higher fee, to profit from it.
- Ganache
- A personal Ethereum blockchain that runs on a local machine for fast contract testing.
- Gas limit
- The most gas a transaction may use. If the work needs more, the transaction fails, and the gas already spent is still paid.
- Hardhat
- A development environment for compiling, testing and deploying Ethereum contracts with scripts.
- Mappings
- Solidity key-value stores, such as a table of token balances by address.
- MetaMask
- A browser wallet that stores keys and signs transactions for DApps.
- Modifiers
- Reusable code that runs before a function body, often to check who may call the function.
- OpenZeppelin
- A library of audited, reusable Solidity contracts, such as token standards and access control.
- Reentrancy attacks
- Attacks in which a called contract calls back into the caller before the first call finishes, for example to withdraw funds twice.
- Remix IDE
- A browser-based editor for writing, compiling, deploying and debugging Solidity contracts.
- Testnets
- Public Ethereum test networks where ether has no real value, used to try contracts before mainnet.
- Web3.js
- A JavaScript library that lets an application talk to an Ethereum node and to deployed contracts.