Announcing the Raiden Light Client “Ashvini” Release

TL;DR

The Ashvini release is the first version of the Raiden Light Client released on the Ethereum mainnet. It is a full implementation of Raiden written in Typescript and it runs in any Ethereum enabled browser. Continue to read this blog post to get an overview of what the Ashvini release is. To get started, go to lightclient.raiden.network!

Introducing the Raiden Light Client

We’re proud to announce the Raiden Light Client. The Ashvini mainnet release is a Typescript implementation of the Raiden Network that runs in any Ethereum enabled browser. Over the five years we’ve been building Raiden, it’s become increasingly clear to us that UX/UI is a challenge in the crypto space, but at the same time it’s paramount for mass adoption. Hence, this is one of our main motivations to develop the Raiden Light Client. We wanted to provide users with a convenient and easy way to interact with the Raiden Network without having to run a full node. We call it a Light Client, but in reality it is a full Raiden client that requires less resources to run. We’re not only releasing an SDK, but also a reference implementation of a dApp that is built on top of the Light Client. You can start using the Raiden Light Client on the Ethereum mainnet right now via lightclient.raiden.network. Once you have the Light Client dApp setup you will be able to do fast and very cheap ERC-20 token transfers to anyone running a Raiden node. Not only will you remove load from the Ethereum main chain, but you also won’t have to worry about high and fluctuating gas prices. In the rest of this post we will go through the details of the Light Client and its features as well as how to get started using it.

Features

The Light Client offers parity with features and functionality in the Python client. The core functionality that users will be using most of the time are exactly the same in both clients. We have even made some UI/UX improvements in the dApp which makes it much easier to interact with the Raiden Services and the User Deposit Contract.

Basic functionality:

• Open channel
• Deposit to channel
• Partially withdraw from a channel (without closing it)
• Close channel
• Settle channel
• Send direct transfers
• Sending mediated transfers
• Receiving transfers (receiving node needs to be online)
• Mediating transfers

All of the above functionalities are shared between both the Python client and the Light Client. Currently, the Python client, as well as the Light Client SDK allow new token networks to be deployed, but the Light Client dApp does not. This doesn’t play a big role for this release, since the smart contracts used only support DAI and WETH which already have token networks deployed.

As already hinted, the Light Client interacts with the same smart contracts as the Python client. This means that Light Client nodes can make transfers to Python client nodes and vice versa. As a matter of fact, users don’t need to distinguish between the two at all.

The team has put a lot of effort into making it as easy as possible to interact with Raiden via the Light Client. As a result of these efforts there is a dApp available already today that allows anyone to use Raiden through a web3 powered browser. The dApp is open source and it also works as a reference implementation to showcase how dApps can be built to utilize the power of the Raiden SDK.

The SDK

One of the most powerful things introduced by the Raiden Light Client is the SDK. The SDK offers all the same features as the Python client and it makes it easy for anyone to implement Raiden into their JavaScript compatible applications. What’s even better is that no full Raiden node is required to do this. The team already showcased how simple it is to implement a dApp with the Light Client SDK in this video. You can see that the code example used in the video is just 87 lines and it implements a full, but very simple dApp that can connect to the Raiden Light Client, open channels and do transfers. Furthermore, if you’re planning to be at EthCC, drop by the Raiden Light Client workshop to learn more about building on the SDK.

The fact that the SDK uses a very restricted environment, means that it can run in just a browser tab. This opens up to a wide range of use cases, since the requirements for running and interacting with a Raiden node are significantly decreased compared to the Python client.

Getting Started

Getting started using the Light Client is as easy as going to lightclient.raiden.network and following the instructions presented on screen. For a more detailed overview of how to get started using the Raiden dApp you can check out the detailed guide available in GitHub.

In Closing

With the Raiden Light Client being released on the Ethereum mainnet, it is now easier than ever to implement Raiden into dApps in order to do fast, cheap and scalable ERC20 token transfers. We are looking forward to seeing what you will build and we encourage everyone to reach out to the team via Gitter or create an issue if they have any questions or feature requests! If you want to build something on top of Raiden, don’t forget to check out the Raiden Trust!

Lastly, we want to thank those of our community members who run the Raiden Service Bundle. We appreciate your efforts and vision towards making Raiden as decentralized as possible and keeping the project true to the decentralized vision of Ethereum!

Safety Measures

The safety measures in place for the Ashvini Light Client release are the same as for the Raiden Bespin release that was announced last week. The smart contracts used for the Light Client and the Python Client are the same and since the safety measures are defined by the smart contracts there are no changes. We want to mitigate risks to limit the potential damage caused by bugs or misuse of the software and to ensure a responsible experimentation environment for this nascent technology. Please also note that the Ashvini release is not yet audited by an external party.

As already explained in the Bespin blog post there are limits in place of the maximum ETH or DAI that can be deposited per channel and a maximum of $1,000,000 worth of tokens per token network. However, the ETH price at the time of writing is up by ~15x since the limits were defined. This means that the limits of the Wrapped Ether token network are worth 15 times more now than they were when the contracts were initially released. DAI is a stable coin so the values for the DAI network remain the same.

WETH and DAI remain the only two available token networks as a consequence of Bespin using the Alderaan smart contracts.

Furthermore, in order to be able to receive transfers, users need to deposit 80 RDN into the UDC contract. This is a safety measure to make sure that the Monitoring Service will react in case of a channel closing while the user is offline.

Safe Usage

As with any blockchain project, there are a number of measures that need to be taken in order to achieve safe usage. This, for instance, includes having a reliable layer 1, such as a working web3 provider and not deleting the database that persists your off chain states. For a complete list of safety precautions related to the use of the dApp you can take a look here. There are some more measures to be taken into account regarding the use of the SDK, which can be found here. As for the CLI, these measures should be taken.

Bug Bounty

There is currently still a bug bounty program in place for the Alderaan smart contracts. Bespin and Ashvini use the same deployed smart contracts, which means that the bug bounty that has a pool worth $200,000 stays in place. For more detailed information on the bug bounty you can take a look at this blog post.