## Overview

Five weeks ago, [Patract Labs](https://github.com/patractlabs) applied a [treasury proposal #103](https://polkadot.polkassembly.io/post/103) for Elara v0.1, which will be an instant and scalable Polkadot API service. 

In the proposal, we promised to finish the following works (referring to [motion #31](https://polkadot.polkassembly.io/motion/31)):

> **v0.1: Implement Substrate node access**
> * Create a server-side framework to develop proxy access, automatic monitoring and data statistics to the RPC service of the Substrate node
> * Support developers to use http and web-socket protocols to uniformly access the network through the server framework
> * Develop a front-end dashboard to display relevant monitoring statistics of the RPC service of the Substrate node
> 
> **How to verify v0.1: Youtube demo video & Github source**
> * The Substrate node of the service can be accessed through http and web-socket protocols
> * Can monitor RPC requests of Substrate nodes
> * Can view the relevant monitoring statistics from the dashboard

By now, we have finished all the development requirements for Elara v0.1 on time. There is a demo video to show all the features on YouTube in https://youtu.be/7UhsUEqk1pQ. The Github repo is https://github.com/patractlabs/elara, and the homepage of a demo dashboard to show the current statistics is in https://elara.patract.io/. 

![image](https://user-images.githubusercontent.com/5023721/97083914-fc841080-1645-11eb-9478-306fc9b1dcc4.png)

Then, Let's show you how Elara works:

## Start Elara On Your Own Computer
Elara v0.1 can be used for any Substrate blockchain. For example, if you want to run a Polkadot or Kusama node to provide a public RPC endpoint node, then you what to monitor how many times and what kind of RPC calls had been called in one day, you can do the following steps to start Elara:

1. The node server should already have `yarn` and `node` command.

2. Git clone Elara into this server:
```bash
git clone https://github.com/patractlabs/elara.git
```

3. Install Elara’s dependencies:
```bash
cd elara
yarn install
```

4. Install database:

Currently, Elara use `Redis` memory database to provide the back-end DB to store all data. We will support other database like MongoDB or PostgreSQL in the future, but now we just support Redis DB and the corresponding configs. If you need persistent data,  using redis’ persistent feature is good enough.

```bash
# for ubuntu or debian
sudo apt install redis
# other system just replace to related command to install redis
```

* Notice: we advice to config password for Redis if you use Elara in production environment *

And on the other hand, the Redis server instance can be replaced by cloud service. In this way, DevOps can save some time and lot of troubles.

5. Start Polkadot or Kusama, or any other substrate node that you want to monitor.

Please notice that all Substrate node will export `ws-port` and `rpc-port`, and can set some limit for commands, like `--rpc-cors`, `--rpc-methods` or `--unsafe-rpc-external`, `--unsafe-ws-external` or something else.

For more information, please refer to [https://github.com/paritytech/substrate/wiki/Public-RPC](https://github.com/paritytech/substrate/wiki/Public-RPC).

6. Modify Elara’s config file:

By now, Elara has provided a real RPC / web-socket service for outside users, and Elara can connect with Substrate node directly. Elara is doing like a proxy to transmit client requests to the node, at the same time, logging, monitoring, and counting all the requests.

So you need to modify config file for Elara:

```bash
vim config/env/dev.env.js
```

And you can see:

```javascript
process.env.DEBUG = process.env.DEBUG || 'dev-errer:*'

module.exports = {
    keys: ['elara@#^*&'],
    name: 'elara',
    port: 8001,  // this port is elara server, receive all client request(inlude rpc and websocket) and dashbord server port
    pid:'00000000000000000000000000000000',
    chain: {
        'substrate': {
            'rpc': ['localhost:9933'], // the substrate node rpc port
            'ws': ['localhost:9944'] // the substrate node websocket port
        }
    },
    redis: { // the redis config
        host: '127.0.0.1',
        port: '6379',
        password: ''
    },
    timeout: 10000,// ms
    requests: 1000//
}
```

In this config file, you should pay attention to 3 fields:

*  `port` : This field is used for Elara server, all client requests will go through this port, including RPC requests and web-socket requests.
*  `chain/substrate`: This field is used to connect with the Substrate node, so it should match its  `--ws-port` and `--rpc-port`.  If the Substrate node doesn’t set those two parameters, the default values are `9944` and `9933`.
* `redis`: This field is used to connect with the Redis instance.

7. Start Elara’s service and dashboard:

In Elara’s root directory, you can start in the current process:

```bash
node app.js
```

Or use [pm2](https://github.com/Unitech/pm2) to management the process

```bash
pm2 start pm2.json --env dev
```

You can find the running log in  `elara/logs/`

And then you can start the dashboard:

```bash
cd ./daemon
nohub node dashboard.js &
```

Now open `http://127.0.0.1:8001/demo` in your browser, you can see the dashboard and all the statistics for requests.

Please notice that the client request’s endpoint should be `http://127.0.0.1:8001` or `ws://127.0.0.1:8001` to start the RPC or web-socket request, otherwise the request can't be monitored by Elara.

8. Start requesting from client:

* If you provide RPC service for developers:

1. Method 1 : using curl to send HTTP requests:

```bash
      #curl http
      curl --location --request POST 'http://localhost:8001' \
          --header 'Content-Type: application/json' \
          --data-raw '{
              "id":1,
              "jsonrpc":"2.0",
              "method":"chain_getBlock",
              "params":[]
          }'
 ```

2. Method 2: using [wscat](https://github.com/websockets/wscat) to send websocket request:

```bash
    parachain@ubuntu:~/elara$ wscat  -c ws://localhost:8001/
    Connected (press CTRL+C to quit)
    > {"id":1,"jsonrpc":"2.0","method":"chain_getBlock","params":[]}
    < {Response data...}
```

3. Method 3 : Using the SDK. You can refer to [polkadot-js](https://github.com/polkadot-js), using the following and similar code to access the node by HTTP or websocket：

```javascript
    const { ApiPromise, WsProvider } = require('@polkadot/api');
    const { HttpProvider } = require('@polkadot/rpc-provider');
    
    (async function () {
    // Http
    const httpProvider = new HttpProvider('http://localhost:8001')
    const hash = await httpProvider.send('chain_getBlockHash', [])
    console.log('latest block Hash', hash)
    
    // Websocket
    const wsProvider = new WsProvider('ws://localhost:8001')
    const api = await ApiPromise.create({ provider: wsProvider })
    //Do something
    })()
```
    
We also provide reference examples under `elara/example/`. Examples can be executed:
    
```bash
    node client.js
```

* If you provide access endpoint to the [Official Polkadot Portal](https://polkadot.js.org/apps/), any other wallets or blockchain explorers:

You must remember that the current endpoint is provided by elara, such as `127.0.0.1:8001`. You can config `ws://127.0.0.1:8001` in your https://polkadot.js.org/apps/ website.

![image](https://user-images.githubusercontent.com/5023721/97085134-06117680-164e-11eb-9ae4-e01ab2474d3a.png)

Then in your dashboard, you can see all the statistics.

## What we have implemented for v0.1
As we describe above, we have implemented all features required in proposal.

~~The Substrate node of the service can be accessed through http and websocket protocols~~

> The [Official Polkadot Portal](https://polkadot.js.org/apps/) can directly use Elara as an endpoint.

~~Can monitor RPC requests of Substrate nodes~~

> We can see all the statistics in Redis or on dashboard.

~~Can view the relevant monitoring statistics from the dashboard~~

> We have provided a demo video to show this dashboard.

Overall, we believe that the node services, wallets, blockchain explorers and other service providers can benefit from Elara! We have done the design of Elara v0.2, Please see the next treasury proposal https://polkadot.polkassembly.io/post/141.

:

1. Five weeks ago, Patract Labs applied a treasury proposal #103 to develop Elara v0.1, which is an instant and scalable Polkadot API service. 
2. Elara v0.1 has been completed and can be used for any Substrate blockchain. 
3. Elara v0.1 is able to provide a public RPC endpoint node and monitor the corresponding RPC and web-socket requests. 
4. The Github repo of Elara v0.1 is https://github.com/patractlabs/elara and the YouTube demo video is https://youtu.be/7UhsUEqk1pQ. 
5. The homepage of a demo dashboard to show the current statistics is in https://elara.patract.io/. 
6. A reference example can be found under `elara/example/` and any other wallets or blockchain explorers can use Elara as an endpoint. 
7. The design of Elara v0.2 has been done and described in treasury proposal #141.

#139 Patract Labs’ treasury report for Elara v0.1