How to Build a Mobile Crypto App and Ensure Its Stability
Modern crypto traders are increasingly choosing smartphones as their primary tool — according to industry data, over 60% of trades are made via mobile devices. This demands that developers create not just visually appealing apps, but fully functional, secure, and high-speed trading platforms, where even minor bugs can lead to serious consequences (from incorrect balance displays to lost funds).
Building a mobile crypto trading app is not just about porting a web interface into an app. It’s a standalone engineering challenge with many nuances. Users expect to trade quickly, conveniently, and securely, without needing to understand the technical details.
Key trends shaping the mobile crypto trading market include:
- A shift from web to mobile: interfaces are embracing mobile-first design, and performance demands are rising.
- Demand for native experiences: apps must be fast, secure, and feel "native" to the operating system.
In this article, we share how the EVEDEX team and developers from CleverPumpkin integrated a TypeScript SDK (originally built for the web) into native apps to maintain unified business logic across platforms. This solution offered many advantages, but also brought a fair share of challenges with it.
Why We Chose SDK and the Challenges We Faced
The web version of EVEDEX already used a custom Exchange SDK, a TypeScript library that connects the exchange API on the client side. Over time, it has developed comprehensive business logic, including market data aggregation, order signing, and validation.
The key objective was to ensure consistent behavior across all platforms. Our aim was to avoid duplicating logic, reduce the number of bugs, and speed up development. This meant: integrating the existing web SDK into native mobile apps.
However, the SDK was written in TypeScript and wasn’t originally designed for use outside of a browser. This became our primary technical challenge.
“We discussed all possible implementation options in detail. Taking the full context into account, we decided to try integrating the full TypeScript SDK into the native apps. This was new territory for us, but we were ready to tackle this unconventional task.”
-Alexander Kiaykin, CTO of CleverPumpkin
The first step was embedding a fully-fledged JavaScript engine into the app. On iOS, we had access to the built-in JavaScriptCore, but for Android, we had to look for an alternative. We chose LiquidCore, an independent, open-source JS engine.
To ensure smooth interaction with the SDK from the native code, we developed a cross-platform wrapper that facilitated communication between the SDK and the app's business logic.
- Not all JS engines support the latest ECMAScript syntax: we had to downgrade the TypeScript transpilation target to a JavaScript version that is compatible with the engine.
- JS engines don’t have direct access to system capabilities: things like HTTP requests, WebSockets, and network communication had to be implemented in the native code.
As a result, the SDK was modified. It now uses external interfaces for network logic, HTTP and WebSocket interactions are handled on the Swift/Kotlin side, while the processing logic remains in JavaScript. In the end, the business logic stayed within the SDK, and low-level network operations were delegated to the native code. This allowed us to preserve architectural consistency and speed up development without compromising performance.
Wallet Integration: Implementing Deposits and Withdrawals
No crypto exchange can operate without deposit and withdrawal functionality. Our goal was to make this process intuitive and secure.
To enhance user convenience, we added support for flexible asset transfers between networks using the LI.FI service, which allows users to:
- Transfer assets from one network to another.
- Do it in just a few clicks, without manually searching for bridges or understanding the complex logic of cross-chain interactions.
- Choose the best option based on price/speed preferences.
We intentionally chose to use WebView. Although the app is built using native technologies, and a separate JavaScript engine is used for SDK operations, WebView allowed us to quickly integrate the LI.FI interface without having to re-implement its UI natively. This enabled a consistent user experience across both web and mobile platforms and made it easier to update deposit functionality.
At the same time, we had to consider the specifics of working with crypto wallets in a mobile environment. For connecting and interacting with wallets, we used EIP-1193 (Ethereum Provider JavaScript API), which is the standard that defines how apps can integrate with Ethereum wallets.
The mobile app supports several connection methods:
- Via MetaMask
- Importing an external wallet using a seed phrase or private key.
- Creating a new wallet directly inside the app.
Regardless of the chosen method, the app can serve as the wallet provider for the deposit page. This allowed us to reuse the existing web interface without needing to build a separate system for the mobile app.
NB*: At the current stage, EVEDEX operates with Ethereum-compatible networks only, so alternative standards were not considered.*
Conclusion and Key Takeaways
Integrating a TypeScript SDK into a native mobile app turned out to be an unconventional and sometimes challenging task, but it allowed us to ensure consistent behavior across all platforms, eliminate logic duplication, reduce the number of errors, and significantly speed up the development process:
- A web SDK can be adapted for mobile environments, but it requires architectural reconsideration and proper logic decomposition.
- Decoupling business logic from system-level operations is essential for sustainable architecture. In our case, the native code handles network operations and WebSocket communication, while the SDK focuses solely on business logic.
- Using standards like EIP-1193 helps to maintain wallet compatibility and simplify implementation.
- Combining native code, a JavaScript engine, and WebView gave us the right balance between development speed, flexibility, and user experience.
“It wasn’t easy, but now we know exactly how to embed a TypeScript SDK into a native crypto app. This not only sped up development but also gave us an architectural foundation for the future.”
— Vlad Komissarov, CTO at EVEDEX
The development of the EVEDEX mobile app wasn’t just another product launch, it was a real technological experiment that can now serve as a starting point for other teams looking for unconventional solutions in the crypto world.
Written by:
Vlad Komissarov, CTO of EVEDEX
Alexander Kiaykin, CTO of CleverPumpkin
