JavaScript Integration into encryption trading applications: Challenges and Solutions

How to create a mobile encryption application and ensure its stability

Modern encryption traders are increasingly choosing smartphones as a basic tool – according to industry data, more than 60 % of trades are made via mobile devices. This requires developers that the developers create an attractive applications only, but also fully, safe and high trading platforms, as even simple errors can lead to severe consequences (from incorrect balance screens to lost money).

Create a mobile transmission trading application not only to transfer a web interface in an application. It is an independent geometric challenge with many nuances. Users expect to trade quickly, comfortably and safely, without having to understand technical details.

The main trends that make up the mobile encryption trading market include:

• Convert from the web to the mobile phone: embraces the first design fronts of the mobile phone, and the performance requirements rise.
• Request for original experiments: The applications should be fast and safe and feel “original” with the operating system.

In this article, we share how to merge the Evedex team and developers from CleverPOmpkin a Typescript SDK (originally designed for the web) into the original applications to maintain the logic of unified business via platforms. This solution provided many advantages, but also brought a fair share of challenges with it.

Why did we choose SDK and the challenges we faced

Use the Evedex web version already Excination SDK, the Typescript Library linking API Exchange on the customer side. Over time, it has developed a comprehensive business logic, including collecting market data, signing requests and verifying health.

The main goal was to guarantee fixed behavior across all platforms. Our goal was to avoid repetition of logic, reduce the number of errors, and accelerate development. This means: incorporate SDK on the current web into original mobile applications.

However, the SDK was written in Typescript and was not originally designed for use outside the browser. This is our primary technical challenge.

“We discussed all possible implementation options in detail. Taking into account the full context, we decided to try to integrate the full SDK into the original applications. This was a new area for us, but we were ready to address this unconventional task.”

–Alexander Kiaikin, CTO OF CleverPOMPKIN

The first step was to include the entire JavaScript engine in the app. On iOS, we were able to reach the built -in javascriptcore, but for Android, we had to search for an alternative. We chose liquidcoreIndependent JS engine and open source.

To ensure a smooth reaction with the SDK from the original code, we have developed a platform cover via platforms that facilitated the communication between the SDK and the logic of the application business.

The challenges we faced:

• Not all JS engines support the latest construction of the ecmascript phrase: we had to reduce the level of Typescript Transpality to the compatible Javascript of the engine.

• JS engines do not have direct access to system capabilities: things such as HTTP, Webskets and network connections must be executed in the original code.

As a result, SDK has been modified. It is now used as external interfaces for the logic of the network, and the HTTP and Websket reactions are dealt with on the Swift/Kotlin side, while the logic of processing remains in JavaScript. In the end, the logic of work remained within the SDK, and the low -level network operations were delegated to the original code. This allowed us to maintain architectural consistency and accelerate development without prejudice to performance.

Portfolio integration: implementation of deposits and clouds

The exchange of encryption cannot work without depositing withdrawal functions. Our goal was to make this process intuitive and safe.

To enhance the user’s comfort, we added support to transfer flexible assets between networks using li.fi The service, which allows users:

• Transfer of assets from one network to another.
• Do this in only a few clicks, without manually searching for bridges or understanding the complex logic of the chain interactions.
• Choose the best option based on price/speed preferences.

We chose to use deliberately Wevief. Although the app is designed with original technologies, the separate JavaScript engine is used for SDK processes, webief allowed us to quickly integrate the Li.fi interface without the need to re -implement the user interface. This enabled a fixed user experience across both web and mobile platforms and facilitate the update of deposit functions.

At the same time, we had to think about the details of working with the encryption portfolios in a mobile environment. To contact and interact with the governor, we used EIP-1193 (ETHEREUM JavASCRIPT API)It is the standard that determines how to combine applications with Ethereum portfolios.

The mobile phone application supports several methods of communication:

• Via metamask
• Import an external portfolio using a Seed or Special key.
• Create a new wallet directly inside the application.

Regardless of the selected method, the application can serve as a deposit portfolio provider. This allowed us to reuse the current web interface without the need to create a separate system to apply the mobile.

Note*: In the current stage, Evedex works with networks compatible with ETHEREUM only, so alternative standards have not been seen.*

The main summary and meals

It turns out that the incorporation of SDK Typescript into an original mobile application is an unconventional and sometimes difficult task, but it allowed us to ensure a steady behavior in all basic systems, eliminate logical duplication, reduce the number of errors, and to speed up the development process significantly:

• SDK can be adapted to the Internet for mobile phones, but it requires architectural review and appropriate logical decomposition.

• Separation of work business at the system level is necessary for sustainable architecture. In our case, the original code takes over network operations and continues Websockket, while SDK only focuses on the logic of work.

• Using standards such as EIP-1193 It helps to maintain the compatibility of the wallet and simplify the implementation.

• Combining the original code, the Javascript and Webief engine gave us the right balance between the speed of development, flexibility and user experience.

“It wasn’t easy, but now we know how exactly how to include SDK Typescript in an original encryption app. This is not only the effective development but also gave us an architectural basis for the future.”

– Vlad Comesarov, CTO in Evedex

The development of the Evedex Mobile app was not just launching another product, but rather a real technological experience that can now serve as a starting point for other teams looking for unconventional solutions in the world of encryption.

Written by:

Vlad Comesarov, CTO OF EVEDEX

Alexander Kiaikin, CTO OF CleverPOMPKIN