DEV Community: Openware

Introduction to OpenDAX – A Fast, Secure & Highly-Scalable Open-Source Crypto Exchange Engine

Akshat — Tue, 17 Jan 2023 05:58:46 +0000

OpenDAX is a modular platform for building, deploying, and managing crypto exchange services. It is fast, cost-efficient, and has a built-in liquidity solution that can scale to demand. This article aims to understand the OpenDAX platform and learn how it solves problems of the Fintech exchange ecosystem.

Introduction

Starting a crypto exchange platform is a difficult & risky business endeavor, primarily due to two reasons. First is the cost required for developing and maintaining the software infrastructure, and second is obtaining the crypto liquidity to make the exchange functional. It only gets more difficult when you realize the crypto exchange landscape is highly-competitive and the major chunk of market share lies with the big exchanges who fight for slivers of user share and liquidity.

This situation has siloed the entire crypto space and has kept new exchanges or brokers from entering this space. OpenDAX is a unique white-label exchange software built to resolve this problem. It is a self-managed cloud-native solution that cuts down the cost and resources required in building, managing, and bringing liquidity to exchanges. OpenDAX takes care of everything under the hood so that you can focus on the growth of your business.

Let’s dive deeper to understand how the OpenDAX platform can help you achieve your business goals and what business problems it solves.

About OpenDAX & Yellow Network

OpenDAX is a crypto brokerage engine platform you can use to build your cryptocurrency exchange. It includes a self-hosted solution for enterprises, a managed crypto exchange platform on the cloud, and a free solution for developers with complete access to public repositories.

The UI components of OpenDAX are freely available as part of the WebSDK – which can be used to create custom design configurations for the platform. Additionally, most of the OpenDAX stack is highly open-source and is based on technologies like Supabase, Next.js, and React. All these things together make OpenDAX super extensible and customizable (to be covered in later articles).

OpenDAX is still a product in development, and would soon come with built-in shared liquidity with the support of Yellow Network. The Yellow Network is a peer-to-peer mesh overlay that interconnects multiple blockchains through state channels. In doing so, it unlocks the liquidity of isolated networks and provides lightning-fast trading speeds. After the public release of the Yellow Network, brokers would be able to harness this deep cross-chain liquidity on their OpenDAX nodes.

Together, OpenDAX & Yellow Network will provide a strong self-managed & supportive ecosystem for crypto exchange businesses to work on, so they only have to focus on their business growth and ideas.

What Makes OpenDAX Special?

OpenDAX abstracts away the complexities of handling & operating a crypto exchange by providing handy and user-friendly tools. Here’s everything that makes OpenDAX special as a crypto brokerage platform.

Quick Setup

OpenDAX is available on AWS, GCP, Azure & Digital Ocean as a pre-configured image you can launch in about 15 minutes. The setup requires only the basic knowledge of cloud platforms, while the OpenDAX interactive installation package takes care of the rest.

Hybrid Model

OpenDAX is hybrid in design, as it provides the security and transparency of decentralized exchanges with the speed and immense liquidity pools of centralized exchanges. For brokers OpenDAX provides the same easy user-interface as any CEX, while giving users the advantage of the extra security. It is the best of both worlds.

State Channels

State Channel is a cutting-edge virtualization method that takes data and processing off-chain to facilitate fast transaction speeds and cross-chain support. This technology allows OpenDAX to fill orders while allowing precise high-frequency trading.

Aggregated Liquidity

By becoming a part of the Yellow Network as a broker, you can aggregate deep liquidity for your crypto exchange, saving you from investing any capital in market makers or other solutions.

Hassle-Free Maintenance

Maintaining cryptocurrency exchanges is difficult as it requires the maintenance of individual blockchain nodes. OpenDAX cloud is a managed solution that takes care of everything under the hood so that you can focus on the business side of things.

High-Performance

OpenDAX was designed with performance in mind. Its matching engine can quickly and accurately fills trade orders. OpenDAX Kubernetes pods can also scale with your business as the demand grows.

OpenDAX’s Tech Stack

OpenDAXv4’s tech stack is highly modular, and the entire exchange engine is based on the microservice architecture. Individual components are loosely coupled, and there’s no risk of accidentally breaking the software should you try to extend it.
It also means that the system is fault-resistant and self-healing – since microservices don’t rely on each other, and there’s no hard linking.

Customizable Frontend & Backend

The front end consists of the trading UI, wallet management service, and administration interface for low-level control over the exchange. The UI components used by OpenDAX are the same as those present in the WebSDK. These components are coded in React and can easily be customized or extended with other components.

The backend consists of the Finex trading engine, which performs order matching at lightning speeds, and smart contracts that take care of the user fund deposits and withdrawals. The front end and back end are tied together through Next.js, a full-stack react framework where you can create your APIs, pages, and endpoints, giving you complete control over the customization of your exchange.

The benefit of using Next.js over plain React and Node.js is SSR or Server-side rendering. Your exchange is going to perform well, even on low-spec client devices. It also means your exchange would benefit from search engine optimization (SEO) as SSR renders pages in a static-like manner that is friendly to the Google spider bots.

Authentication, APIs, and Key Management

For secure key management, OpenDAX comes integrated with Vault – an industry standard for securing keys and other secrets. GoTrue is used to authenticate all APIs, while Kong serves as a gateway and helps in scaling those APIs.

OpenDAX also comes integrated with Supabase – an open-source Firebase alternative. It is a BaaS (backend as a service) tool that helps you create and manage your software's APIs.

Maintenance & Scaling Infrastructure

Docker is a DevOps containerization service that separates your code from the infrastructure it depends on. Docker is often coupled with Kubernetes, which helps you rapidly deploy, scale and manage your containers. Together, they administer rapid software delivery and take care of its scaling.

OpenDAX comes pre-configured with these tools, and they take care of the scaling as the demand for your software grows. It also means you can create production-grade workflows for your development team if you plan to extend the software stack.

Cloud Native

Hosting an exchange on bare-metal servers is cost and resource-intensive, so OpenDAX has been developed as a cloud-native solution. OpenDAX is available as a free image on AWS, Azure, and GCP, and you are only required to pay as you use the hosting. It also means you don't have to worry about scaling, downtimes, or other security threats, as these cloud services take care of protection and reliability.

If you want to try the installation immediately, check out the step-by-step video guide for the OpenDAX v4 mainnet installation:

Key Benefits of OpenDAX

The crypto exchange ecosystem is plagued with many technical problems that have made launching and operating crypto exchanges difficult. OpenDAX aims to resolve these issues.

If you like it visual, here’s an OpenDAX v4 video webinar by Openware CEO & Founder Louis Bellet:

KYC & AML Compliant

Even now, compliance remains a huge problem in the crypto exchange space. And although KYC and AML solutions exist, standards vary across countries. OpenDAX comes with a KYC integration protocol using which you can easily use a KYC supplier service with your exchange.

You can also customize these solutions to suit your own needs.

Cutting Down Business Costs

Because of the other benefits of OpenDAX in infrastructure, development, security, and liquidity, it can massively cut down the cost required to launch and operate a cryptocurrency exchange business. That includes minimizing OPEX & CAPEX costs, making OpenDAX stand out from other similar solutions.

Perfect For Businesses of All Sizes

Whether your exchange is operating globally or is serving a small area, OpenDAX can scale to serve audiences of all sizes. OpenDAX can be operated by small and large teams, making it easier to start a crypto exchange business.

Final Thoughts

This article sums up the OpenDAX crypto exchange platform and its technical and business benefits. If you have any doubts or queries regarding the engine, feel free to reach out to the extensive OpenDAX community. In the upcoming articles, we will explain how you can deploy, manage and extend an OpenDAXv4 mainnet instance on the cloud of your choice.

Feel free to experiment with the installation, ask your questions to the community, and let’s build the Web3 Internet of Finance together!

Developer’s Guide To Web3 Security

Akshat — Thu, 03 Nov 2022 11:50:28 +0000

Learn About The Industry’s Best Practices, Security Roles, And How To Approach Web3 Security As a Developer

Web3 has finally entered the mainstream consumer space; and its effect is undeniably strong. Even the big tech realizes this, as it has started building the supporting infrastructure. This moment also marks a major shift in the tech landscape as we transition from the company owned Web2, to the user-owned Web3 model.

But as with any new technology, Web3 comes with a whole new set of challenges, and security remains a big issue. According to Certik– a leading Web3 security firm, DeFi has lost more than $2 billion in the first two quarters of 2022 alone, which just goes to show how bad the situation is.

Cyber attacks have become increasingly common and there has been a parallel surge in demand for security professionals in the industry. Since Web3 is still in its nascency, this presents itself as a perfect opportunity for people who are looking to get a headstart in this space.

How Secure is Web3?

Security in Web3 revolves around two central ideas, decentralization and strong encryption. These features are native to the blockchain technology, which is a self-protecting database that resists mutation due to its design. But unlike traditional databases, a blockchain has several layers of protection.

Every piece of data on a blockchain is a transaction, and to verify its authenticity a blockchain uses a ‘Consensus Mechanism’. This algorithm requires all the miner nodes on a blockchain to reach a common ground for a transaction before it can get recorded. Additionally, every transaction is asymmetrically encrypted, and its ownership can be justified.

The security of a blockchain is established on one simple fact; that the computing power required to create fake transactions has to be greater than the combined processing power of all participating miner nodes. As the blockchain gets bigger and computers naturally get faster, the cost of brute-force or data corruption attacks on a blockchain becomes impossibly high.

But even with this security, Web3 systems are still constantly at the receiving end of cyber attacks. So much so, that it has painted an overall grim picture for some people in the community. And this raises the question, is Web3 really more secure than Web2? The short answer is Yes.

The reasoning behind this is quite simple; as most of the security breaches that we see in the blockchain world today (with the exception of some) are not related to the functioning of the blockchains themselves. These attacks mostly occur on application layer, or from newer technologies built around the blockchain that facilitate cross-chain communication.

Web3 Security Vectors

The list of attack vectors in Web3 is long and constantly growing; and for the sake of this article, we’ll limit the scope to only those pathways which depend upon the functioning of Decentralized Applications

Smart Contract Vulnerabilities

Although Web3 has been around for a while now, the ecosystem for writing smart contracts is immature. Writing blockchain apps requires a deep understanding of smart contract programming languages, and an in-depth knowledge of blockchain networks. And due to the absence of a mature ecosystem, developing enterprise-grade blockchain apps is quite difficult.

The EVM is still experimental in nature, and bugs are easier to induce than they are to detect. A good example of this would be the re-entrancy attack which only takes the programmers to incorrectly structure the sequence of operation for the vulnerability to take effect. SWC registry records some of the most common vulnerabilities which we’ll cover in a little detail later.

Programming vulnerabilities are the leading security concern even today. Smart Contracts ideally need to go through several stages of security audits, before they are considered ready for production.

DeFi Semantics

Web3 provides a native ecosystem for finance as cryptocurrencies are embedded right into its framework. However, this has also created problems for developers and businesses as now attackers have an easier, and more direct access to it. Additionally, the functioning of a DApp is directly dependent upon the liquidity of the environment; which, as of today, is quite poor.

This allows more sophisticated, semantic-based attacks to occur. One of the simplest forms of this attack is market manipulation in DEXs to create artificial pumps and dumps. Attackers can make use of features of DeFi like lending, borrowing, flash-loans and combine them together in ways to attack the entire system.

The price oracle manipulation attack also comes under this category, where attackers use the weakness of on-chain oracles to manipulate prices either through flash-loans or borrows. This is now used to artificially increase the prices which leads to liquidations and a steep fall in the price of the token.

Compared to smart contract weakness based attacks, these are harder to detect. And to fully understand and assess risk, businesses need to hire experts who understand the high-level semantics of a DeFi application.

Blockchain Trilemma

Unlike the other two weaknesses, Blockchain Trilemma is related to the weakness of blockchain and its surrounding technologies. And it refers to the notion that blockchain systems cannot simultaneously be highly scalable, secure and decentralized. Until recent innovations, this has more or less held true especially in the case of Layer–1 networks.

The idea originates from the CAP theorem, which was formulated in the 1980s. And according to the theorem, amongst security, scalability and decentralization; a distributed system can only provide two of the features at once. Blockchain being a distributed system, follows this theorem.

Centralization of resources improves speed, but it also puts all responsibility on a single entity which reduces security. On the other hand, decentralization improves security, but slows down a network considerably. Most of the high TPS Layer–1 networks still suffer from this problem. The trilemma is further proven right in the case of CEXs and DEXs, where each have their benefits over the other.

However, recent innovations in the blockchain space have created a pathway for Layer–1 networks to scale while keeping their decentralization and security intact. Layer–2 scaling solutions like state-channels, sidechains and nested chains have been able to greatly improve the scalability of Layer–1 networks without harming their security.

Ensuring Security in An Unstable Environment

Web3 gets attacked often because it is still in its elementary phase, and these attacks are more like growing pains. Opposed to Web2 applications, which follow the conventional client-server architecture, the rules and frameworks concerning the security of Web3 apps, are still under development.

Moreover, since there’s no formal Web3 consortium or a central standards organization, a lot of development around the security of Web3 applications is scattered and distributed amongst several independent organizations. As such, securing Web3 applications currently is more challenging than Web2.

Even some of the most popular products like Binance, Uniswap, tornado, and Harmony face regular attacks. While ensuring complete security in this environment is unrealistic, we can get close to it by following simple rules; Given below are the steps you can take as a developer to secure your Decentralized Apps.

Following The Design Standards

Web3 companies have different solutions for a single problem, and a lot of them are new, and largely untested in real world environments. This is bad from a security standpoint and puts the business and its customers at risk.

However the risk can be reduced significantly by adhering to the coding standards, and following some rules. Colloquially speaking, design pattern is a general reusable solution to a given problem; whose security is well established.

When it comes to writing smart contracts, there are design patterns which deal with different aspects of a DeFi application such as, optimizing gas costs, safely handling transactions and securely managing storage. Smart Contract developers can make use of the SWC registry as their go-to handbook for writing coherent, and secure code. We’ve discussed a few of those below.

Withdrawal Pattern

Handling transactions is one of the most trivial but sensitive tasks, and there are several ways to do it. Solidity provides send, transfer and call functions for transferring ether through a smart contract.

Although all three of these functions are secure and can be used for making transfers, in practice, there are certain quirks about making transactions. We’ll use the smart contract below (taken from Solidity Docs) to serve our example.

pragma solidity ^0.8.4;

contract SendContract {
    address payable public richest;
    uint public mostSent;
    error NotEnoughEther();
    constructor() payable {
        richest = payable(msg.sender);
        mostSent = msg.value;
    }

    function becomeRichest() public payable {
        if (msg.value <= mostSent) revert NotEnoughEther();
        // This line can cause problems (explained below).
        richest.transfer(msg.value);
        richest = payable(msg.sender);
        mostSent = msg.value;
    }
}

Source : Solidity Docs – Withdrawal Pattern (Become The Richest Contract)

The following contract makes a direct transfer to the receiver, and this puts the entire burden of transaction on the sender. Which means, if the transaction fails, it would stop the functioning of our contract, and if any of the other users have their funds in this DApp, they would forever be locked.

Luckily for us, the fix is quite simple, our goal here is to not bear the responsibility of the transaction.

function becomeRichest() public payable {
        if (msg.value <= mostSent) revert NotEnoughEther();
        pendingWithdrawals[richest] += msg.value;
        richest = msg.sender;
        mostSent = msg.value;
    }

    function withdraw() public {
        uint amount = pendingWithdrawals[msg.sender];
        // Remember to zero the pending refund before
        // sending to prevent re-entrancy attacks
        pendingWithdrawals[msg.sender] = 0;
        payable(msg.sender).transfer(amount);
    }

As can be seen above, the simplest fix is creating a function which allows the fund receiver to withdraw their amount from a mapping which holds the information of their withdrawal. Withdrawal Pattern provides a safe way to transfer ether so that it does not block the functioning of a smart contract in-case of a failure.

Avoiding Re-entrancy

Re-entrancy is a vulnerability that arises from the way we structure code in a smart contract. It works by stopping the execution of a payable function by trapping it inside a recursive call. It can be better understood using the example below.

mapping (address => uint) private userBalances;

function withdrawBalance() public {
    uint amountToWithdraw = userBalances[msg.sender];
    (bool success, ) = msg.sender.call.value(amountToWithdraw)(""); // At this point, the caller's code is executed, and can call withdrawBalance again
    require(success);
    userBalances[msg.sender] = 0;
}

Source: Consensys.org – Reentrancy

The withdrawBalance function allows the users to withdraw their funds, however, it updates the user fund allocation after making the transfer. This means a user can drain this contract of all its funds by trapping eth transfer inside a recursive call. And this is done through a fallback function which calls the withdrawBalance method recursively.

This vulnerability can drain a contract of all its funds, and is a classic example of how smart contract programming is different from Web2 development and design. A simple fix would be to update the state variable before the transfer takes place, as in the example we’ve provided below.

function withdrawBalance() public {
    uint amountToWithdraw = userBalances[msg.sender];
    userBalances[msg.sender] = 0;
    require(amountToWithdraw > 0);
    msg.sender.call.value(amountToWithdraw)(""); // At this point, the caller's code is executed, and can call withdrawBalance again

}

Locking Unlocked or Floating Pragma

Pragma is a compiler directive which tells EVM about the versions of Solidity our smart contract can execute on. Unlocking the pragma means the smart contract is open to execute on untested as well as experimental versions of solidity. And this can introduce fatal bugs to our application.

pragma solidity ^0.8.0;
// Should be written as
pragma solidity 0.8.25;

The first line suggests that all the versions of the solidity compiler starting from version 8, can be used for executing this contract. This has been fixed in the third line, where the pragma is locked. At the time of writing this article, Solidity version eight remains the standard.

Unencrypted Data on-chain

A common misconception amongst beginner blockchain developers is that the contents of a private marked variable are hidden, however, that’s not the case. Private in the context of blockchains and smart contracts means that the variable is inaccessible to other contracts.

The data of all the variables of a contract is stored on the blockchain and can be viewed by anyone. Although data storage contracts exist, they’re not generally built for storing sensitive information. And the developers must ensure that any sensitive data stored on a blockchain is encrypted.

Preparing For Failure

Blockchain technology is experimental, and it is bound to fail. Even flawlessly written code is susceptible to vulnerabilities and underlying architecture problems – which surface up from time to time. In the world of Web2, such situations would usually be handled through patches or hot-fixes; but since a blockchain works differently, security needs to be implemented by design.

What this means is that we need to make our smart contracts tolerant of failures. And this is important because a blockchain is an immutable database, and a smart contract that has once been deployed, cannot be deleted. There are three aspects to failure control which a smart contract needs to follow to gracefully deal with such issues.

Pausing the contract – This works like a circuit breaker for when security has been breached. It freezes the functioning of the application and ensures no further exploitation takes place.

Rate limiting – As the name suggests, it means limiting the maximum usage of the different metrics in our app. This includes fund withdrawals, cooldown time, and successive withdrawals.

Upgrade path – Designing the smart contracts to be upgradable is an absolute must. This also means having an effective upgrade plan and a procedure for introducing improvements or bug-fixes.

Failure control protocols are built into all apps before they are rolled out for production, and it is a life saver in situations where there is a catastrophic failure or vulnerability in the system. The recent Binance bridge attack and the handling of the situation goes to show how important a failure control procedure can be.

On October 6th, the Binance bridge was drained for as much as $500 million. These funds were then moved across wallets on the smart chain network to disperse and make it hard to track. Binance prevented any further exploitation of their bridge, firstly by pausing their smart chain network, and then introducing new changes with the fork which solved the previous vulnerabilities.

Designing Apps on Layer–3 Blockchains

Layer–1 represents the first layer of blockchain and it manages all the essential tasks of the network. Because of the many operations that this tier has to manage, it faces issues regarding scalability. These problems are mitigated through Layer–2 scaling solutions such as state-channels, sidechains and plasma-networks.

Layer–2 networks work by forming an arrangement which decouples acknowledgement and settlement of data. This boosts the network speed and also introduces interoperability. But despite offering higher speeds Layer–2 networks have failed to gain mainstream popularity, as they do not inherit the liquidity of their parent chains. Good liquidity triumphs over gains in speed and apps continue to be developed on Layer–1 networks.

Over the years, this has created many problems for businesses. The absence of a mature ecosystem has made the development of blockchains apps complex and expensive. On one end, developers can reap the benefits of high liquidity, and on the other they can make use of high scalability and interoperability to offer smoother user experiences.

These problems are now solved by Layer–3 networks, which perform the task of connecting, pooling liquidity of Layer–1 & 2 networks. And in doing so, Layer–3 networks get rid of the redundancy that plague blockchain development. Layer–3 acts as an application layer and it simplifies the development of decentralized apps.

Layer–3 protocols like the Yellow Network bring the much needed reliability and security to Web3. By providing deep liquidity, high interoperability and scalability, Layer–3 creates an ideal working environment for DApps. Deep liquidity offers protections from price manipulations while the SDK provides a simpler interface for making apps interoperable.

The Web3 Security Stack

Security is a broad field and it requires knowledge of a diverse set of skills. Although there are many languages and tools to cover, you can get started using just a few of these. And depending on your goals and area of interest, your tech stack can have different variations of the one we have mentioned here.

Blockchain Programming Languages

Based on their use, blockchain programming languages can be divided into two categories. Application programming languages are used for writing smart contracts and developing decentralized apps. Whereas Low-Level languages are used for the development of blockchain networks.

Go – Imagine C, but with a modern syntax, memory safety, structured typing and garbage collection; well that’s exactly what Go is. Go was developed at Google as a “modern C” . It is used for building fast and reliable modern blockchain systems.

Go’s low level capabilities allow the developers to have fine-grain hardware control, while its modern syntax and features boost productivity and make long term maintenance of blockchain products easy.

Rust – Rust was developed by the Mozilla corporation to be the modern C++. It is a popular contender to Go for blockchain development as it offers similar features and is in use in major chains such as Solana and PolkaDot.

But unlike Go, Rust has controllable memory management. Developers can harness this feature to make extremely fast and efficient blockchain systems. Additionally, Rust is also in popular use as a smart contract programming language due to its easy to learn syntax.

Python – Unless you’re living under a rock, Python should be no stranger. It is a general purpose programming language with a simple syntax, which has been designed keeping code readability in mind.

It has tons of libraries and can be used to write smart contracts for blockchains like AlgoRand. It is also heavily used in smart contract vulnerability tools such as Mythril and Slither which we’ve discussed in the coming sections.

JavaScript – JavaScript is the native language of the internet, and it is here to keep that title. JavaScript offers first class support for blockchain development and has been a direct inspiration for languages like solidity.

It has a small learning curve and by far the best support for blockchain app development. Together with npm and the NodeJs ecosystem, JavaScript is a powerhouse of tools which you can use to easily bootstrap a blockchain app in seconds.

Solidity – When it comes to writing smart contracts, Solidity is arguably the most popular programming language. It is native to the Ethereum ecosystem and is supported by other major blockchains such as Avalanche and Binance.

It bears many similarities with the curly-bracket languages like Java and JavaScript and is fairly easy to grasp. Another thing to note, is that amongst all smart contract programming languages, Solidity has the best support and the most mature ecosystem of libraries and frameworks.

Vyper – Vyper is a relatively new pythonic language which has recently gained traction. It has an easy syntax and its compilation targets the EVM. Vyper was developed to make blockchain programming less complex, and to eliminate the bugs that arise because of the code structures in Solidity.

Motoko – Although less popular, Motoko is used for application development for the ICP blockchain. The Internet Computer is a blockchain that aims to reform the centralized internet. It is a decentralized cloud computing platform where motoko is used to “model” protocols and apps.

Yul – Yul is an Intermediate EVM based language which was designed to make optimisations on Solidity code. Its primary purpose is to improve the gas experience and produce more efficient target bytecode which executes on the EVM.

Security Analysis Tools

Security analysis tools are the swiss army knife in the world of infosec, and are of great help to security engineers and developers alike. Unlike programming languages, these tools have a smaller learning curve and are fairly easy to use.

Slither – Developed by Crytic, it is the most popular free tool used for static analysis of solidity code. It’s written completely in python and features a vast array of vulnerability detectors. Slither also has its own API which the developers can use to write custom vulnerability analysers.

Mythril – It is a part of the Mythx tool suite provided by Consensys for enterprises. But unlike Mythx, it is completely free of use. It supports symbolic analysis and SMT solving for smart contracts. Mythril works on bytecode and supports multiple EVM compatible blockchains.

Echidna – Echidna is another famous tool developed by Crytic. It is written in Haskell and is used for Fuzz-testing Solidity contracts. It runs a series of tests against smart contracts to test their security in real-world scenarios. Echidna is modular in nature and can be extended with custom tests.

Manticore – Manticore is strictly a symbolic execution tool which is used to explore all the possible states a smart contract can reach within the range of its capacity. It also records inputs which lead a contract to a given state in case of errors.

All these tools are a part of the Ethereum security toolbox, which presents them in a singular docker image. This makes it all the more convenient to set up and work with them collectively rather than installing them as separate packages.

Blockchain Development Frameworks

Outside the realm of Web3, blockchain systems have a ton of uses and have been in popular use by the industry for over a decade. Since developing a blockchain system from scratch takes time and is quite expensive, the industry has collaborated and come up with solutions for developing custom blockchains using pre-existing tools and frameworks.

Hyperledger Fabric – Hosted by the Linux Foundation, Hyperledger Fabric is a permissioned blockchain platform built for the enterprise. It has a modular plug-and-play architecture and is in use by companies such as Walmart and Sony. It offers a ton of pre-built consensus mechanisms and configurations, along with the ability to add custom features on the go.

Ethereum – Ethereum is the world’s first and arguably also the most popular blockchain development framework. It offers the most advanced set of features, and a Turing complete bytecode interpreter called the EVM. Ethereum forms the basis of modern blockchain networks today and has a thriving community.

EOSIO– EOSIA is a blockchain development framework that’s been developed to meet high demands. It is a developer-friendly and highly configurable platform which is used for developing high-throughput permissioned blockchain networks. EOSIA uses C++ for smart contracts and has great community support.

Web3 Security Roles

Security is about connecting the dots, protecting systems and creating dependable recovery plans. Compared to development, security roles are more serious, and given the current scarcity of talent in Web3, the demand is high. A lot of these roles have overlapping responsibilities and this makes transitioning from one role to another quite easy.

Smart Contract Auditor –As the name suggests, your job is to analyze smart contracts, detect vulnerabilities and bullet-proof the code before it goes for production. Additionally, some companies might also require you to mentor fellow engineers over the best security practices.

Blockchain Security Engineer –As a security engineer your job is to secure the entire end to end blockchain. This includes auditing smart contracts, securing blockchain infrastructure, creating custom security tools as well as conducting in-depth research on the latest attacks.

Security Lead – Similar to the security engineer role, your job is to secure the entire blockchain infrastructure. But this goes well beyond that, as you are also required to create custom infosec plans, and make important decisions related to the security of the business and its clients.

Resources To Learn And Practice Web3 Security

Creating a portfolio for security roles is slightly tricky as this area requires a lot of experience, and is usually not very beginner friendly. Luckily for us, there are plenty of resources online where we can practice and testify our skills for free. Moreover, a lot of these platforms offer bug-bounty programs to incentivise learning and boost participation

Damn Vulnerable DeFi – It is a hacking war-game where users/participants go through a series of smart contracts (equivalent of levels) with the purpose to either stop their functioning, drain them of funds or cause other anomalies.

Ethernaut – Similar to Damn Vulnerable DeFi, Ethernaut is a hacking wargame inspired by overthewire. It also has a historical catalog of some of the biggest attacks which appear as levels.

Immunefy – Backed by Chainlink and Sushiswap, Immunefy is a Web3 bug bounty program founded in 2020. It offers some of the biggest bounties from major Web3 orgs that are updated frequently.

HackenProof – Hackenproof is Hacken’s bug hunting program. Hacken is a leading name in Web3 security, and just like Immunefy, Hackenproof offers huge bounties and is associated with big orgs like FTX and CoinGecko.

If you prefer a structured way of learning then there are plenty of DAOs and Web3 cohorts which offer tutored sessions. They also have an active community which will help you along the way at every step.

Buildspace – Buildspace is perhaps one of the most famous DAOs. Whether you’re experienced, just starting out or have cool ideas to work on, Buildspace is the perfect place to start with Web3 as quickly as possible.

Learn Web3 – With an active community of over 50k members (and growing), Learn Web3 is the fastest growing DAO. It offers curated learning paths and sponsored tracks to help accelerate your learning.

Closing Thoughts

Security is of paramount importance to every business and in order to become truly disruptive and viable, Web3 needs to become more mature. Ultimately, the success of Web3 is tied to how secure it is. And just like the internet, our requirements have to evolve and adapt to this new decentralized and transparent web.

Since Web3 is extremely fast paced, to keep ourselves secure we need to stay ahead of the curve. As a security professional, you need an abstract understanding as well as nuts-and-bolts knowledge of the technology at hand. And while there’s no secret sauce to achieving complete security, an appetite for learning definitely helps.

State Channels Still Beat All Other Layer-2 Scalability Solutions

Julie Plavnik — Mon, 13 Jun 2022 06:08:22 +0000

We can’t help writing about what we work on in Yellow Network. Previously, we talked a lot about the issues of blockchain interoperability and crypto market fragmentation. In this article, we will cover another not less significant problem of the industry — the blockchain scalability and will focus on state channels as its most prominent solutions. Here we would like to explain these things simply but in-depth and showcase how we use state channels to make cross-chain transactions instant and low-cost. Let’s dive in!

Why is scalability so important for blockchain?

The more crypto adoption is gaining momentum, the more it becomes challenging for blockchain networks like Bitcoin and Ethereum to provide participants with the due user experience. The original designs of the networks get less and less suitable to process the growing transaction numbers without losing on speed and increasing transaction fees. It's good to remind here that the Ethereum network can handle ~15 TPS (transactions per second), and the Bitcoin network can handle ~5 TPS. That was great at the beginning but no longer feasible at the present moment.

Clumsy and semi-functional network design becomes a major turnoff for potential users considering joining a network, as well as for existing users to keep continuously exploring a network. From the marketing perspective, it's literally killing the user retention rate.

Herewith, the growing number of decentralized applications (dApps) creates an extra load on networks. As dApps are getting more complicated, they require more computational power to function, but at the same time, they seek faster transaction speed and lower fees. So as we see here, blockchain scalability and its mass adoption are pretty interdependent things. This is why solving the scalability problem is so vitally important for the whole crypto industry to keep progressing and widespread.

How do we solve scalability issues in blockchain?

Roughly saying, there are two main approaches to handling the scalability problem. These are "off-chain" and "on-chain" approaches - a few words on each.

On-chain

"On-chain" means that we make some improvements on the blockchain level (Layer 1). Here we can, at least, try to innovate the existing consensus algorithm, replace it with a better one (f.eg. Proof-of-Work with Proof-of-Stake), or create a groundbreaking new one from scratch. The end goal here would be to achieve better bandwidth and throughput and decrease the computational power required for transaction processing. As an example, Ethereum is currently undergoing on-chain scaling through sharding.
Briefly, sharding is the process of splitting a database horizontally to spread the load. In the Ethereum context, sharding will reduce network congestion and increase the number of transactions per second by creating new 60+ chains, known as "shards." This will also reduce the load for each validator, as they will no longer be required to process the entirety of all transactions across the network. The consensus mechanism will move from highly computational and clumsy Proof-of-Work (PoW) to Proof-of-Stake (PoS) with lower hardware requirements.

Off-chain

While on-chain scaling is a great way to go in the long term, however, this is an extremely complicated task. It requires massive efforts and enormous time (it can take years) to get accomplished. A way more flexible alternative to on-chains is "off-chain" solutions that do not modify the base blockchain. Off-chain or interchangeably, Layer 2 solutions, are built upon blockchains and exist in the form of their superstructures. The main job of off-chain solutions is to improve users' transaction experience by getting rid of existing blockchain networks bottlenecks, like slow speed and high fees. The core principle of the off-chain solutions' work is moving transaction sessions out of the blockchain and publicly recording only their final balance. The most applied off-chain solutions are:

state channels
sidechains, and
rollups. Below we will cover how they differ while focusing on state channels. Other examples to add here could be validiums and Plazma. However, they are less common and won't be addressed in this article.

What is a state channel?

A state channel is a mechanism enabling transacting parties to interact off-chain and further record with a blockchain only the final state between them. It's like two traders would make x-number of transactions between each other during a day, and by the evening, would officially post the final net balance between them. This trick allows to overcome all the challenges arising out of blockchains' clumsy nature, making transactions fast and cheap while still being the same secure as if they were conducted directly on-chain. Here is how to use them:

1. Opening

To initiate a state channel, counterparties shall deposit a required amount of collateral (i.e., funds) with a multisig contract. Then the collateral of both will be deducted and sent to a smart contract running the state channel. A deposit transaction will deduct money from the party's accounts and transfer it to a particular smart contract that cooperates with this state channel. This depositing mechanism is aimed to ensure that no double-spending will occur neither on the on-chain nor on the off-chain sides of interactions. And this is where the first fee payment happens.

2. Transacting

Since a state channel is open, parties are free to conduct the transactions as much as they prefer through cryptographically signed messages. Their "P&L" inside the channel will alter with each transaction that happens.

3. Settlement and channel closing

Finally, any party can initiate an on-chain transaction when all the transactions are done. For that, both parties should agree on the final state of the channel and submit it to the blockchain for the record. And now it's time for the second fee payment.

What if there is a dispute?

If a participant rejects confirming the final state or simply doesn't respond, the other party can register a dispute on-chain. Then this party will have to submit to a smart contract the latest state of their digitally signed transactions recorded off-chain to prove their claims are legitimate. Another party can disagree that the provided state is the latest and submit the more updated state in response. In the end, the parties would turn to the settlement or the force-execution phase (depending on the specifics of a channel design).

Killer features of state channels

Summing up, the key benefits of state channels are:

High throughput: moving transactions off of a chain allows to dramatically reduce the computational load of a Layer 1 network without losing on security
Strong privacy properties: transactions within a state channel are not publicly broadcasted. Only the opening and closing of a state channel goes into a blockchain.
Instant settlement: once both parties sign a state update, all the transactions between them are deemed to be completed. No miners' confirmations are required for that.
Low fees: transactions happening inside a channel do not require any computational power, and therefore they are cheap.

Limitations of state channels

Like with any technology, the application of state channels has its limitations. Basically, these limitations look as follows:

Pre-defined counterparties requirement: A channel cannot be used to send funds off-chain to users who are not the channel's participants.
Availability requirement: They have to be available in case their counterparty wishes to rigger settlement.
Insufficiency for some types of real-time interactive applications, when the parties get into a dispute and have to resolve it on a blockchain (i.e., adjust to slow blockchain speed).

State channels implementation (2015–2021)

Here is a quick historical data on how state channels have been implemented:

Examples of state channels implementation in 2022

Here I would just share some great examples of ongoing projects relying on state channels, including ours (why not?😊):

Yellow Network - a non-custodial multi-chain trading environment and automated clearinghouse, providing a user with aggregated crypto liquidity, price feed, and seamless high-speed cross-chain transactions at minimal fees.
Perun Network - a state channel application that supports payments, microservices, IoT, gaming, and other business use cases.
Raiden Network - an instant payment solution with low fees compatible with all ERC-20 tokens.
Graph Protocol - a blockchain indexing and querying service utilizing state channels for settling rewards for node operators (indexers).

State channels vs. Payment channels

Payment channels are a specific use case of state channels. They are only designed to support payments between two or more parties. The most well-known example of payment channels is Lightning Network. Comparing payment channels with state ones, the latter have much broader applications and are not limited only to payments. For example, state channels can also be used for scaling a dApp or a blockchain (like Celer Network), in real-time gaming, etc.

Essentially, state channels are an answer for any decentralized application which needs a high throughput, privacy at a transaction level, and the same level of security as a Layer 1 blockchain.

State channels vs. Sidechains vs. Rollups

Sidechains

Unlike a state channel, a side chain is a separate blockchain that is connected with its parent blockchain (the main chain) through a two-way peg. Sidechains run in parallel with their main chains and have their own consensus algorithms. Though side chains are similar to the main chain in terms of smart contract language and code deployment, they have different validator nodes and, unlike state channels, side chains do not inherit the main chain's security properties. A two-way peg enables the transfer of assets between the main net and side chain. The side chain's consensus mechanism (ex: PoS) allows it to process transactions at a higher throughput. The transactions are batched and brought on the main chain, which reduces the computational load on the main chain and thereby reduces the gas fees. Examples of sidechain projects:

Polygon - a proof-of-stake sidechain for scaling Ethereum.
Gnosis Chain - a stable coin payment network built on Ethereum.xDAI is a USD pegged stable coin on the Gnosis chain.
Liquid Network - a bitcoin sidechain for quick payments and settlements with applications for exchanges.
RootStock - a side chain with smart contract functionality on Bitcoin.

Rollups

Rollups are a group of solutions that use different techniques to 'bundle' transactions and submit them to the main net, thereby increasing the speed and reducing the fee per transaction. Like state channels, rollups perform transaction execution outside Layer 1, and then the data is posted to Layer 1, where consensus is reached. The main difference between state channels and rollups is that the latter involve an intermediary to process transactions - a rollup operator. Also, state channels are suitable for a wider variety of use cases than rollups at the present moment. Examples of rollups:

Optimistic rollups (as defined on Ethereum.org): assume transactions are valid by default and only run the computation, via a fraud proof, in the event of a challenge.
Zero-knowledge rollups: run computation off-chain and submits validity proof to the chain.

State channel implementation in Web3 multi-chain trading: Yellow Network

As we mentioned above, Yellow Network enables multi-chain high-speed trading and liquidity aggregation from multiple exchanges and DeFi protocols. At the core of Yellow's architecture is an **overlay mesh peer-to-peer (P2P) network **that uses state channels for two primary purposes:

to unify all blockchains and allow their interoperability, and
to enable reaching any token circulating on whatever isolated network and transfer it to other networks (no matter whether the networks are compatible) without bridging. Below is how it works.

(i) Channel opening

To open a trading state channel, the counterparties need to agree on the amount of YELLOW tokens to be provided as collateral and then deposit them with a smart contract called Adjudicator. Once this is done, the state channel is active, and the counterparties can start trading.

(ii) Remote order matching

The trades are facilitated by the matching engine 'Finex'. The engine allows the exchanges to place bulk orders and cancellations with a validation process that ensures trades are being executed within funding limits. The transactions are then maintained with a metadata index without processing them in the blockchain.

(iii) Settlement

The settlement process may be initiated by any party at any time and should be validated by all the parties involved. After that, the trading channel closes.
Essentially, Yellow Network is a Layer 3 that operates independently of blockchains but facilitates their interconnection and cross-functionality, massively relying on state channel technology. As a result, Yellow's architecture enables a matching throughput of around billions of messages per day, which is significantly faster than any paired Layer 1 and Layer 2 solutions available today. At the end, it would even enable high-frequency crypto trading in the same manner as it's done in traditional finance.

Yellow Network's Features

Key takeaway

Compared with other scalability solutions, state channels still maintain their winner position. They are easier for implementation, cheap and fast in terms of their functionality, absolutely disintermediated, and secure ̶a̶s̶ ̶h̶e̶l̶l̶ the same as a blockchain they operate with. Moreover, state channels are feasible for more use cases than their alternatives. When it comes to Web3 multi-chain trading, state channels are the best bet, as they help overcome blockchains' interoperability challenges and provide speed, enabling even crypto HFT. Yellow Network is the perfect example to prove that.

Want to learn more about Yellow Network and cross-chain trading technology?

Check out OpenDAX v4 stack GitHub: github.com/openware/opendax
Visit the OpenDAX product page: https://www.openware.com/product/opendax
Follow Yellow Twitter: twitter.com/Yellow
Join the public Yellow Network Telegram: t.me/yellow_org
Read Yellow Network Medium blog: medium.com/yellow-blog

Stay tuned as Yellow Network unveils the developer tools, brokerage nodes stack, and community liquidity mining software!

A Comprehensive Guide on Web3 Programming Languages and Tools

Julie Plavnik — Mon, 06 Jun 2022 14:37:28 +0000

40+ Valuable Links To Help You Understand Web3 Stack In 2022

Web3 stands for a new decentralized dimension of the Internet. So far, it’s still in its infancy, and no one has seen it fully deployed and functioning yet. However, we already have many prospective projects and solutions that call themselves Web3 related, and we also have some basic understanding of the Web3 stack.

Some time ago, we discussed how to become a Web3 developer.

In this guide, I will walk through some Web3 stack elements in more detail and focus on the programming languages and tools used in the current Web3 development.

Grab your coffee and enjoy the reading. ☕️

Start of Web3 programming: Bitcoin and C++

The first public blockchain Bitcoin was written in C++.

The choice of this language was not random: C++ served perfectly for Bitcoin’s multithreading model.

Essentially, multithreading refers to the capability of a system to divide its tasks into multiple individual threads and run them simultaneously in parallel. In the end, it helps achieve multitasking — higher performance and productivity for a short time.

Examples of multithreaded parallel operations in Bitcoin are verification of addresses, checking digital signatures, etc.

In contrast, a single threading system implies the execution of only a single task at a time without interruption, which is time-consuming and less productive.

Other merits of C++ as a blockchain programming language were

its maturity in terms of upgrades and debugging, and
the dynamic memory management model via move semantics and forwarding, which allows developers to fetch objects without creating copies of temporary objects — this improves the runtime execution speed. Although C++ matched well with the functionality of the Bitcoin network, it was not sufficient for other types of blockchains, whose stacks included the elements that were not present or well-developed in Bitcoin — for example, smart contracts.

Generally, the proper programming language for the blockchain stack is the one that at least provides for:

a compact code size — as we know, blockchain storage is expensive, and code size has to be space-saving.
an increased level of security
proper auditing and debugging capabilities, and
deterministic way of doing things, which implies that every event or action that takes place is purely due to a set of previously happened events or actions. Given this, let’s look at particular programming languages primarily used in Web3 development.

Smart contracts programming languages

With the popularity of Bitcoin, the concept of “programmable money” and peer-to-peer payments very soon got onto the next level of development. It was proposed that blockchain transactions run through smart contracts — self-executing pieces of code that provide complete transparency and eliminate human interference.

For accuracy, the idea of smart contracts was introduced more than a decade earlier than the rise of crypto. In 1994 Nick Szabo, an American computer scientist and cryptographer, proposed “smart contracts” as computerized transaction protocols wired to guarantee tamper-proof execution of agreements. According to Szabo, the general objectives of smart contract design are to satisfy common contractual conditions (such as payment terms, liens, confidentiality, and even enforcement), minimize exceptions, both malicious and accidental, and minimize the need for trusted intermediaries.

However, the way we know them now, smart contracts gained their popularity later on with the introduction of Ethereum. For the purpose of smart contracts coding, Ethereum’s team developed a completely new programming language — Solidity.

Solidity

It is a high-level object-oriented programming language created by the Ethereum Network team for building and deploying smart contracts. Solidity was designed to target the Ethereum Virtual Machine (EVM) — a software platform that constitutes the core of the Ethereum blockchain and enables developers to create various types of programs and applications (dApps) using smart contracts.

EVM has all features of a Turing-complete virtual machine, which means it can execute any type of code exactly as intended. In other words, Ethereum’s Turing Completeness implies that it can use its codebase to perform virtually any task, as long as it has the correct instructions, enough time, and processing power.

Solidity is syntactically similar to JavaScript, C++, and Python, which makes it easy for coders to master.

Solidity is statically typed and supports inheritance, libraries, and complex user-defined types, among other features.

With Solidity, one can create contracts for voting, crowdfunding, blind auctions, multi-signature wallets, etc. The scope of its application is unprecedented.

Solidity is used almost in all EVM-compatible networks (Polygon, BSC, Avalanche, RSK, Fantom, Telos, etc.) and in most Layer 2 scaling solutions, like Arbitrum, Optimism, Zk sync, Parastat, and others.

Solidity is the most widely used language for smart contracts and has the largest dev community compared with other smart contract languages.

Rust

Rust is a low-level programming language used for smart contract coding in such prominent blockchains as Solana, Polkadot, Near, and others.

Rust is memory efficient and statically typed. Unlike Solidity, Rust is a general-purpose language, and smart contracts are just one of the use cases of its application. One of Rust’s biggest advantages as a blockchain programming language is that it allows the creation of a code that doesn’t have memory bugs and consumes less storage on the blockchain.

Among other valuable features that Rust offers are type safety, small runtime, no undefined behaviors, and the like. Rust’s compiler is ergonomic and provides color-coded outputs and detailed error reports.

Rust is the second most used language for smart contracts.

Vyper

According to its documentation, Vyper is a contract-oriented, pythonic programming language that targets the Ethereum Virtual Machine (EVM). The main goal behind Vyper is to simplify smart contracts, provide their superior auditability and make them less vulnerable to attacks. So Vyper is contemplated as an upgraded, more user-friendly, and secure version of Solidity. Vyper aims to make it virtually impossible for developers to write misleading code.

Yul

Yul (previously also called JULIA or IULIA) is a simple, low-level intermediate language for the Ethereum Virtual Machine. The Solidity Developers wrote Yul as a compilation target for further optimizations. It features simplistic and functional low-level grammar. It allows developers to get much closer to raw EVM than Solidity, and with that comes the promise of drastically improved gas usage.

Yul was recently upgraded to Yul+ extension.

Yul is a language that hasn’t seen much popularity yet, however it has tons of potential for future use.

Plutus

Plutus (Haskell) is a statically typed programming language wired for writing reliable smart contracts on the Cardano blockchain. It is also a functional programming language, which means programs are composed as sets of mathematical functions for execution.

Python

Python is a general-purpose programming language with a readable code design philosophy. It is especially gaining popularity for data analysis and neural network programming.

Python is also used for smart contract programming. A notable example here is Algorand, a public blockchain in which smart contracts are written in Python using PyTeal library.

Others

Languages like GoLang, Rholang, and Javascript are also often used as blockchain programming languages. However, unlike Solidity and Rust, they do not apply as languages for writing smart contracts. Instead, these languages can be used for creating environments to interact with blockchains (like a JavaScript environment) through smart contract call functions.

So here is a summary of the smart contract programming languages covered above and the blockchain networks where they apply:

Web3 Tools

First, let’s look at the main building blocks of the Web3 stack, which are represented in the table below (taken from Edge&Node).

Now, let’s look at some of these blocks closer.

Web3 IDEs/SDKs

Both SDKs (Software Development Kits) and IDEs (Integrated Development Environment) are collections of various tools in one installable package used by developers to create applications for specific platforms or purposes. They are designed to simplify and automate the process of development. With these tools, there is no need to code everything from scratch.

The main difference between SDKs and IDEs is that IDEs are purposed to provide an interface for writing and debugging codes, while SDKs are used to add functionality to the codes written.

The actual contents of IDEs and SDKs vary from one to the other. They can include libraries, frameworks, documentation, preprogrammed code pieces, API, testing/debugging tools, etc. Some SDKs have a dedicated IDE that one can use right out of the box.

Here are some popular Web3 IDE/SDK examples:

IDEs

Hardhat and Truffle — terminal-based IDEs that allow developing, testing, and deploying smart contracts on the Ethereum blockchain. Though they have some slight differences, the functionality of these two IDEs is pretty similar. Both provide JavaScript and Solidity-based development frameworks.
Remix — a browser-based IDE serving similar purposes as Hardhat and Truffle. Remix IDE allows developers to write smart contracts in Solidity from web browsers and desktop apps. It has modules for testing, debugging, and deployment, and a diverse set of plugins with intuitive GUIs.
Ganache — allows you to set up your personal blockchain to test smart contracts and dApps. It’s a kind of a simulator of Ethereum blockchain that makes developing Ethereum applications faster, easier, and safer.

SDKs

SDKs contain libraries, documentation, and sample codes to make developers’ lives easy. For instance, directly plugging into an RPC (Remote Procedure Call) node (i.e., a remote node facilitating communication between blockchain and dApps) can be complicated and time-consuming. This is where SDKs might come in handy.

web3.js, web3.py, and ethers.js are the most popular Web3 SDKs (libraries’ collections). They allow connecting smart contracts with the front end of an application. In other words, these tools would help turn your web application into a Web3 one.

Niche Web3 SDKs

By that sort of SDKs, I mean those specifically wired for building certain types of applications.

Here is an example. Let’s say you want to launch a crypto exchange or a brokerage platform. For that, you can use the OpenDAX WEB SDK — a part of comprehensive OpenDAX software wired for establishing crypto exchanges and brokerage apps.

OpedDax WEB SDK provides the developers with all necessary react components and tools, allowing them to launch a Web3 exchange within days without spending hundreds of thousands of dollars and months of work on the software and web development.

Blockchain APIs

Blockchain APIs (application programming interfaces) allow dApps to communicate with blockchain networks.

APIs are used in many crypto-related areas: payments, trading, clearing, analytics, data management, account management, and the like.

Many blockchain APIs are available open-source and come as IDE/SDK package components. For example, the web3.js mentioned above enables interaction with a local or remote Ethereum node using HTTP, IPC, or WebSocket.

Another example is ethers.js — a JavaScript API for interacting with the Ethereum blockchain. While web3.js assumes that there is a local node connected to the application that stores keys, signs transactions, and interacts with the blockchain, Ethers.js separates these functions between a wallet that holds the key and a provider that serves as a connection to the network, checks the state and sends transactions. This approach gives more flexibility to developers.

Here are a couple of more blockchain API examples:

Graph — a decentralized querying and indexing protocol from Ethereum and IPFS. It allows developers to build on open APIs called sub-graphs.
Alchemy Web3 API. According to its documentation, Alchemy Web3 is a wrapper around Web3.js, providing enhanced API methods and other crucial benefits listed below. It is designed to require minimal configuration so you can start using it in your app right away.

Distributed data storage solutions

As we know, one of the key things that Web3 aims to procure is the decentralized, secure, and immutable storage of data.

What does this mean?

The vision is to ensure that users’ information is stored sliced to multiple independent network nodes instead of one server that is not under users’ control. This distributed approach will procure high-quality data protection, as well as enable users to manage their data, encrypt and keep it private, authorize access to data, and backup the storage.

The most notable projects that work in this direction are:

Block explorers

A block explorer is an online blockchain browser that tracks transactions on a particular blockchain. It publicly shows such transaction details as TXID, amount, timestamp, etc.

Also, block explorers provide APIs to access their data by dApps.

Examples:

Oracles

A blockchain oracle is software that facilitates communication between blockchains and any off-chain system, including data providers, web APIs, enterprise backends, cloud providers, IoT devices, e-signatures, payment systems, and other blockchains, etc.

Oracles work both on and off the blockchain simultaneously. On-chain oracles establish a blockchain connection (handle requests), broadcast data, send proofs, extract blockchain data, and perform computation. Off-chain oracles process requests, retrieve and format external data, send blockchain data to external systems, and perform off-chain computation for greater scalability, privacy, security, and other smart contract enhancements.

Examples here:

Chainlink and
SupraOracles.

Automation tools

Here, we mean the tools to create and automate Web3 applications. An example here is Open Zeppelin which has a library of reusable audited smart contracts for multiple use cases such as DeFi, NFTs, and DAOs. It also has automation tools for smart contract operations and scripts to call smart contract functions.

Smart contract audit tools

One of the biggest challenges with Web3 applications and driving them smart contracts is that they are such irresistible magnets for hackers and attackers. This is why auditing is a non-negotiable part of any dApp/smart contract development and deployment. Auditing helps identify potential vulnerabilities of smart contracts, their backdoors, bugs (if any), and other security flaws that must be eliminated at all costs before a dApp starts widely applying. Auditing also allows finding out some gas optimization opportunities for a contract, making it more cost-effective.

The audit is usually done by third-party companies specializing in it. Here are some examples of tools these guys apply in their activity:

Certik — offers tools for security audit, transaction monitoring and insights, wallet tracing and visualization, and attack simulation.
Consensys Diligence — provides automated testing and verification tools.
Sliter is a static smart contract security analytic tool built on Python to detect vulnerabilities, enhance code comprehension, and prototype custom analyses.
MythX, Mythril, Manticore, and Echidna are other tools for security audits.

Data analytics tools

Anyone can access public chain data and run analytics. Web3 is currently in the early stages, wherein decentralized applications are still being developed. As these applications scale and mature, analytics will play a crucial role in keeping the ecosystem up, running, and safe.

Dune analytics provides tools to query, extract and visualize data from public blockchains. Querying is done with SQL. Dune currently supports Ethereum, Binance Smart Chain, Polygon, Gnosis chain, and Optimism.

TRM Labs and Chainalysis have a suite of paid analytics products for forensics and transaction analytics.

No-code tools

Today no-code development in the blockchain is gradually gaining traction. No-code is poised to enable the creation dApps and other solutions easily and effortlessly, without having special knowledge or hard skills.

With no-code tools, one can create and launch tokens, Decentralized Autonomous Organizations (DAOs), NFT marketplaces, NFT minting platforms, Generative Art, etc.

Examples:

Third Web — a platform for launching NFT marketplaces and tokens,
Mirror.xyz — a platform for tokens minting, governance, and NFT marketplaces. Mirror positions itself as the essential web3 toolkit for sharing and funding anything, and
Aragon — an open-source infrastructure with governance plugins for creating DAOs.

Multisig wallets

A multisig wallet is a digital wallet that requires more than one private key to sign and authorize a crypto transaction. In some cases, it assumes that several different keys must be used to generate a single required signature.

A multisig wallet can be of the m -of- n type where any m private keys out of a possible n are required to sign and approve a transaction. The main purpose of multisig wallets is to protect funds from being misused or stolen.

Multisig wallets are popular among all types of crypto market players: retail investors, crypto exchanges, investment funds, brokers, OTCs, DAOs, etc.

Advantages of multisig wallets:

Increased security: a hacker needs to crack at least m-keys instead of just one to access an account and move funds from it.
Assets recovery: if some of n-keys are lost, the funds can still be accessed through the remaining keys.
Collective control over funds: Funds can not be withdrawn without the unanimous consent of all authorized team members who are in charge of funds management.

Multisig wallets examples:

Web3 starter kits

For example, Scaffold ETH helps quickly start building and prototyping on the Ethereum blockchain. It provides tutorials and libraries to make DeXs, NFTs, multisig wallets, smart contracts, etc.

Support forums

Forums could be a great additional help on the Web3 development journey if you get stuck and need help. The most popular ones are Stack overflow, Ethereum stack exchange, as well as different thematic Discord and Reddit threads.

Final word

Web3 stack has been developing sporadically and is quite fragmented so far. Apparently, it’s still in its baby stage, and so is its knowledge base. However, the speed at which the Web3 development moves is pretty comparable to lighting.

Already today Web3 is no longer the exclusive territory of a bunch of dedicated techies. It provides an impressive toolkit that does not require us to be PhDs in computer science but instead leaves room for quick learning and active participation in the new Internet ecosystem development. It also allows us to harness the accumulated knowledge of Web2, so we can avoid reinventing the wheel each time trying to make things differently.

Sooner or later, even amateurs would be able to find their place under the Web3 sun. The entry barriers are becoming lower, so the more people passionate about this space will be able to join without being dismantled by its complexity.

Learn Web3 with Yellow Network. We can’t wait to see you driving this movement!

Check out OpenDAX v4 cryptocurrency exchange software stack on GitHub: https://github.com/openware/opendax

Visit the OpenDAX product page: https://www.openware.com/product/opendax

Follow Yellow Twitter: https://twitter.com/Yellow

Join the public Yellow Network Telegram: https://t.me/yellow_org

Read Yellow Network HackerNoon blog: https://hackernoon.com/u/yellownetwork

Stay tuned as Yellow Network unveils the developer tools, brokerage nodes stack, and community liquidity mining software!

Let’s Customize OpenDAX White Label Crypto Exchange Branding and Landing Page

Akshat — Sat, 04 Jun 2022 04:26:03 +0000

In the previous article, we discussed the problems that are faced when launching an exchange, and how OpenDAX and Yellow Network solve them together. We went as far as generating a Frontend using the OpenDAX NextJs template. Today’s article is about customizing that frontend and taking a closer look at the software.

Now this article assumes that you’ve been following along to our series. And while we recommend that you do so, feel free to follow along as we walk you through our exchange software. With that out of the way, let’s begin customizing our OpenDAX NextJs template and give it some personality.

Exploring Our Exchange

For better clarity, I’ve broken down our exchange’s trading interface into a set of components and labeled them with numbers. Think of them as lego pieces that you can join in different ways to create cool stuff.

Now If you’ve ever used an exchange, you will find this interface to be very familiar.

Sidebar

It has routes for our settings page, the trading interface and a button to connect our wallet. On connecting the wallet, you can also see added options for the order history as well as deposit and withdraw buttons.

While this component isn’t exactly essential to our exchange, it’s a convenient UI/UX design pattern. We can navigate to any screen from anywhere and this works even better on mobile as we’ll see later.

Chart

At the bottom of our screen, we have the trading chart. Our chart is the star of the show, OpenDAX makes use of Trading View’s charting library to provide you with all the good features of trading view without compromise.

By default, it supports all common chart patterns and indicators; tools like Fibonacci retracement and moving averages are built into it. You can also add your own indicators to this chart.

Orderbook

An exchange works by connecting buyers and sellers, and the Orderbook is represents just that. In the orderbook, you can see all the buy and sell orders placed at different amounts for our currency.

For now though, those are all just mock orders that are populated through the mockserver.

Order Creation Panel

Lastly, we have the panel to create orders. Orders direct exchanges when and how to buy an asset for your account based on a given set of conditions.

Our exchange supports the market and limit orders, in both the buy and sell direction. Market orders execute at the market rate, and the limit orders execute when our currency value reaches the limit price.

Connecting The Wallet

To explore the UI even more, we need to connect our wallets. This will give us the options to deposit and withdraw Crypto to our wallet address and several other added features to our exchange.

Since OpenDAX is a Decentralized Exchange, the wallet is non-custodial and to work with it you need to link your existing wallet to the exchange. As of now, it supports Metamask and WalletConnect.

On expanding the sidebar, we can now see our wallet’s address as well as an option to deposit and withdraw crypto at the bottom. However, the placeholder for our logo currently sits blank as we haven’t chosen any logo yet.

It’s time to change that, so let’s head over to our exchange’s settings panel to see all the available customization options.

Here, we have an option to choose our exchange’s languages, currently it supports English and Russian–both of which can be toggled at the settings. We also have an option to toggle dark and light themes followed by customization and the connection type.

We’ll leave the connection type as it is, and enable customization for our exchange. Now this is where the fun begins, after enabling customization you can see an icon in the shape of a color tray at the bottom-right portion of your screen; this is the menu which will help us in customizing our exchange.

Customizing Our Exchange

Currently, our exchange looks quite bland and only has light and dark themes. It also lacks a logo and landing page, all of which are essential to any exchange. On clicking the color tray you can now see the different options to customize your exchange.

Playing With The Color Palette

Let’s begin by changing the colors of our exchange. We’ll set the primary CTA, secondary CTA and Sidebar to #31d35c, #2d314d and #2bb7da hex codes respectively. These are the colors that I’ll be using for our landing page and the logo.

Adding A Logo

To add a logo, head over to the logo tab in the customization menu and select a logo for the light and dark modes for your exchange. For now, let’s just select a logo for the light mode, make sure your logo is 115x30 pixels in size.

After uploading your logo, hit save, and now we have a logo, which you can see in the sidebar.

Naming Our Exchange

It’s finally time to name our exchange, let’s head over to the ‘Platform Name’ tab and set up our exchange’s name.

And there we have it, with this we’ve finished the basic customization for our exchange. It now has a theme, a logo and a name. But our exchange still lacks a landing page, which takes us to our last and final part.

Setting Up The Landing Page

Our app, by default, redirects to the trading screen and that’s because it lacks a landing page. The developers at OpenWare have given us full freedom in choosing our own theme and design with control over every visual aspect of our exchange.

However, to set up our landing page we need to get our hands dirty with a little coding. It’s time to pop-open the hood and configure our landing page internally. To make it easier, I’ve provided the code snippets which you can directly copy and paste into your exchange’s folder to make it look the same.

The first step is cloning, or downloading the code from my repository. After unpacking contents of the zip file, you can see we now have the following folders.

After unpacking the zip file, copy index.tsx present in our pages folder, and replace it with the index.tsx file in our exchange’s pages folder. Next, we need to copy all the* images* present in our images folder, and paste them into the images folder located in public/images of our exchange’s directory.

The last thing we need to do is to copy the Landing folder and paste it in the components folder of our exchange. Remember to save all the files after every change and wait for NextJs to compile the files. After they are compiled, we can goto localhost:3001 to check out our exchange’s landing page.

And there it is, the landing page complete with our logo and the buttons to access our trading panel; you can now click on the different buttons to access all parts of our website.

Conclusion

We are done with both the setup and customization of our exchange, it is now time to finally connect our frontend to the real OpenDAX backend with liquidity from the Yellow network. This is where we’ll deploy our exchange which you can use to perform real trades.

We’ll also go through our exchange’s source code to see how NextJs works in the background, and understand all the magic that happened in setting up our landing page. See you in the next article where we’ll plug the liquidity from the Yellow Network. And as always, if you have any doubts, feel free to reach out.

Learn Web3 & Dive into DeFi with Yellow Network!

Yellow powered by Openware is developing an unprecedented worldwide cross-chain P2P liquidity aggregator Yellow Network, designed to unite the crypto industry and provide global remittance services actually helpful to people.

Are you a crypto developer? Check out the OpenDAX v4 white-label cryptocurrency exchange software stack on GitHub, designed to launch market-ready crypto exchange brokerage platforms with a built-in liquidity stream.

Join the Yellow Community and dive into the most product-oriented crypto project of this decade:

Follow Yellow Twitter
Join Yellow Telegram
Check out Yellow Discord
Find us on Hacker Noon

Stay tuned as Yellow Network unveils the development, technology, developer tools, crypto brokerage nodes software, and community liquidity mining!

How to Become a Web3 Developer, Even If You’ve Never Written a Single Line of Code.

Julie Plavnik — Thu, 02 Jun 2022 12:04:56 +0000

Web3 is booming and expanding to more areas of life. Its adoption happens faster than the Internet in its time. You might be probably ignited by the idea “to join the movement and shape the future.” And you might have already heard that the Web3 industry offers juicy rewards.

Yes, it does. There is a profound imbalance between talent supply and industry demand. Web3 developers are a rare breed. Scarcity always makes something even more valuable. So how do you bring yourself to Web3 development?

Some productivity gurus would first advise you to define your goals, who you want to be, pick up a niche, etc. But how are you supposed to figure it out while you’ve never touched the Web3 things and have no practical experience to understand what resonates with you the most?!!

This article will cover how to jump into Web3 development right without getting lost in the overabundance of the information.

Let’s get started.

What areas does Web3 cover?

There is no one full-proved academic definition of Web3. Some attribute to Web3 every next big thing that implementing crypto. Including even those projects that are ̶s̶h̶a̶m̶e̶l̶e̶s̶s̶l̶y̶ apparently centralized (like Metaverse by Meta).

Others define Web3 as a decentralized Internet of value, enabling users to interact peer-2-peer without relying on a tech-giant intermediary (like Facebook and Google) and stay in complete control over their data. This is closer to the truth.

At least, that's how Web3 is described by Gavin Wood, one of the pioneers and leaders of the Web 3.0 movement, who actually coined this term.

Regardless of how many different definitions Web3 has, it is clear that it is multidisciplinary.

The key areas that Web3 covers are:

Artificial Intelligence (AI),
Internet of Things (IoT),
Blockchain Technology,
Metaverse Augmented Reality.

No way you want to start mastering them all simultaneously.

Regardless of your expertise, IQ, and persistence, you will likely end up overwhelmed on day one. And will give up on the second.

So how to approach Web3 development?

As Web3 stands for a decentralized internet, therefore the primary technology it relies on is Blockchain. It is the base of Web3. Other areas - AI and IoT - constitute its superstructure.

Therefore the starting point of our Web3 development journey is blockchain technology.

Further, we will talk about how to get on it. But first, let's look briefly at what a Web3 developer actually does.

What does a Web3 Developer do?

Each time, the particular set of tasks a Web3 developer depends on the niche he is working in (DeFi, NFT, Metaverse, GameFi, etc.) and what an employer or a client pointed out in the role description. In that sense, the role of a Web3 developer is similar to the role of a Business developer. The latter can be a salesperson, a manager who does fundraising, or someone in charge of establishing partnerships and PR collaborations. Therefore, from case to case, the set of tasks is unique.

I will broadly group Web3 development into two main categories: core development and application development.

Web3 Core Developers

A Web3 Core Developer is generally involved in the design, architecture, and security of blockchain systems. Basically, their roles include the following:

Designing and building Layer 1 blockchains from scratch;
Design of consensus protocols and security patterns for the network;
Design of the network architecture and nodes operating; and
Supervision of the entire network.

Essentially, a Core Blockchain Developer sets up the foundation for future decentralized applications (dApps).

Web3 Application Developers

An application developer (dApps developer) has a different set of tasks. They utilize the architecture built by core developers to design and deploy dApps.

The dApps development is basically broken into back-end and front-end parts.

Back-end Web3 App Development

Regular (i.e., Web2) back-end programming refers to the server side of an application and everything that communicates between a database and a browser. The back-end is a part of an application that users do not see.

Web3 back-end development is entirely different. We don't need a server to build a dApp. Instead, we want to choose a proper Layer 1 network (ETH, Solana, Polygon, etc.) fitting our dApp's goals and build upon it smart contracts that would define the dApp's logic and automate its work. Roughly said, smart contracts replace a server-side component in dApps.

Web3 back-end tasks mainly include working with distributed databases, smart-contracts design and deployment, and blockchain APIs, SDKs, and EDIs (see below). Unlike Web2 back-end, Web3 one is always open for users. Blockchain databases and smart contracts are inherently transparent and can be viewed by everyone.

Front-end Web3 App Development

Front-end stands for the client-side part of an application. This is what users see and interact with (i.e., website and mobile app).

The specificity of dApps front-end is that the front-end architecture is focused on communication with smart contracts. Instead of making network requests to a centralized API server somewhere, you will be reading data from the blockchain directly, usually from smart contracts.

Another specific thing here is users’ authentication. As Web3 stands for decentralized ownership and data storage, users access blockchain networks through a dApp directly using their private keys. So another thing you are going to handle as a web3 front-end developer is wallet connections. To identify a user and procure their access to the blockchain, you will usually ask them to connect their wallets, like Metamask, to the dApps website (or mobile app). A wallet acts like a transaction signer in a blockchain network and stores users’ private keys in the browser.

Full-stack Web3 App Development

A Web3 full-stack developer works with both the back and front ends of a dApp. In this sense, they provide end-to-end service and can be involved in projects that include databases and building user-facing websites.

How to start Web3 development?

There are multiple different ways of approaching Web3. The defining factors here are your current skillset and experience.

If you are entirely new to programming and development, the path can be a little trickier than having a related background. However, with intense curiosity, commitment, and dedication, nothing is impossible, right?

Here I would offer a general practical scheme that can fit both the experienced and fresheners. It is based on the assumption that regardless of how new you are to Web3, at least you get along with maths and computer science fundamentals. You are also excited about Web3, consistently educate yourself on it, and follow the trends.

So even if you don’t code yet, your theoretical understanding of blockchain technologies is already solid. That is why I would avoid advising here on things like learning what blockchain is, its goals, and other introductory stuff. If you are at the stage of thinking about becoming a Web3 developer, you are supposed to be already clear on that sort of basics.

So here are the steps:

1. Focus on one blockchain

I would recommend starting coding with Ethereum. At the moment, Ethereum is the most mature development environment in the blockchain space. At the core of the Ethereum network is its EVM (Ethereum Virtual Machine) - a software platform that developers can use to create programs using smart contracts for various purposes, including dApps.

EVM has all features of a Turing-complete virtual machine, which means it can execute any type of code exactly as intended. In other words, Ethereum's Turing Completeness implies that it can use its codebase to perform virtually any task, as long as it has the correct instructions, enough time, and processing power.

Another reason for starting with Ethereum is that there are a lot of other blockchains out there that are compatible with EVM. Among those are Polygon, Avalanche, Polkadot, etc.

So once you master Ethereum, it would be easier for you to expand into other blockchain networks compatible with its EVM.

Also, if you build on Ethereum, you are a part of the largest blockchain developers community. So can always learn from professionals and ask for guidance when needed.

Why not start with Bitcoin?

While Bitcoin has the most extensive adoption, its technology doesn't have the feature of Turing completeness. Therefore, Bitcoin is way less friendly for development than Ethereum.
It's just not fundamentally wired for this. However, a few projects somehow enable building dApps on BTC. For example, Stacks.

2. Learn the most applicable programming language

In the world of building decentralized apps, a must-have coding language is Solidity. Solidity is a high-level object-oriented programming language created by the Ethereum Network team for building and deploying smart contracts. It is designed to target the Ethereum Virtual Machine (EVM).

Solidity is statically typed and supports inheritance, libraries, and complex user-defined types, among other features. With Solidity, one can create contracts for voting, crowdfunding, blind auctions, multi-signature wallets, and other purposes. A significant benefit of Solidity is that it is easier to learn than many other programming languages (like rust or C++, for example). The scope of its application is unprecedented. Solidity is used almost in all EVM-compatible networks (Polygon, BSC, Avalanche, RSK, Fantom, Telos) and in most Layer 2 scaling solutions, like Arbitrum, Optimism, Zk sync, Parastat, and others.

The next suggestion is to learn JavaScript. It is a client-side (i.e., frontend) programming language that allows to implement various complex features on web pages, like interactive maps, animated 2D/3D graphics, scrolling video jukeboxes, and the like Knowledge of JavaScript would be a great addition to Solidity. As mentioned earlier, in dApps development, even its backend part is open for users. Therefore, no matter which development aspect you decide to focus on - backend or frontend - it’s essential to understand the basics of both and how they interact with each other.

Other top programming languages in Web3 development are C++, Java, C#, Go, Python, Ruby, and Rust. However, Solidity + JavaScript would be enough to cover all the necessary basics if you are just starting.

3. Use Web3 IDEs/SDKs

The main difference between SDKs and IDEs is that IDEs are purposed to provide an interface for writing and debugging codes, while SDKs are used to add functionality to the codes written.

Let’s look at some most popular Web3 SDK/IDE examples:

Hardhat and Truffle - terminal-based IDEs that allow developing, testing, and deploying smart contracts on the Ethereum blockchain. Though they have some slight differences, the functionality of these two IDEs is pretty similar. Both provide JavaScript and Solidity-based development frameworks.
Remix - a browser-based IDE serving similar purposes as Hardhat and Truffle.
Ganache - allows you to set up your personal blockchain to test smart contracts and dapps. It’s a kind of a simulator of Ethereum blockchain that makes developing Ethereum applications faster, easier, and safer.
web3.js, web3.py, and ethers.js are the most popular Web3 SDKs (libraries' collections). They allow to connect smart contracts with the front end of an application. In other words, these tools would help turn your web application into a web3 one.
Niche Web3 SDKs. By that sort of SDKs, I mean those specifically wired for building certain types of applications. Here is an example. Let’s say you want to launch a crypto exchange or a brokerage platform. For that, you can use the OpenDAX WEB SDK created by Openware, a Yellow’s company. OpenDAX WEB SDK combines the privacy and security of decentralized finance with the usability and simplicity of centralized exchanges. This SDK offers reusable UI components and widgets for common web interfaces used in creating exchange platform applications. They come with a simple and modern design developed to satisfy any needs and according to the latest UI/UX practices. Users can customize the interface based on their corporate style, design guidelines, or other preferences.

In addition to UI components, the library leverages React state management tools such as Providers, Hooks, and Utils. It allows for an easy connection to the OpenDAX WEB SDK for JavaScript and passing data to the UI layer.

4. Join Web3 Communities

Web3 development is amazing and joyous but could be pretty challenging at times. Especially for newbies. If you go a sole wolf way, you can lose days, months, and even years trying to overcome obstacles on your development journey. It makes no sense, given that there is always someone already ahead of you and willing to share their knowledge. You can easily find those people in Web3 communities.

Such communities exist almost around every Web3 network, protocol, or a stand-alone project. They hang out on Reddit, Discord, Github, Telegram, and other social platforms. Engage with those that are the most suitable for your current professional level and goals. The beauty of the Web3 development world is that it is tremendously supportive and collaborative.

Final thoughts

Web3 development is absolutely a brilliant career path. Not only will it reward you financially, but the time spent working in this field will give you paramount personal growth and high-quality social capital.

Don’t be discouraged by its seeming at first sight complexity. Learn as you go. The clarity will follow.

Want to learn more about Web3 and FinTech?

Check out the most ambitious decentralized project Yellow Network powered by the latest state channel technology: yellow.org
Take a look at the open-source OpenDAX v4 white-label cryptocurrency exchange software stack on GitHub: github.com/openware/opendax
Visit the OpenDAX product page: https://www.openware.com/product/opendax
Follow Yellow on Twitter: twitter.com/Yellow
Join the Yellow Network Telegram: t.me/yellow_org
Read more exciting articles on Yellow Network Medium blog: medium.com/yellow-blog
Find us on Hacker Noon:hackernoon.com/u/yellownetwork

Let's Launch a Crypto Exchange Brokerage Using Open-Source OpenDAX with Yellow Network Liquidity

Akshat — Fri, 20 May 2022 07:47:22 +0000

Build Your Own Crypto Exchange Using OpenDAX

If you’ve ever attempted or at least thought of creating your own crypto exchange, it takes little research to realize that it’s not easy. This is majorly because of two reasons, one is obtaining liquidity, and the other is having an experienced developer team.

Crypto exchanges are quite scarce, and their tech stack is mostly proprietary. This leaves us with two options, the first is making use of third-party libraries and components, which are often unmaintained, and the other is building your own exchange completely from scratch, which is a daunting task if you ask any developer.

But an even bigger problem is obtaining liquidity, and with Crypto, it is a “Chicken and the Egg” story. An Exchange is called liquid if it has an ample amount of buyers and sellers, and this means we need users to start with to get liquidity. But to get those initial users, we need liquidity, and this is where we are stuck in an endless loop.

Welcome, Yellow Network and OpenDAX

As we discussed earlier, we are dealing with two major problems here, the problem with liquidity and the problem with infrastructure; Yellow Network and OpenDAX solve exactly that. But how?

To start, Yellow Network is a Layer-3 decentralized overlay P2P network, which connects brokers together to form a giant Liquidity pool with shared order books, and solves the problem of getting liquidity to our crypto exchange altogether; other than that, it also brings in ultra-high-speed trading, which the crypto world has never seen before.

OpenDAX is short for Open-Source Decentralized Asset Exchange, and it is open-source software with a host of libraries to build literally any crypto trading application, and we will use it to create a Crypto exchange brokerage website. It has a customizable self-hosted platform, several templates, as well as an open-source OpenDAX WebSDK, which you can use to build some crypto projects of your own.

If all this sounds too good to be true, well, because it is. Yellow Network and OpenDAX together are taking web3 to a whole new level where starting your own Crypto brokerage is easy as cake. Gone are the days when you needed a huge capital and network to start your own exchange.

So, in short, Yellow Network provides liquidity, and OpenDAX provides the infrastructure. In this series of articles, we’ll learn how to set up our very own Crypto exchange using the OpenDAX platform and connect it with the Yellow Network to obtain liquidity.

Before We Begin

To properly follow along with this tutorial, at the least, you need

NodeJs on your computer.
VS Code or an equivalent code editor.
Basic understanding of JavaScript.

Starting Visual Studio Code

To launch VS Code, select a directory of your choice and open the terminal in that directory. If you’re on Mac, then in the terminal, type ‘code’ and hit enter — this should open up VS Code with the chosen directory.

But If you’re on a windows system, then press shift and right-click together; this will open up the right-click menu with an ‘Open PowerShell window here’ option. After opening PowerShell, type ‘code .’ and this should launch VS Code for the selected directory.

Now, we need to launch the in-built terminal for VS Code, it provides all the features of our regular terminal plus the added convenience as you can launch as many terminals as you want, and you don’t need to switch between windows to write commands anymore.

To open a terminal in VS Code, go to ‘Terminal’ in the menu bar and click on ‘New Terminal’; this should open up a terminal window at the bottom. From here on, we can start writing our commands.

Bootstrapping An OpenDAX Project

OpenDAX is available as separate tools and as a complete SDK. In the following series, we’ll make use of the OpenDAX NextJs template to set up our exchange. It is a Lego-like system and gives you complete freedom of customization.

To create an OpenDAX NextJs project, type the following command in the VSCode terminal, and hit enter.

npx @openware/create-opendax-web-app@latest

This will execute our package and will set up the template for us. After executing this command, NPM will prompt you for the project template; here, we’ll keep the default option which is typescript. We are also asked for the name of our project; you can name it however you like. For the sake of this tutorial, we’ll call it ‘Crypto_Exchange.’

This process takes a while to complete, and by the end, we are left with our project’s folder. And while all these files may seem overwhelming, we don’t have to deal with them all.

Starting The MockServer

Our OpenDAX template is just the frontend interface. To actually make it functional, we need to have some sort of backend server to feed the data. That said, the OpenDAX backend is a heavy software and requires time and a lot of resources to set up.

Luckily for us, though, we have something called a ‘mock-server,’ which, as the name suggests, is an imitation of a real server. It will help populate our exchange with fake data so that we can conveniently work on customizing the front end without having to start a complete platform.

To start a mockserver, open a new terminal in VSCode for the project directory and type:

npm explore @openware/opendax-web-sdk -- npm run mockserver

This spins up a mock-server at the given addresses. Notice how on the right side of this image, we have two terminals now. We have used the second terminal for spinning up our mockserver, and the first terminal is now going to be used to start the frontend.

Starting The OpenDAX Frontend

With our mockserver in place, it is finally time to start our frontend to visualize our app. To start the frontend, switch back to the first terminal and execute the command:

cd Crypto_Exchange

This will change the directory to our project’s directory, where we can finally run the command to start the frontend.

To start the frontend, enter the command:

npm run dev

It will start the process of spinning up our frontend, which can take a couple of minutes to complete. At the end of this process, we will have our project running at localhost:3001 which we can navigate to see our project live.

And there we have it, a trading interface complete with an orderbook and an extensive chart similar to the Trading View’s chart. Here you can create your own indicator or choose from a library of indicators.

Conclusion

We’ve come to the end of this tutorial and have successfully set up our exchange’s frontend using the OpenDAX NextJS template, complete with dummy data from a mockserver.

I will keep going through the OpenDAX software stack. The next few articles will be majorly focused on customizing our frontend, understanding NextJs, and finally connecting it to a real backend to make a complete Crypto brokerage software.

I hope you enjoyed this tutorial. If you have any questions or have trouble sleeping — feel free to reach out :) See you in the next article where we plug the liquidity from Yellow Network into our new cool crypto exchange!

Learn Web3 & Dive into DeFi with Yellow Network!

Join the Yellow Community and dive into the most product-oriented crypto project of this decade:

Follow Yellow Twitter
Join Yellow Telegram
Check out Yellow Discord
Find us on Hacker Noon

Stay tuned as Yellow Network unveils the development, technology, developer tools, crypto brokerage nodes software, and community liquidity mining!