Cryptnox now provides three host-side SDKs for building software that talks to its smartcard-based hardware wallet over NFC: the Arduino SDK, the C++ core SDK, and the ESP32 SDK. They are intended for embedded engineers, native application developers, system integrators, and teams building connected wallet prototypes, NFC terminals, payment devices, kiosks, or IoT products.
For developers exploring embedded prototypes, NFC terminals, self-custody wallet integration, or custom smartcard development, the release provides a practical starting point for crypto hardware wallet integration using Cryptnox smartcard technology.
The new Cryptnox Arduino SDK documentation is intended as the first stop for developers who want to understand how to begin implementation in Arduino-based environments. Developers who want to inspect the repository, review examples, or follow the evolution of the source can also visit the Cryptnox Arduino SDK on GitHub.
For teams working in native C++ environments, the Cryptnox C++ SDK documentation provides an entry point for implementation. Developers who want to review the source code and repository structure can inspect the Cryptnox C++ SDK on GitHub.
Developers targeting ESP32-S3 can start with the Cryptnox ESP32 SDK documentation, install the package from the Cryptnox ESP32 SDK on the PlatformIO registry, or review the source in the Cryptnox ESP32 SDK on GitHub.
A hardware wallet SDK reduces the gap between secure hardware and real-world applications. Without an SDK, developers often need to spend significant time understanding low-level smartcard communication, command structures, transport behavior, and integration patterns before they can even begin building a product experience.
The purpose of the Cryptnox SDK publications is to make development around Cryptnox cards more accessible. Instead of starting from a blank page, developers can use the SDKs as a structured foundation for prototypes, demos, technical evaluations, and custom wallet applications.
This is particularly important for teams building self-custody products. In a software-only wallet, private keys are typically generated, stored, or used inside a software environment. A smartcard-based hardware wallet changes that model by placing sensitive key operations inside dedicated hardware. The application can request an operation, but the private key remains protected inside the card’s secure element.
That difference matters for product teams. It affects onboarding, signing flows, recovery models, NFC behavior, user interaction, and the way a wallet application is architected. A hardware wallet SDK helps developers connect the application layer with the card layer in a more predictable way.
The Arduino ecosystem is widely used for rapid prototyping, embedded development, hardware experiments, NFC projects, and proof-of-concept devices. The Cryptnox Arduino SDK is designed to help developers explore Cryptnox card integration from that type of environment.
This makes it especially useful for teams that want to test smartcard communication before committing to a full production architecture. For example, an engineer could use an Arduino-based environment to validate a concept involving NFC smartcard development, a dedicated terminal, or a constrained embedded system that interacts with a Cryptnox card.
The Arduino SDK is also relevant for education, demonstrations, and internal R&D. Hardware wallet integration often becomes much easier to understand when developers can test physical interactions with a card, reader, or terminal instead of only reviewing diagrams or specifications.
The key point is not that Arduino is always the final production platform. In many cases, it is the fastest way to explore behavior, validate assumptions, and build a working proof of concept around a smartcard SDK.
For a hands-on walkthrough, see our step-by-step guide on how to build Arduino projects with a Cryptnox hardware wallet smartcard.
The Cryptnox C++ SDK is aimed at developers building in native C++ environments or systems where performance, portability, or low-level integration control matters. C++ remains widely used in desktop applications, embedded systems, hardware interfaces, middleware, and fintech infrastructure.
For smartcard integrators, a C++ smartcard SDK can be especially useful because many card reader stacks, device communication layers, and system-level applications are built close to the operating system. Teams working on wallet software, issuer tools, secure signing flows, or terminal-side applications may prefer C++ when they need more control over integration behavior.
The C++ SDK provides a foundation for teams that want to build applications around Cryptnox cards without reinventing the entire communication layer from scratch. It can support development around prototypes, demos, internal testing tools, and custom integrations where Cryptnox hardware is part of the product architecture.
For technical decision-makers, this is also important because it makes Cryptnox easier to evaluate. Instead of assessing only the card as a physical product, engineering teams can now review SDKs, documentation, repositories, and integration paths.
For a hands-on C++ integration walkthrough, see our guide on the C++ smartcard SDK for integrating Cryptnox hardware wallet cards.
The ESP32 SDK is for ESP32-S3 projects that need to communicate with a Cryptnox hardware wallet card over NFC while also reaching the network from the same device. It targets ESP-IDF v5.5 and is built on top of the Cryptnox C++ core SDK.
Through the C++ core, the ESP32 package supports an encrypted secure session with certificate verification, ECDH, and mutual authentication, card-info reads, PIN verification, and on-card ECDSA signing of a 32-byte hash using secp256k1. The private key never leaves the card’s secure element, and NFC transport can be implemented with components such as PN532.
The Cryptnox ESP32 SDK is suited to connected wallet prototypes, NFC terminals or kiosks, payment devices, and IoT or embedded products. A documented end-to-end flow signs a USDC ERC-20 EIP-1559 transaction on-card and broadcasts it to Ethereum Sepolia over Wi-Fi.
A smartcard-based hardware wallet follows a different security model from a software-only wallet. In a software-only model, the application environment plays a major role in key storage and transaction signing. That may be acceptable for some use cases, but it also places more responsibility on the device, operating system, and application security model.
With the Cryptnox hardware wallet, the wallet is based on smartcard technology. The private key remains protected inside the card’s secure element, while the external application interacts with the card to request wallet operations.
This separation can be valuable for self-custody wallet integration because it creates a clearer boundary between the user interface and the key-holding hardware. The application can manage the experience, network selection, transaction preparation, and user flow, while the card remains the protected signing component.
For developers, this architecture requires a different mindset. The wallet application is not merely a key container. It becomes an interface to secure hardware. That is exactly where a secure element SDK or smartcard SDK becomes useful.
The new SDKs are relevant to several development scenarios.
Embedded engineers can use the SDKs as a starting point for hardware experiments involving Cryptnox cards. This may include proof-of-concept devices, custom terminals, lab tools, or product demonstrations that need to communicate with a smartcard-based hardware wallet.
NFC smartcard development is an important area for wallet and payment-related prototypes. Developers building NFC-enabled terminals, readers, or interaction flows can use the SDKs to explore how a device might communicate with Cryptnox cards in a controlled environment.
Web3 wallet builders can use the SDKs to better understand how Cryptnox cards fit into a broader self-custody wallet integration. A wallet application may handle the user interface, blockchain network logic, and transaction preparation, while the card remains the hardware-based signing element.
Fintech teams and issuer-oriented product teams can use the SDKs to build demonstrations or prototypes around card-based self-custody. This is especially relevant for organizations evaluating how hardware wallets, secure elements, and smartcard infrastructure can fit into regulated or semi-regulated financial products.
Cryptnox cards can be used as part of workflows where signing should remain separated from the application environment. The SDKs provide a development starting point for teams exploring how to structure these workflows around physical hardware rather than software-only key storage.
The recommended starting point is the documentation. Developers working with Arduino should begin with the Cryptnox Arduino SDK documentation. Developers working in C++ should begin with the Cryptnox C++ SDK documentation. Developers targeting ESP32-S3 should begin with the Cryptnox ESP32 SDK documentation.
The SDK repositories are also available for review and integration work: the Cryptnox Arduino SDK GitHub repository, the Cryptnox C++ SDK GitHub repository, and the Cryptnox ESP32 SDK on GitHub. For ESP32 projects, the package is also installable from the Cryptnox ESP32 SDK on the PlatformIO registry.
Teams should then test with Cryptnox hardware. Developers evaluating production use cases can review the main hardware wallet page or buy a Cryptnox hardware wallet from the Cryptnox shop.
The SDK releases are part of a broader Cryptnox ecosystem focused on smartcard-based wallet technology, secure elements, and hardware-backed self-custody.
For individual users and developers, the Cryptnox hardware wallet provides the physical foundation for card-based self-custody. For fintechs, issuers, and enterprise teams, Card Wallet as a Service extends this architecture into a broader platform model.
For organizations that need specialized card behavior, application logic, or product-specific implementation, Cryptnox also provides custom smartcard development. This is relevant for companies that need more than an off-the-shelf hardware wallet and want to build around secure smartcard technology.
Together, the SDKs, hardware wallet products, C-WAAS offering, and custom development services create a more complete path for developers and product teams: evaluate the card, prototype with SDKs, build an integration, and then move toward a custom or platform-based deployment if required.
The publication of the Cryptnox Arduino SDK and Cryptnox C++ SDK gives developers a clearer path to start building around smartcard-based hardware wallets.
For embedded engineers, the Arduino SDK offers a practical route into hardware prototyping and NFC smartcard development. For native application developers and system integrators, the C++ SDK provides a foundation for more advanced smartcard and wallet integrations. For connected and Wi-Fi-enabled devices, the ESP32 SDK supports ESP32-S3 flows that combine NFC card communication with network access.
Developers can begin by reading the SDK documentation, reviewing the GitHub repositories, and testing with Cryptnox hardware. Product teams exploring self-custody wallet integration, secure element workflows, or smartcard-based crypto infrastructure can also connect these SDKs to the broader Cryptnox ecosystem, including C-WAAS and custom smartcard development.
The next step is simple: review the documentation, inspect the code, and start building with Cryptnox smartcard-based hardware wallets.
A hardware wallet SDK is a developer toolkit that helps applications communicate with hardware-based wallets. With Cryptnox, the SDKs support development around smartcard-based hardware wallets, where the private key stays inside the card’s secure element.
The Cryptnox Arduino SDK is intended for developers building prototypes, demonstrations, embedded experiments, and NFC-related projects around Cryptnox smartcard-based hardware wallets.
The Cryptnox C++ SDK is intended for developers building native applications, system-level integrations, smartcard tools, wallet applications, or technical prototypes that communicate with Cryptnox cards.
The Cryptnox ESP32 SDK is used to build ESP32-S3 applications that communicate with a Cryptnox hardware wallet card over NFC and can also use Wi-Fi for connected flows, such as signing a transaction on-card and broadcasting it to a network.
Yes. The SDKs are designed to help developers build around Cryptnox cards, which can be used as secure hardware components in self-custody wallet applications.
Developers can review the Cryptnox hardware wallet page or browse Cryptnox hardware wallet products in the Cryptnox shop.
