DIY Blockstream Jade + Camera: Low-Cost ESP32 Builds

In this guide, I’m going to walk through how to build a DIY Bitcoin hardware wallet that runs the same Blockstream Jade firmware you would find on a retail Jade, but with camera support. That matters because QR scanning makes these builds much more useful for interacting with other wallets and apps without needing USB compatibility in every case.

Watch the video if you want to see the full assembly process. This written version is a standalone reference, so it covers the main hardware options, wiring ideas, flashing steps, and the security-minded build order I recommend.

Five blue 3D-printed DIY Jade cases on a table
Several DIY Jade-style wallet builds in 3D printed cases

Build your own hardware wallet

Kits, smartcard hats, cases and parts for SeedSigner, ShieldSigner, Specter DIY and Satochip builds, tested with the firmware shown in these videos and shipped from Canada.

What you are building

The goal is to make an air-gapped, QR-capable Bitcoin hardware wallet using inexpensive ESP32-based boards. The firmware is Blockstream Jade firmware with camera support generalized for DIY hardware.

There are a few different build paths:

  1. ESP32-WROVER-CAM + Pico LCD — the easiest no-solder option.
  2. ESP32-WROVER-CAM + 1.3-inch Waveshare LCD hat — thinner and more compact, still simple wiring.
  3. Lilygo T-Camera-Plus with MicroSD sniffer button — one-button build with minimal soldering.
  4. Lilygo T-Camera-Plus with PCB-soldered buttons and battery modification — more work, but better as a portable device.
  5. Plain ESP32-CAM — the cheapest option, but it needs programming-mode wiring and is fiddlier to assemble.

All of these need a 3D printed case for a clean result. If you do not have access to a printer, local libraries or maker spaces can sometimes print simple cases for a small fee.

Recommended build process: test before securing the device

Before I get into each board, this is the workflow I strongly recommend.

  1. Assemble the hardware on the bench first.
  2. Flash a debug firmware profile.
  3. Verify buttons, display, and camera scanning all work.
  4. Put the device in its case.
  5. Power it up and verify everything again.
  6. Only then enable secure boot or no-radio options for production use.

This order matters because secure boot can make a bad build very hard to recover from. If you enable secure boot before confirming that your buttons, screen, camera, and flashing process all work correctly, you can easily end up with a bricked device. In other words: get it working in debug mode first, then lock it down.

You will also want my fork of the official Jade repository, using the diy-camera branch. It contains the documentation and configuration profiles for these camera-enabled DIY devices. The branch is based on the retail firmware but includes changes to support camera functionality more generally across different hardware.

GitHub repo with diy-camera branch
The DIY camera branch of the Jade fork repository

This guide assumes you already know how to set up the Jade build environment. If you have not done that before, go back to my earlier DIY Jade video and get your toolchain working first. Then come back here for the camera builds.

Easiest build: ESP32-WROVER-CAM + Pico LCD

The simplest camera-enabled build I show is an ESP32-WROVER-CAM board paired with a Pico LCD 1.14-inch display. This is the easiest option because the pins are labeled, there is no soldering required, and you only need jumper wires to connect the display to the ESP32.

This build uses around ten jumper cables. You match the display pins to the ESP32 pins using the assembly guide in the repository documentation.

WROVER-CAM board with Pico LCD and pin mapping
ESP32-WROVER-CAM board next to a small display and pin-mapping documentation

Wiring the Pico LCD build

  1. Connect VCC / 5V from the display side to the matching power pin on the ESP32-WROVER-CAM. – On some boards this may be labeled VCC. – On others it may be labeled 5V. – Use the innermost 5V pin if possible, because using the outer edge pin can make case fitment harder later.
  2. Connect ground from the display to any ground pin on the ESP32 board.
  3. Follow the documentation and connect the remaining display signal pins with jumper wires.

I personally prefer female-to-female Dupont connectors over some of the standard female-to-male types, because they tend to hold more securely on the header pins. This is not required, but it makes disassembly and reassembly easier.

Jumper wiring between ESP32-WROVER-CAM and display
Routing jumper wires from the ESP32 board to the display connector

Flashing and testing the Pico LCD build

Once the hardware is wired:

  1. Go into the configs folder in the repository.
  2. Copy the ESP32-WROVER-CAM configuration file.
  3. Paste it into the main Jade repository folder.
  4. Delete any existing sdkconfig files if present.
  5. Rename the copied config to sdkconfig.defaults.
  6. Open your ESP-IDF environment.
  7. Run idf.py flash monitor.

After flashing, do not jump straight into using it for funds. Test the basics:

  • Press each button and confirm the firmware logs or responds correctly.
  • Confirm the display lights up.
  • Go to recovery, then advanced options, then QR scan.
  • Confirm the camera initializes and can see a QR code.
Working DIY Jade with camera feed on LCD
Serial log shows camera initialized while the LCD displays the live camera feed

If all of that works, you have a functional DIY Jade-style wallet with camera support using only two main components and jumper wires.

Putting it in a case

The Pico LCD build is simple but bulky. The case I show for this one is large, but it fits together without much fuss.

  1. Seat the ESP32 board so the camera lines up with the cutout.
  2. Route the jumper wires toward the back and middle of the case where there is more space.
  3. Press the halves together.
  4. Power it up again and retest buttons, display, and QR scanning.
Finished Pico LCD build in a blue 3D printed case
The assembled no-solder WROVER-CAM build with screen lit

This is the best option if you want the lowest barrier to entry. It costs more than the cheapest ESP32-CAM route, but it saves a lot of frustration because there is no soldering and the wiring is straightforward. In the video, I noted that this build can be around $20 USD with a generic clone board or about $25 USD with an official Freenove board.

More compact WROVER-CAM build: 1.3-inch Waveshare LCD hat

If you want something thinner than the Pico LCD build, you can use a Waveshare 240×240 1.3-inch LCD hat with right-angle header pins. This gives one of the lowest-profile builds in this video while still using simple wiring.

You can find that display here: Waveshare 240×240 1.3inch LCD Hat for Raspberry Pi

Low-profile WROVER-CAM and 1.3 inch display build
ESP32-WROVER-CAM wired to a smaller 1.3-inch display module

Wiring differences from the Pico LCD build

The wiring is similar, but there are two important differences:

  • This Waveshare hat uses 3.3V power, not 5V like the Pico LCD.
  • You do not need to connect the backlight pin for this build.

Use the documentation in the repository to match the correct pins. Once wired, you can use small printed spacers or clips over the header legs so they do not short together when the device is compressed into a low-profile case.

Fixing the display offset

When you first power up this build, the image may look slightly offset because the firmware defaults are tuned for a smaller display. You need to adjust the Blockstream Jade display driver offsets in menuconfig.

  1. Stop the serial monitor if it is running.
  2. Run:

bash idf.py menuconfig

  1. Go into Blockstream Jade options.
  2. Open the display driver section.
  3. Set the display offsets to:

text 0, 0, 240, 240, 240

  1. Quit and save the configuration.
  2. Rebuild and flash with:

bash idf.py flash monitor

After this change, the image should fill the larger LCD properly.

Terminal showing menuconfig and full-screen display result
Adjusting display driver offsets so the image fills the 1.3-inch LCD

A note about WROVER-CAM clones

I tested both an official Freenove ESP32-WROVER board and a cheaper clone. They are very similar, but there are quirks.

The main difference I noticed:

  • The official board has USB-C and generally starts up cleanly when powered.
  • Some clone boards have micro-USB and may need to be restarted after power-up before they work reliably.

On one clone, you can trigger startup by pressing a small button on the PCB with something like a toothpick. Alternatively, you can wire the enable pin to a spare button so you do not have to poke at the board every time. Just remember: if you connect that pin to a button, pressing it will reboot the device.

For simplicity and reliability, I generally prefer the official Freenove board when possible. In the video, the 1.3-inch Waveshare build was about $24 USD with a generic ESP32 and around $30 USD with the official Freenove board.

Lilygo T-Camera-Plus: built-in screen, camera, and battery connector

The Lilygo T-Camera-Plus is interesting because it already has a screen, camera, and battery connector on one compact board. That makes it attractive for a small wallet build. The catch is that there are very few usable IO pins available, so adding buttons is not straightforward.

T-Camera Plus pin diagram
Pin map for the Lilygo T-Camera Plus board

The button that comes on the board mainly resets or powers the device. It is hardwired and cannot simply be remapped like a normal firmware-controlled button. The only usable IO I found was connected to the MicroSD port, which gives us a workaround.

T-Camera-Plus with MicroSD sniffer button

The easiest way to add a working button without doing fine PCB soldering is to use a MicroSD sniffer adapter. These are inexpensive on AliExpress. You solder a tactile button between the CD pin and ground on the sniffer, then insert it into the board’s SD slot.

T-Camera Plus with MicroSD sniffer adapter and button
MicroSD adapter carrying a soldered push button for the T-Camera Plus

Flashing the T-Camera-Plus build

  1. Copy the DIY CAM T-Camera Plus config from the repository’s configs folder.
  2. Paste it into the main Jade repository folder.
  3. Delete any existing sdkconfig files if present.
  4. Rename the copied file to sdkconfig.defaults.
  5. Run:

bash idf.py flash monitor

Once running, you should see button press and release events in the serial log. The firmware is configured so that a single button can loop through menus when it reaches the bottom, which makes one-button operation practical.

To test camera support:

  1. Select initialize or recovery depending on your setup stage.
  2. Go to advanced options.
  3. Choose QR scan.
  4. Confirm the camera feed appears and can read a QR code.
Button press log with working Jade device
Serial monitor shows button events while the physical button is pressed

Case assembly for T-Camera-Plus

The case I show is based on a Lilygo-style design, modified for this build. The board screws into the top part of the case first. That helps hold everything together and keeps alignment better.

  1. Insert the board so it passes through like an SD card.
  2. Screw the board to the top section if desired.
  3. Clip the lower case half on.
  4. Verify camera position and screen alignment.
  5. Retest buttons, display, and QR scanning.

One thing to watch: the camera module may sit in a slightly random position depending on how it was attached during manufacturing. You may need to nudge it into better alignment inside the case. The same can be true for the screen alignment.

T-Camera Plus being fitted into its 3D printed case
Seating the T-Camera Plus board and camera module in the printed enclosure

This build is compact, but it still has a one-button interface unless you do more soldering. In the video, I included parts such as buttons, an SD adapter plate, and even a cheap soldering iron, bringing the total to about $35 USD.

T-Camera-Plus with PCB-soldered button and battery modification

If you are comfortable with soldering, you can improve the T-Camera-Plus build by adding buttons directly to the PCB and modifying it for proper battery use.

This is more advanced than the MicroSD sniffer method, but it gives a cleaner result and better battery behavior.

Accessing IO0 / button pins on the PCB

The pin we want is not easy to reach because of the metal shield around the SD holder area. You may need to trim back the shield carefully to expose the target pad.

Annotated T-Camera Plus PCB showing solder target
Close-up of the MicroSD socket pins and target pad for button wiring

Important safety notes:

  • The SD holder housing can be connected to ground.
  • Avoid shorting your pin to ground, adjacent pins, or nearby surface-mount components.
  • If the screen does not light up or the button does not respond after soldering, suspect a short and inspect before powering it again.

You are connecting one side of the button to the target IO pin and the other side to ground. Some tactile buttons have legs on both sides that act as common connections, which lets you reuse a single ground wire across multiple buttons.

Adding battery support with a power button

The T-Camera-Plus has a battery connector, but if used without modification it can drain overnight. To make battery use behave more like a retail Jade, you need to remove a specific resistor and add a separate power button wire.

  1. Remove the specified resistor from the board using soldering iron heat.
  2. Be careful not to damage nearby components such as the screen or existing buttons.
  3. Solder a wire to the power management unit’s power button pin.
  4. Connect that wire to a second tactile button.
  5. Reuse the ground connection from your other button if convenient.

After this modification, you have two distinct functions:

  • One action button for navigating menus.
  • One power button for turning the device on and off.

Pressing the power button twice should turn the device off, similar to a retail Jade.

T-Camera Plus with external buttons wired
Two tactile buttons wired to the T-Camera Plus board

Battery case assembly

For this version, I used a battery that had been cut out of a bricked Elipal Titan Mini and fitted with leads. You can use another suitable lithium cell if you are comfortable doing so, but make sure it fits safely in your case and does not create a fire hazard.

Assembly order:

  1. Seat the camera module into its hole.
  2. Place the battery over the board where it will help hold things down.
  3. Keep wires clear of moving parts and tight edges.
  4. Fit the lower case section.
  5. Align the lid screws with the pegs.
  6. Make sure there is clearance under any internal posts or connectors.
  7. Screw the lid down.
  8. Test power button, action button, display, and camera scanning.
T-Camera Plus battery build in a compact case
DIY wallet case compared with a retail hardware wallet

This is one of the more complete builds because it has battery operation and a proper power-off behavior. It is still larger than a retail Jade, but not enormously so. In the video, the total for this build was also around $35 USD including soldering tools.

Cheapest option: plain ESP32-CAM

The final build uses a basic ESP32-CAM board. This is the cheapest route, but it is also the most fiddly because IO pins are very limited and programming requires forcing the board into download mode by tying IO0 to ground.

Disassembled ESP32-CAM parts
ESP32-CAM board, display, USB converter, and jumper wires

You have two main flashing options:

  • Buy an ESP32-CAM with a programming base.
  • Use a separate CP2104 or similar USB-to-TTL UART converter.

The CP2104 route lets you keep the final device smaller if you do not need USB after assembly, but it requires more careful wiring on the bench first.

Programming mode: IO0 to ground

This is the most important part of the ESP32-CAM build. By default, simply plugging in power may not put the board into a state where your computer can flash it. You need to force programming mode by holding IO0 low during boot.

The easiest method I found:

  1. Hold the metal housing of a USB plug firmly against the IO0 contact on the board.
  2. Make sure you are touching the outer metal shell, not the live contacts.
  3. Plug in power while maintaining that connection.
  4. Release once the board is in flash mode.
  5. Run your flash command.
Holding USB plug housing to ground IO0
Using a USB plug housing to tie IO0 to ground for programming mode

After flashing, you may need to press the reset button on the ESP32-CAM board to start it properly.

Button and display wiring

Because IO is so scarce on this board, the button reuses an IO port connected to flash-related functions. This works, but it means the design is less flexible than the WROVER or T-Camera-Plus builds.

For the button:

  1. Use a standard tactile push button.
  2. Remove any extra legs you do not need.
  3. Fit DuPont connectors onto the remaining legs if desired.
  4. Keep one wire connected to IO0 for programming mode during initial flashing.
  5. Once the device is working, you can remove that IO0 wire because future updates can be done over OTA.
ESP32-CAM with button and USB converter wired
Repository files alongside ESP32-CAM bench wiring

Assembling the ESP32-CAM case

This case is more fiddly than the others, so I strongly recommend getting the board running on the bench before trying to fit it into the enclosure.

Assembly order:

  1. Seat the ESP32-CAM board with the camera aligned near the bottom cutout.
  2. Slide in the CP2104 USB converter if you are using one.
  3. Push it fully into place, with pin protectors facing down.
  4. Insert the button through its hole first.
  5. Add the triangular retainer piece to hold the button against the board.
  6. Tuck wires diagonally to one side.
  7. Curl and seat the screen module into position.
  8. Close the case.
  9. Power on and retest buttons, display, and QR scanning.
ESP32-CAM being seated inside the printed case
Fitting the ESP32-CAM board and button into the blue enclosure

This build is very cheap. In the video, I estimated around $20 USD for the main parts. If you want to save even more, you can skip the separate USB-to-serial converter by buying an ESP32-CAM with a programming base, then powering the device directly from 5V after flashing. That can bring the cost down to roughly $16 or $17 USD, though it makes the build less convenient if you want USB access later.

Secure boot, no-radio builds, and mkdefaults.py

For production use, I recommend building a more secure firmware profile once your hardware is fully verified. This can include:

  • Disabling radio features such as Bluetooth.
  • Enabling secure boot.
  • Using signed firmware where appropriate.

In this repository setup, separate config profiles for no-debug, secure boot, and no-radio are not used the same way as before. Instead, there is a script called mkdefaults.py that modifies your SDK defaults file for you.

Example: creating a no-radio build

  1. Make sure your working sdkconfig.defaults file is in the main repository folder.
  2. Run the script with that file as an argument.
  3. Choose the no radio option when prompted.
  4. Rebuild and flash:

bash idf.py flash monitor

The device should now show Bluetooth disabled in firmware. If you try to enable it from the UI, it will tell you that it is disabled at the firmware level.

No-radio build with BLE disabled
sdkconfig.defaults file and Jade screen showing BLE disabled

Example: preparing a secure boot build

For secure boot:

  1. Use the same mkdefaults.py script.
  2. Choose the secure option.
  3. Delete any old generated config if prompted or if it causes conflicts.
  4. Let the script create the correct defaults file.
  5. Follow the normal secure boot key generation and firmware signing process from my earlier DIY Jade guide.

The benefit of using mkdefaults.py is that it reduces the chance of copying the wrong configuration template by hand. You start with your known debug config, then let the tool modify it for the production profile you want. That makes the process less error-prone and easier to maintain across firmware versions.

Terminal running mkdefaults.py
Using mkdefaults.py to edit SDK configuration defaults

Device limitations and practical notes

These builds are impressive, but they do have limitations.

USB compatibility

Some of these DIY boards use a USB device identifier that is different from the retail Jade. That can matter if you want direct USB integration with certain desktop wallets or tools. Pull requests to improve compatibility may take time. If you need USB compatibility urgently, you may have to build those changes yourself or rely more on QR scanning.

The T-Camera-Plus and some other builds share the same device identifiers as a retail Jade, so they can work plug-and-play with software that already supports the retail Jade over USB. The plain ESP32-CAM and WROVER-based builds may not have the same level of USB compatibility out of the box.

QR code login quirks

Camera-based QR scanning works well for many tasks, but I found QR code login to be a bit finicky on some boards, especially when running from battery power. On USB power, it worked more reliably in some cases. This may point to power delivery or board quality issues rather than a fundamental firmware problem. These cheap ESP32-CAM boards are not known for high-quality power behavior, so that is plausible.

That said, all the builds I showed work well enough for:

  • Stateless operation.
  • Scanning QR codes.
  • Performing transactions over QR.
  • Recovery workflows where camera scanning is used.

RAM and other cheap ESP32 boards

A common question is whether you can add a camera to something like a Lilygo T-Display, which costs around $10. The short answer is that those cheaper display boards often do not have the extra RAM needed for this kind of camera workflow in the same way the retail Jade or WROVER-class boards do.

I briefly looked at an M5 Fire-type device as well, but I ran into issues getting the camera to work correctly. There may be enough IO to make it possible, but other peripherals on that board might interfere. That is definitely a future experiment rather than something I would recommend right now.

In general, with readily available low-cost ESP32 platforms, it seems easier to start with an integrated camera and add a screen than the other way around.

Which build should you choose?

Here is how I would think about choosing:

  • Choose the WROVER-CAM + Pico LCD if you want the easiest no-solder camera-enabled build and do not care much about size.
  • Choose the WROVER-CAM + 1.3-inch Waveshare hat if you want a thinner device but still prefer simple wiring.
  • Choose the T-Camera-Plus with MicroSD sniffer if you want a compact all-in-one board and are okay with one button plus minimal soldering.
  • Choose the modified T-Camera-Plus if you are comfortable soldering, want battery operation, and want a proper power button.
  • Choose the plain ESP32-CAM if cost is your main priority and you do not mind more assembly work and limited IO flexibility.

From a security perspective, my advice remains the same: build it, test it thoroughly in debug mode, then move to secure boot or no-radio only when you are confident the hardware is stable. A DIY wallet is useful because it gives you transparency and control, but that also means you are responsible for verifying that your build actually works before trusting it with funds.

Five completed DIY Jade-style devices
Multiple completed low-cost camera-enabled Jade builds

Conclusion

These builds show how far open source hardware and firmware can go. For relatively little money, you can create a Bitcoin hardware wallet that runs Blockstream Jade firmware with camera support, QR scanning, and air-gapped operation. The WROVER-CAM builds are the most beginner-friendly, while the T-Camera-Plus gives you a more compact package if you do not mind soldering or using an SD sniffer workaround.

The 3D printed cases I used should be treated as proof of concept rather than perfect industrial designs. If you improve them, share your work. That is part of what makes this space useful: people can build, test, learn, and then make the next version better.

If you try one of these builds and run into trouble, leave a comment with details about your board, config file, symptoms, and serial logs if available. I do my best to answer questions like that because troubleshooting is where most DIY wallet projects either get fixed or get abandoned.

Build your own hardware wallet

Kits, smartcard hats, cases and parts for SeedSigner, ShieldSigner, Specter DIY and Satochip builds, tested with the firmware shown in these videos and shipped from Canada.

Found this useful?

These guides are free and ad-free. You can support them by sharing them, subscribing on YouTube, or sending a tip.

Stuck on this?

Book a one-hour session and I’ll walk you through it, or ask about a trusted recovery.

Recovery guides

More guides