In this guide, I’m going to walk you through how to build your own Bitcoin hardware wallet using inexpensive off-the-shelf ESP32 boards and the same open-source software that runs on a Blockstream Jade. If you want to see the full process visually, Watch the video.
This is not a “buy one thing” guide. It is a practical build-and-flash walkthrough for people who are comfortable using a terminal, following documentation, and taking basic security steps seriously. The goal is to end up with a working DIY Jade-style device that can be used more like a production wallet rather than a development board left in debug mode.

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.
Why build your own Jade-style wallet?
There are a few reasons someone might want to do this instead of buying a retail device:
- You can use cheap, readily available hardware.
- The firmware is open source.
- You learn how the system works at a lower level.
- You get more control over the build and configuration process.
- You can experiment with secure boot and other low-level options.
That said, this is still a DIY project. If you want something that just works out of the box for most people, a retail device may be simpler. But if you like tinkering and understand the trade-offs, this is a very interesting project.
Hardware options covered in the video
In the video, I look at three no-assembly options:
- M5Stack Basic
- M5StickC-Plus
- TTGO / Lilygo T-Display
The important thing to note is that none of these require soldering or assembly in this build. You can buy them and use them as-is. The downside is that the units shown do not include camera functionality; they work over Bluetooth and USB only.
A few practical differences matter:
- M5Stack Basic and TTGO T-Display can use secure boot v2 in the examples I show.
- M5StickC-Plus, depending on the ESP32 chip revision, may be limited to secure boot v1.
- The M5StickC-Plus has a nonstandard USB device ID that some desktop wallet software may not recognize automatically unless patched or updated.
If you want something that works cleanly with existing Jade-compatible software without extra patches, the M5Stack-based option is probably the easiest path. If size and cost are your top priorities, the M5StickC-Plus is hard to beat, but it has a few more caveats.
Before you start: what this guide assumes
Before flashing anything, make sure you understand these points:
- You should be comfortable using Linux or Windows command-line tools.
- You should follow the official Blockstream documentation where possible and adapt only where needed.
- You should not treat a DIY device as magically safer than a retail one just because you built it yourself.
- If you enable secure boot, you must keep your signing key safe. Losing it can prevent future signed firmware updates.
Flashing the M5Stack Basic on Ubuntu Linux
For the first build, I use a fresh install of Ubuntu 22.04 and follow the Blockstream Jade documentation almost directly.

Step 1: Install build dependencies
Open a terminal and update your package list first:
sudo apt update
Then install the packages you need. In this case, that includes Git, Python 3 pip, and Python 3 venv:
sudo apt install git python3-pip python3-venv
If your system already has these installed, fine. If not, make sure they are present before moving on.
Step 2: Prepare the ESP-IDF workspace
The documentation tells you to create an esp folder for the build environment. In a terminal:
mkdir esp
From there, follow the repository instructions to set up the ESP-IDF toolchain in that folder. This is where the build tools live once everything is ready.
Step 3: Clone the Jade firmware repository
Return to your home directory and clone the Jade repository with submodules:
cd ~
git clone --recursive <jade-repository-url>
cd jade
The exact URL depends on whether you are using the official Blockstream repo or a fork that includes additional DIY hardware support. For some of the boards shown, my repository may be needed until upstream changes are merged.
Step 4: Select the correct config template for M5Stack Basic
This is one of the most important steps. If you use the wrong configuration file, the build will not target your actual hardware correctly.
For the M5Stack Basic, copy the appropriate display-based default config from the configs folder into the repository root and rename it to:
sdkconfig.defaults
In other words, you are telling the build system: “This is an M5Stack Basic with a display.”
Step 5: Identify the USB serial device
Plug the board in via USB. In Linux, these devices show up as serial devices. You can check what appeared using:
sudo dmesg
In my example, the device appears as /dev/ttyACM0.

Step 6: Fix permissions if needed
If you only need to flash once and do not plan to use the device in Linux long-term, a temporary permission change is enough. In my case, I used a one-time chmod approach so the current session could access the port.
If you intend to use this board in Linux regularly, adding proper udev rules is the cleaner long-term solution.
Step 7: Flash and monitor
Once the config file is correct and permissions are set, run the flash-and-monitor command from the repository instructions. In practice, that means building and flashing through ESP-IDF, then watching the device boot in monitor mode.
If everything works, you will see firmware write progress followed by serial output from the board. At this stage, it may still be running with development/debug features enabled, which is fine for testing but not ideal for normal use.
Flashing the M5StickC-Plus on Windows
Next, I show how to set up the environment and flash an M5StickC-Plus using Windows. The general idea is the same: install ESP-IDF, clone the firmware repo, pick the right config template, then flash.
Step 1: Install ESP-IDF for Windows
Start from the official Espressif documentation and use the Windows installer. In my example, I used the universal online installer and selected the ESP-IDF version that matched the Blockstream documentation at the time of recording.
This is an important detail: if the Blockstream docs specify a particular ESP-IDF version, match it as closely as possible to avoid unnecessary build problems.

Step 2: Clone the repository with submodules
In the ESP-IDF command prompt, clone the firmware repository recursively so all required submodules are pulled correctly:
git clone --recursive <repository-url>
cd jade
Again, use whichever repo actually supports your specific board.
Step 3: Use the M5StickC-Plus config template
Copy the default development config for the M5StickC-Plus into the repository root and rename it to:
sdkconfig.defaults
This tells the build system which hardware profile to use.
Step 4: Force a specific baud rate when flashing
One quirk with the M5StickC-Plus is that it may not work reliably at the default board rates used by ESP-IDF. In my example, I had to force a specific baud rate during flashing using an extra flag in the command.
If you see repeated flash failures on this board, check whether a non-default baud rate helps.
Step 5: Fix the Python 3 issue on Windows
This was one of the annoying parts of the Windows process. On some systems, typing python3 opens Microsoft Store instead of running Python. That breaks build commands that expect a working python3 executable.
The fix I used was simple:
- Open the ESP-IDF Python environment folder.
- Go into the
scriptsdirectory. - Copy the existing
pythonexecutable. - Rename the copy to
python3.
After that, both python and python3 resolve correctly inside the build environment.

Once that is fixed, the flash process can continue normally.
Making the firmware more suitable for normal use
The default development configs are useful when you are testing and debugging, but they are not what I would recommend for a device you actually plan to use day to day.
For this part, I use the TTGO T-Display as the example board, though the same idea applies to the other devices.
Step 1: Start from the right hardware template
Copy the correct config file for your board into the repository root and make it the active defaults file:
sdkconfig.defaults
If you previously used another board’s config in the same folder, delete or move old sdkconfig files so stale settings do not carry over. This matters more than people expect.
Step 2: Disable debug mode
Search your config for something like:
CONFIG_DEBUG_MODE=y
and remove it or disable it. Debug mode enables behavior that is useful during development but unnecessary and undesirable in a wallet you intend to use normally.
Step 3: Turn off verbose logging
Add a setting such as:
CONFIG_LOG_DEFAULT_LEVEL_NONE
The exact naming may vary depending on the config template, but the goal is simple: stop the device from dumping all sorts of diagnostic information over USB during normal operation.

Step 4: Rebuild and flash
After editing the config, rebuild and flash using the same ESP-IDF workflow as before. You should notice an immediate difference: instead of a wall of console spam in monitor mode, the device stays much quieter.
That does not mean it is “secure” by itself, but it at least moves you away from leaving development features enabled on something that will hold keys.
Enabling secure boot v2 and flash encryption
This is where things get more serious, and also where you need to be especially careful.
Secure boot changes the trust model of the device. Once enabled, the board should only accept firmware signed by your signing key. That is a good thing in principle: it makes casual reflashing much harder. But it also means that if you lose the signing key, you may no longer be able to update the firmware yourself.
Step 1: Use a secure boot config template
Instead of manually editing many low-level settings one by one, I use secure boot configuration templates from my repository for the main DIY platforms. The idea is that these templates already include the right options for your hardware class.
Copy the appropriate secure boot defaults file into the repo root and rename it to:
sdkconfig.defaults
Again, make sure you are using the profile that matches your actual board.
Step 2: Generate a v2 signing key
Secure boot v1 and v2 use different key types, so do not mix them up. For v2, generate a new signing key using espsecure.py from the ESP-IDF toolchain.
In my example, the config expected the key to live one folder above the repository with a name like:
jade_diy_v2.pem
You can use different names if you edit the config accordingly, but keep it consistent.
Step 3: Store the signing key safely
This is the most important part of the whole secure boot process.
Once secure boot is enabled with a specific key:
- only firmware signed by that key should be accepted;
- losing the key can prevent future updates;
- you should treat it like a critical piece of infrastructure for that device.
I would not casually store this on an unencrypted laptop or in a random cloud folder. Think about it as something you need to protect if you want long-term control over the firmware lifecycle of your DIY wallet.
Step 4: Build and manually flash the secure boot bootloader
When secure boot is enabled, the normal “build and flash automatically” flow changes. In my example, building the bootloader succeeded, but ESP-IDF did not auto-flash it. Instead, it printed a manual esptool.py write_flash command for you to run yourself.
Copy that command, trim unnecessary port/board arguments if your environment already detects the device correctly, and run it.

At this point, the board may remain in bootloader mode because full setup is not complete yet.
Step 5: Build the application and flash the signed binary
Next, build the app:
idf.py build
Then use the command provided to flash the signed binary. In my example, there were two commands shown; I used the one that flashed the signed image onto the device.
Step 6: Boot the device to complete setup
After flashing, start the monitor so the board performs its first full boot with secure boot enabled. This is when the final pieces of the process are completed.
Once it boots properly, you can check how wallet software sees the device. In my example, Blockstream Green no longer treated it as a developer device; it showed up as a normal Jade-compatible device running custom firmware.

What if you have an older ESP32 chip? Secure boot v1
If your board has an older ESP32 revision, secure boot v2 may not be available. In my example with one of the smaller boards, the build succeeded but flashing failed because the bootloader required a newer chip revision than what was detected.
In that case:
- Use a secure boot v1 config instead of v2.
- Change the relevant level setting from requiring level 3 to level 1.
- Generate a new signing key specifically for v1.
- Follow the same build and flash process as before.
The exact file names and settings will depend on your template, but the core idea is simple: v1 and v2 are not interchangeable.
How much does secure boot actually help?
This is an important security discussion, so I want to be clear about what secure boot does and does not do.
Without secure boot enabled, someone with physical access could potentially reflash your device very quickly if you were not paying attention. That is a real risk in the physical world.
With secure boot enabled:
- unsigned firmware should not boot;
- tampering becomes significantly harder;
- an attacker would need more time, more skill, and more specialized equipment to do anything meaningful.
That said, especially on older chips using v1, fault-injection-style attacks are still theoretically possible for a highly sophisticated adversary. So secure boot is not magic. It raises the bar dramatically, but it does not make the device unbreakable in all circumstances.
The practical takeaway is this: if you are going to run a DIY wallet, enabling secure boot and keeping your signing key safe makes the device meaningfully harder to abuse than leaving it in an open development state.
Updating firmware after secure boot is enabled
Once secure boot is active, you cannot just flash unsigned builds the way you would during normal development. Updates need to follow the signed workflow.
In my example, updating firmware over USB worked like this:
- Pull updates into the local repository so your source code is current.
- Rebuild the firmware. With secure boot enabled, the build produces a signed image such as
jade.binin the build folder. - Use the OTA script included with the repository to apply the update over USB rather than Bluetooth.
In practice, I ran the Jade OTA tool with the no-agent option because the device was connected by USB only. The process then prompted for confirmation on the device itself, similar to what you would see when updating a retail Jade through the Green app. You could review version information and proceed from there.
This is one of the nice things about this project: even after locking down the boot chain, updates remain possible as long as you have your signing key and follow the correct process.
Practical recommendations if you try this yourself
If you decide to build one of these, here are my practical suggestions:
- Start with a board that has good documentation support for your use case.
- Do not mix config files from different boards in the same working folder without cleaning up first.
- Test basic functionality before enabling secure boot.
- Back up your signing key properly if you enable secure boot.
- Disable debug mode and verbose logging once you are done testing.
- Keep your build environment version aligned with the documentation for the firmware you are using.
Final thoughts
I think the Blockstream Jade sets a high standard for what an open source hardware wallet can be, especially when it comes to making the project accessible enough that people can use off-the-shelf hardware and flash it themselves. That is not something I see very often in this space.
This DIY route also gives you real insight into how the system works under the hood: build configuration, USB behavior, secure boot, signing keys, and firmware updates all become much more concrete when you have actually done them yourself.
At the same time, this is still a self-hosted, self-built security project. The most important part is not just getting it to flash; it is understanding what you enabled, why you enabled it, and how to keep control of the device over time. If you can do that, this is a genuinely useful and interesting way to run your own Bitcoin hardware wallet on very low-cost hardware.
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.







