- This proposal is about creating a mobile app for voting and governance in Polkadot and Kusama networks.
- The app aims to make it easier for users to participate in on-chain governance activities.
- The team led by Hanwen Cheng has experience in building mobile apps and is working with Litentry Technologies.
- The app will allow users to verify their identity, receive notifications about governance updates, and see their voting statistics.
- It will improve participation rates by providing a user-friendly design and relevant information.
- The proposal is divided into four milestones, starting with identity registration and ending with more features like lottery integration.
- The total cost for the first phase is approximately $28,210, requesting 6,132 DOT.

Awarded

> Note: This treasury proposal is only for **milestone 1**, we list all milestones here only to provide an holistic overview of our vision and better context for understanding our proposed solution.

Proposer: (Hanwen/Litentry) `14zExx2SkY7j9HLeBmuz91o3KfSroSAFRFGNtBnEkYNC492U`

Date: 17.12.2020

Requested DOT: 6132

[Original proposal on GitHub](https://github.com/hanwencheng/gists/blob/master/Litentry/governance-app.md)

[Discussion on Polkassembly](https://polkadot.polkassembly.io/post/217)


**Short description**: Governance-focused Mobile App for substrate-based networks

---

In this proposal, we raise the idea of building a governance-focused app with cross-wallet support, which could encourage the user to take part in various on-chain governance actions and be able to interact with on-chain governance activities in a low friction manner, thus improving the on-chain governance engagement.

## 1. Context of Proposal

Hanwen Cheng was the former product owner of [Parity Signer](https://github.com/paritytech/parity-signer). He has rich experience in building mobile and web applications, also very familiar with Substrate-based tools. Now he is working for [Litentry Technologies GmbH](https://www.litentry.com/), a technology company focusing on building a [cross-chain identity aggregator](https://litentry.medium.com/why-we-need-cross-chain-identity-on-polkadot-d59a90c9329c), which includes the substrate-based networks and related tools. The team has solid substrate development experience and specialization in mobile engineering.

Aggregated identity means an identity linked with accounts from different blockchains and off-chain applications/services, which represent the owner behind the accounts, and further present the owner's credibility and reputation in various aspects. 

In this proposal, we present a governance app. It could 

* facilitate the governance process by lowering the participation friction
* increase user engagement by providing clear UI/UX for interactions 
* allow users to subscribe to remote **Push Notifications** for relevant topics
* provide richer information related to the identity across different substrate-based chains
* serve as a basis for more incentive mechanisms

*Polkadot* currently employs *Phragmén Method* to equalize stake holder's voting power in elections. In our eyes, we see a future where the reputation of identity also plays a vital role in calculating the voting power of elections.

## 2. Problem statement:

There are currently a few issues when it comes to on-chain governance on *Polkadot* and *Kusama*:

1. Low Voting Participation Rate: Currently, the on-chain governance participation rate is quite low, even in the case of controversial decisions (such as  *Kusama* redenomination, in which only about 10% of stakeholders participate in the vote).

2. Missing Identity Governance Stats: When voting for the council members, it is hard to know who, from all councilors, has made the most contributions to the ecosystem and who has participated the most in the discussions. Currently, there is no dashboard to show on-chain governance stats of identity. Also, on [Polkadot.js Apps](http://polkadot.js.org/apps/) and [Polkassembly](https://polkadot.polkassembly.io/), the identity tooltip is limited to certain fields. Therefore richer information is needed to be shown when users browse and participate in governance. Opensquare has made a [proposal](https://kusama.polkassembly.io/post/352) on *Kusama* about the treasury reputation recording system, and this system is currently in the web app side.

3. After investigating the wallets listed on https://wiki.polkadot.network/docs/en/build-wallets, currently only [Polkawallet](https://polkawallet.io/) natively supports for governance module. The rest wallets either use integrated governance DApp in a WebView, or do not even have governance module integration at the moment. Furthermore, each mobile app has its own governance UI. The engineering power is wasted and lacks interoperability.

Imtoken |  Math Wallet | Polkawallet
:-------------------------:|:-------------------------:|:---|
![imtoken](https://raw.githubusercontent.com/hanwencheng/gists/master/Litentry/imgs/GovernanceImtoken.jpeg)  |  ![mathwallet](https://raw.githubusercontent.com/hanwencheng/gists/master/Litentry/imgs/GovernanceMath.jpeg)| ![polkawallet](https://raw.githubusercontent.com/hanwencheng/gists/master/Litentry/imgs/GovernancePolkawallet.jpeg)

4. Current state of *Polkadot.js Apps* is mostly catered for experienced users or developers. Besides, it exposes low-level APIs to interact with substrate-based blockchains, which introduces frictions for end-users to interact. 

5. There is no mobile application that could relay the transactions from other wallets on the *Polkadot* ecosystem. And only a few mobile wallets like *Parity Signer* and [Math Wallet](https://mathwallet.org/) could sign the transactions from *Polkadot.js Apps*. The wallet ecosystems are relatively closed.

6. When Council submits emergency proposals, councilors must view and react to the proposals in a timely fashion, but there is currently no efficient way to notify the councilors in case of emergency proposals. This is especially challenging since councilors are in different time zones.

## 3. Proposal Objective/solution/s:

### Objective

We want to create a governance mobile application that could:

1. Offer native governance support integration and Polkassembly off-chain discussion.
2. Improve user engagement by allowing them to receive and customize **Push Notification** of governance-related updates.
3. Provide participants with good governance statistics and gamification scores to incentivize users to join governance.
4. Provide the option to notify App users (in the form of **Push Notification**) for emergency proposals. The notification itself can be customized with a basic ruleset (e.g., users who logged in as Councilors or Technical Councilors members in case of a proposal have to be processed urgently)

|Current Governance Ecosystem| Targeting Governance Ecosystem|
|-------------------------|-------------------------|
|![imtoken](https://raw.githubusercontent.com/hanwencheng/gists/master/Litentry/imgs/governanceBefore.png)|![mathwallet](https://raw.githubusercontent.com/hanwencheng/gists/master/Litentry/imgs/governanceNow.png)|

### Solutions / Milestones

#### Milestone 1: Integrate identity registration
1.1 Offer user the capability to verify Identity (e.g., email, riot) in App.
1.2 Provide a registrar service to verify the submitted identity automatically.
1.3 Display a basic dashboard of governance-related activities for this identity
1.4 Display Identity registration Status on *Polkadot*/*Kusama*.

#### Milestone 2: On-chain governance basic support
2.1 Support native governance actions on *Polkadot*/*Kusama* with good information hierarchy and UX/UI.
2.2 Allow users to subscribe to governance-related updates via Push Notification to improve engagement. (e.g., when a new proposal is up, or it is either being accepted or rejected.)
2.3 Build further on a governance dashboard, allowing the user to see governance-related statistics of any Account. (e.g., if a user is browsing a proposal and wants to learn more about the **proposer**)
2.4 Support role-based Push Notification subscription of a certain type of on-chain events.


#### Milestone 3: Identity Dashboard and customization
3.1 Allow users to customize further **Push Notification** settings to receive the tailored governance-related digest.
3.2 Show identity on-chain governance states on *Polkadot*/*Kusama*.(Extends on Openquare's treasury [reputation data](https://kusama.polkassembly.io/post/352))
3.3 Allow users to participate in discussions from Polkassemby natively in app.
3.4 Further enrich governance dashboard's data of an Identity from different chains.
3.5 Interact with other wallet app and sign the transactions with inter-app communication (work together with WalletConnect [Specification v2](https://docs.walletconnect.org/v/v2.0.0-alpha/tech-spec)).


#### Milestone 4 Governance Score and Lottery integration
4.1 Be able to do on-chain governance actions on different networks.
4.2 Build further on Push notification touchpoint to increase engagement
4.3 Build further on the main dashboard to highlight important proposal or event for the community
4.4 Integrate substrate [lottery](https://hackmd.io/68rduBydTEy4X-ULevd90g) support.

### Network Benefit

* Have more users share their voice on important elections. (`vote`)
* Encourage users to register on-chain identity. (`identity`, `setIdentity`, `requestJudgement`)
* Have users change/update their validator nominations on a regular schedule. (`nominate`)
* Encourage brainstorming of ideas in future updates and changes (`propose_bounty`)
* Encourage user to use tipping system (`tip`, `reportAwesome`)
* Have more users (change their) backing of (candidate) council members (`electionPhragmen`, `vote`)
* Encourage users to use lottery modules and join vote (`buy_tickets`, `vote`)
* Encourage users to join the off-chain discussion on Polkassembly.

## 4. Why Polkadot Network.

The governance on *Polkadot* affects most users, and it is of the most important features among all substrate-based networks.

The technical implementation does not have much difference when we compare *Polkadot*/*Kusama* or Substrate-based networks. So we are doing the work firstly on *Polkadot* and *Kusama*, and then it will be further extended to all the substrate-based networks.

 ## 5. Payments and Conditions
 
 The total estimate time is 438 hours, estimated with 1 designer and 2 developers in mind. In the case of discrepancies of our time estimate (either over or underestimate), we will be revising it in future milestones.
 
 It is calculated with an hourly rate of 70 USD/hour and using DOT 5 USD/Unit as a reference for the total dollar value of 28210 USD.
 
There are 4 milestones in total, and the detailed information of each milestone is listed in the table below,

| Milestone | Task                                                                                                                                           | Research/Design (Hours) | Development (Hours) | Total (Hours) | DOT (Unit) | Dollar Value |
|-----------|------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------|---------------------|---------------|------------|--------------|
| 1.1       | Design Register Backend (BE) to be able to verify Email, riot, and Twitter data                                                                | 6                       | 16                  | 22            | 308        | 1540         |
| 1.1       | Implement in BE of chain monitoring on identity events                                                                                          | 4                       | 4                   | 8             | 112        | 560          |
| 1.2       | Implementation of submission of judgment based on the verified result                                                                           | 5                       | 16                  | 21            | 294        | 1470         |
| 1.2       | Add database layer to BE to persist processed verification                                                                                     | 0                       | 12                  | 12            | 168        | 840          |
| 1.3       | Able to scan address from different source and display its Identity data (e.g. Judgment status)                                                | 6                       | 10                  | 16            | 224        | 1120         |
| 1.3       | Support signing Tx with QR code (integration with Parity Signer and other offline wallets)                                                     | 3                       | 12                  | 15            | 210        | 1050         |
| 1.4       | Design UI/UX to allow user submit identity Info (via forms)                                                                                    | 2                       | 8                   | 10            | 140        | 700          |
| 1.4       | Allow user to request judgment and display its status                                                                                          | 6                       | 12                  | 18            | 252        | 1260         |
|           |                                                                                                                                                |                         |                     |               |            |              |
| 2.1       | Design Information hierarchy of governance and implement corresponding UI/UX                                                                   | 6                       | 16                  | 22            | 308        | 1540         |
| 2.2       | Implement BE infrastructure to be able to send Push notification to device                                                                     | 4                       | 12                  | 16            | 224        | 1120         |
| 2.2       | Implement in App to receive and process Push notification content                                                                              | 6                       | 16                  | 22            | 308        | 1540         |
| 2.3       | Build further on governance dashboard with more information                                                                                    | 8                       | 16                  | 24            | 336        | 1680         |
| 2.3       | Provide detailed screen of the certain proposal and user can see in app directly more identity-related information of *Proposer*               | 4                       | 16                  | 20            | 280        | 1400         |
| 2.4       | Design and implement Setting pages for Push notification based on user roles.                                                                  | 6                       | 16                  | 22            | 308        | 1540         |
| 2.4       | Handle remote navigation when remote Push Notification came in App (Navigate to proper screen)                                                 | 3                       | 10                  | 13            | 182        | 910          |
|           |                                                                                                                                                |                         |                     |               |            |              |
| 3.1       | Design more granular level of Push notification for user to receive, e.g, only receive when a proposal is proposed                             | 5                       | 16                  | 21            | 294        | 1470         |
| 3.1       | Build UI/UX in app to allow the user to customize which Push notification should be received                                                   | 2                       | 12                  | 14            | 196        | 980          |
| 3.2       | Integrate on-chain governance state (Extends from Opensqares proposal)                                                                         | 3                       | 8                   | 11            | 154        | 770          |
| 3.3       | Build UI/UX to integrate Polkassembly functionalities in App                                                                                   | 6                       | 12                  | 18            | 252        | 1260         |
| 3.4       | Connect different sources of on-chain governance data from different chains                                                                    | 6                       | 10                  | 16            | 224        | 1120         |
| 3.5       | Support WalletConnect protocol as a signing method                                                                                             | 3                       | 12                  | 15            | 210        | 1050         |
|           |                                                                                                                                                |                         |                     |               |            |              |
| 4.1       | Support more native on chain governance related actions                                                                                        | 6                       | 20                  | 26            | 364        | 1820         |
| 4.2       | Build further on Push notification touchpoint with a clear and quick call to action button to participate                                      | 4                       | 12                  | 16            | 224        | 1120         |
| 4.3       | Design main dashboard to be able to highlight on-chain governance-related event by showing countdown or teaser with a prominent call to action | 6                       | 18                  | 24            | 336        | 1680         |
| 4.4       | Design and integrate substrate lottery function in to app                                                                                      | 4                       | 12                  | 16            | 224        | 1120         |
|           | Sum                                                                                                                                            | 114                     | 324                 | 438           | 6132       | 30660        |


Here is the summary of the 4 milestones.

| Milestone   | Research/Design (Hours) | Development (Hours) | Total (Hours) | DOT (Unit) | Dollar Value |
|-------------|-------------------------|---------------------|---------------|------------|--------------|
| milestone 1 | 32                      | 90                  | 122           | 1708       | 8540         |
| milestone 2 | 28                      | 102                 | 139           | 1946       | 9730         |
| milestone 3 | 25                      | 70                  | 95            | 1330       | 6650         |
| milestone 4 | 20                      | 62                  | 82            | 1148       | 5740         |
| Sum         | 114                     | 324                 | 438           | 6132       | 30660        |

**Payment suggestion:**

As the proposal will benefit both Polkadot and Kusama network, we could split the proposal with the payment of both DOT and KSM. For example, we accept payments of milestone 1 and 2 in DOT, and accept payments of milestone 3 and 4 in KSM.


Governance-focused Mobile App for all Substrate-based networks

- The Substrate Developer Academy helps developers learn how to create projects using Substrate and the Polkadot ecosystem.
- The program lasts 6 weeks and includes online lessons, a project internship, and a certification.
- Students will learn to build and launch their own blockchain and decentralized applications (DApps).
- Mentors include experienced professionals from the Polkadot community.
- Scholarships are available for those who can't afford the course fees.
- The academy will track the success of its students and provide reports on their progress.
- Future plans include improvements to the program and offering more scholarships.

**Problem: **There are not enough resources available to developers wanting a more hands-on approach to learning Substrate. In order to see a vibrant Polkadot ecosystem, we must first address education so that developers have the tools to build. 

**Goal: **Create a hands-on and affordable educational environment where developers can learn first hand from existing developers in the Polkadot ecosystem. We want to give developers the tools (education and mentorship) to build the next great DApp or Parachain on Polkadot. While Acala has created the educational framework, we need help ensuring that any qualified developer who cannot afford the Academy will have access to it through a scholarship. 


**How we’ll get there… **

The Substrate Blockchain Developer Academy brings together the best in industry expertise, interactive learning, and a recognized certification program to help developers learn to program and build on Substrate and Polkadot in just 6 weeks. Here’s what developers can expect: 


Hands-on Start a Project from Scratch
Understand the Polkadot ecosystem and Substrate codebase. Use Substrate to develop a product-ready blockchain project.

Code & Launch Your First Blockchain & DApp
Learn blockchain design principles. Learn Polkadot.js SDK. Launch your first blockchain, and build a web3 front-end DApp.

Connect with Global Polkadot/Substrate Developers
Connect with the most passionate, accomplished developers in the Polkadot and Substrate ecosystem, and have access to resources and opportunities from ecosystem projects.


**Mentors/Instructors:**
Bryan Chen -- Co-Founder of Acala and CTO of Laminar
Joe Petrowski - Technical Integrations at Parity Technologies
Ricardo Ruis - Runtime Engineer at Parity Technologies 

**Course Details: **
6 weeks of online, video-based content + 4 weeks of project-based internship
The course is $492 -- this fee covers costs and ensures active participation from students. Crypto is accepted as a method of payment. 

Lecture 0 Preparation
1. Why learning Substrate
2. Intro of Lecturer & Tutors
3. Course overview and how to be successful in this Course
4. Prerequisites & Preparation

Lecture 1 Introduction to Polkadot/Substrate
1. What is Substrate
2. Introduction of Polkadot Ecosystem
3. Setup development environment for Substrate
4. Start testnet and send a transaction
5. Substrate Kitties demo

Lecture 2 Substrate Basics
1. Create multi-nodes network
2. Commonly used Substrate command-line arguments
3. Substrate Architecture Overview
4. Substrate Pallet
5. Project file structure

Lecture 3 Writing Substrate Pallets
1. How to create a Substrate Pallet
2. Substrate macros
cargo expand
decl_module
decl_storage
3. Implement Substrate Kitties
4. Code walkthrough: pallet-assets

Lecture 4 Onchain Upgrade
1. Implement Substrate Kitties Version 2
2. Onchain runtime upgrade
3. Code walkthrough: pallet-sudo
4. pallet-member and pallet-collective

Lecture 5 Data Structures, Testing & Debugging
1. Linked-list data structure
2. Unit test
3. Storage comparison: map / double_map
4. Code walkthrough: pallet-balances

Lecture 6 Install & Integrate with Pallets
1. Use pallet-balances pallet
2. Dependency Injection
3. Events
4. Introduce ORML
5. Integrate with orml-nft

Lecture 7 Advanced Topics
1. Weights mechanism
2. Metadata system
3. SCALE codec
4. Offchain worker
5. Code walkthrough: pallet-im-online

Lecture 8 Production Ready, Cross-chain, Parachain
1. Before go live
Security
Transaction fees
Governance
Compatibility
2. Cross-chain message passing
3. Become a parachain


For more information on the program, visit: https://www.industryconnect.org/substrate-runtime-developer-academy/


**Substrate Developer Scholarships:**
There are developers interested in attending who require financial aid in order to participate. We would like for the Polkadot Treasury to provide scholarships to students so that they can learn the skills it takes to build the next great application or parachain on Polkadot. 

**Financial Commitment: **
643 DOTs

**Your commitment provides:**
Full sponsorship of 6 students into the Substrate Developer Academy

**Scholarship Evaluation Process:**
The Acala team will act as a stand in for evaluating scholarship applicants for this Substrate Developer Academy course and will work with other organizations in the ecosystem to identify developers who are in need of financial support. 

**Criteria for scholarship will be based on: **
Applicant has mastered at least 1 programming language
Applicant has a minimum of one year professional coding experience
Applicant has demonstrated financial need. 

**Payment Conditions:**
A one-time payment of 643 DOTs (monthly average of $4.36 per DOT) 
Should there be any funds that are unused, Acala will roll them over into the next Developer Academy for scholarship purposes. At the request of Council, Acala will return any remaining funds to the treasury. 

**Measuring Success: **
At the end of the program, Acala will report back on the amount of participating developers, graduation rate, projects started/completed, and other unforeseen success metrics (e.g., hires into the Polkadot ecosystem, etc). It is our goal to give developers the tools to build -- and then help them integrate into the ecosystem for collaboration and funding opportunities. 

**Future Plans:**
Acala intends to continue refining and improving upon the Substrate Developer Academy. In 2021, we plan to roll out an updated version of the Substrate Developer Academy -- students will be able to apply for a scholarship directly via a Substrate Academy Bounty Program. 

Substrate Developer Academy Scholarships

- Europa is a special environment for developers to test and improve a program called Substrate Runtime.
- It helps in finding mistakes in a type of contract called the `ink!` contract.
- Europa makes it easier to run and check certain operations by offering important services.
- The team is working on improvements for more helpful error messages and better debugging tools.
- They plan to create better ways to see what happens when a contract runs, like tracking errors and execution steps.
- Their future updates will make the debugging experience smoother and connect better with other tools.

This is copy from https://polkadot.polkassembly.io/post/189
 
Github: https://github.com/patractlabs/europa

Europa is a sandbox environment that runs `FRAME Contracts pallet`, and it is also a framework that provides a sandbox environment for Substrate Runtime. Therefore, developers can use the executable files compiled by Europa to debug the `ink!` contract, and they can also use the library provided by Europa as a framework to implement a sandbox environment for the Runtime in their Substrate project.

Europa provides the minimal service components that support Runtime to package and execute transactions normally. Therefore, although Europa can be regarded as a chain node, this node has no consensus system, no network connection, and only retains the Runtime executor, RPC and some other necessary services. In addition, as a WASM contract running sandbox, we modified `FRAME Contracts pallet` to provide more detailed debugging information, including contract execution process information (in `FRAME Contracts` layer) and WASM execution information (in WASMI execution layer).

In order to facilitate debugging and add new features, Europa removed all WASM components in Substrate, so any `std` code can be added to the entire system of Europa to meet experimental requirements.

## Europa's Future development plans

~~v0.1: Have an independent runtime environment to facilitate more subsequent expansion directions.~~

v0.2: Modify at `FRAME Contracts pallet` level to provide more information。

v0.3: Improve the development experience, strengthen collaboration with other tools, and extend the sandbox to be compatible with other runtime modules。

We submitted a proposal for [Europa v0.1](https://polkadot.polkassembly.io/post/102) two months ago, and wrote the [treasury report](https://polkadot.polkassembly.io/post/166). In v0.1, Europa has completed the basic framework of the Runtime sandbox, removed unnecessary modules related to the chain, removed the functional components of WASM, and provided many necessary tool components as a sandbox.

## Detailed design of Europa v0.2

### 1. Fork `FRAME Contracts Pallet` to provide more debug information

Although `FRAME Contracts pallet` has been iterative, its error messages are not friendly to contract development. Although in Substrate's [Commit #6773](https://github.com/paritytech/substrate/pull/6773) and [Commit #7017](https://github.com/paritytech/substrate/pull/7017), the error handling of contracts has been improved a lot, but these error messages are mainly concentrated in the `FRAME Contracts pallet` layer, missing a lot of error information about WASM execution layer. For example, WASM execution crash errors or out-of-bounds errors do not have detailed information. For example, this part of the code in Substrate [`frame/contracts/src/wasm/runtime.rs:LL367`](https://github.com/paritytech/ substrate/blob/master/frame/contracts/src/wasm/runtime.rs#L367)

```rust
		// Any other kind of a trap should result in a failure.
		Err(sp_sandbox::Error::Execution) | Err(sp_sandbox::Error::OutOfBounds) =>
			Err(Error::<E::T>::ContractTrapped)?
	}
}
```

As shown above, because `sp_sandbox::Error` only provides three types of errors, and these error types do not contain more detailed reasons for this error. For example, developers only know that it is an execution error of `Execution` and an out of bounds error of `OutOfBounds`, And all have been converted into `ContractTrapped`. Therefore, the reason for the internal crash of the contract cannot be known to the outside world. In our fork development of `FRAME Contracts pallet`, we will supplement and perfect this short board.

In the execution environment of the contract `wasmi`, all error messages are discarded. For example, in this part of the code in Substrate [`primitives/sandbox/with_std.rs:L287`](https://github.com/paritytech/substrate/blob/master/primitives/sandbox/with_std.rs#L284), The information of `_err` of `Err(_err)` is discarded.

```rust
match result {
    Ok(None) => Ok(ReturnValue::Unit),
    Ok(Some(val)) => Ok(ReturnValue::Value(val.into())),
    Err(_err) => Err(Error::Execution),
}
```

Although the `debug_message` field is provided in the contract RPC call `contracts_call` to provide the function of returning more information before the formal execution in the future, more detailed information still needs some customized development to provide. For details, please refer to the discussion in [ink! issue #589](https://github.com/paritytech/ink/issues/589#issuecomment-731745755). Therefore, the developers cannot well know the error information in the current `FRAME Contracts` layer and the `wasmi` interpretor during the execution of the contract.

On the other hand, when a contract calls a contract, the current `FRAME Contracts pallet` cannot tell the developer which layer of the contracts has a problem. In other words, there is no `Contract Stack trace` information about the execution process of the contract in the `FRAME Contracts pallet`.

In addition, as a tool for contract debugging, the contract module lacks a lot of display for internal execution information, such as displaying the value of the `selector` called by the current contract and the parameters passed by the contract. On the other hand, we can count the gas consumption of the contract calling the contract (not the gas consumption of a single contract, but the gas consumption during the execution), and the number of times of reading, writing, storing, and accessing other interfaces.

### 2. 2. Provide log printing during contract execution

Developers need to know some variables or information during the execution of the contract. The easiest way is to print logs during the contract execution. 

For printing logs information, currently `seal_println(_ctx, _ptr: u32, _len: u32)` is provided in `FRAME Contracts pallet`, and `::ink_env::debug_println()` is provided in `ink!`. This group of functions plus `ink_prelude::format!` can be combined into a feature similar to the `println!` macro in rust to print information to the console. Therefore, after the debugging switch (flag) of the contract is turned on, the following printing can be provided:

```rust
let s = ::ink_prelude::format!("print in contract:{}", 1_u32);
::ink_env::debug_println(&s); // == println!
```

Set `log=runtime=debug`, then start the node, You can see the logs:

```bash
Dec 01 20:02:13.307 DEBUG execute_block:apply_extrinsic: print in contract:1    {ext}
```

The logs printed  in the node by this method are all DEBUG level, and the `target` of the logs are all `runtime`. But compared with `println!`, the existing `log` crate in Rust provides the function of printing logs at different levels (like DEBUG|INFO...), and can use the `target` to filter the log, so the usage of `log` in debugging contracts is more powerful than `println!`.

We hope to provide the following functions in the contract by modifying `FRAME contract pallet` and `ink!` or providing other additional libraries:


```rust
impl Erc20 {
	/// Creates a new ERC-20 contract with the specified initial supply.
    #[ink(constructor)]
    pub fn new(initial_supply: Balance) -> Self {
        use log::{info, trace};
        info!(target: "contract1", "it's info log: {}", initial_supply);
        trace!(target: "contract1", "it's trace log: {}", initial_supply);
        // ...
    }
}
```

After you executed the contract, you can see the logs in node:

```bash
Dec 01 20:02:13.307 INFO contract1: it's info log:123    {ext}
Dec 01 20:02:13.307 TRACE contract2: it's trace log:123    {ext}
```

### 3. Fork `wasmi` interpreter to provide `Backtrace` functions etc.

As a WASM interpreter built by parity, `wasmi` has implemented all the standard functions of WASM. But for contract developers, the execution process of `wasmi` is similar to a black box. The contract developer only knows that the contract is executed by the `wasmi` interpreter after deployment, but cannot know the execution status of the contract in `wasmi`. If you encounter a crash such as `panic`, `wasmi` does not retain the current context and cannot report back the situation in the `function stack`. On the other hand, WASM does not currently provide a good breakpoint debugging and Single-step debugging method, so it is not possible to interrupt during WASM execution to view the information during execution.

Therefore, we plan to fork `wasmi` and provide functions similar to `Backtrace` information. **We may also add Breakpoint Debugging in the future**

In the customized `HardHat EVM`, abnormal [`stack traces`](https://hardhat.org/hardhat-network/#solidity-stack-traces) will be printed during the execution of the Solidity code:

> ```text
> Error: Transaction reverted: function selector was not recognized and there's no fallback function
>   at ERC721Mock.<unrecognized-selector> (contracts/mocks/ERC721Mock.sol:9)
>   at ERC721Mock._checkOnERC721Received (contracts/token/ERC721/ERC721.sol:334)
>   at ERC721Mock._safeTransferFrom (contracts/token/ERC721/ERC721.sol:196)
>   at ERC721Mock.safeTransferFrom (contracts/token/ERC721/ERC721.sol:179)
>   at ERC721Mock.safeTransferFrom (contracts/token/ERC721/ERC721.sol:162)
>   at TruffleContract.safeTransferFrom (node_modules/@nomiclabs/truffle-contract/lib/execute.js:157:24)
>   at Context.<anonymous> (test/token/ERC721/ERC721.behavior.js:321:26)
> ```

In `wasmtime`, when the inside execution of `panic` appears, similar output will be printed:

```text
Error: failed to run main module `target/wasm32-unknown-unknown/debug/bt.wasm`

Caused by:
    0: failed to invoke command default
    1: wasm trap: unreachable
       wasm backtrace:
         0: 0x1cda - <unknown>!__rust_start_panic
         1: 0x1cce - <unknown>!rust_panic
         2: 0x1c9e - <unknown>!std::panicking::rust_panic_with_hook::hc5713da015ebaa19
         3:  0x26e - <unknown>!std::panicking::begin_panic::{{closure}}::h8e62ab0ea555186f
         4:  0xfba - <unknown>!std::sys_common::backtrace::__rust_end_short_backtrace::h34a944558df1326a
         5:  0x15c - <unknown>!std::panicking::begin_panic::h03c636dac2b8fb70
         6: 0x1a65 - <unknown>!_start
```

In `wasmer`, when the inside execution of `panic` appears, similar output will be printed:

```text
error: failed to run `target/wasm32-unknown-unknown/debug/bt.wasm`
│   1: RuntimeError: unreachable
           at __rust_start_panic (bt.wasm[67]:0x1cda)
           at rust_panic (bt.wasm[66]:0x1cce)
           at std::panicking::rust_panic_with_hook::hc5713da015ebaa19 (bt.wasm[65]:0x1c9e)
           at std::panicking::begin_panic::{{closure}}::h8e62ab0ea555186f (bt.wasm[2]:0x26e)
           at std::sys_common::backtrace::__rust_end_short_backtrace::h34a944558df1326a (bt.wasm[36]:0xfba)
           at std::panicking::begin_panic::h03c636dac2b8fb70 (bt.wasm[0]:0x15c)
           at _start (bt.wasm[55]:0x1a65)
╰─> 2: unreachable
```

In `wasmi`, when the inside execution of `panic` appears , only the following output will be printed:

```text
thread 'main' panicked at ': Trap(Trap { kind: Unreachable })', src/bin/instantiate.rs:87:14
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
```

Learning from the `HardHat EVM`, `wasmer` and `wasmtime`, we will make similar modifications to `wasmi` to achieve similar functions. We will migrate the relevant code of [`wasmer`](https://github.com/wasmerio/wasmer) and [`wasmtime`](https://github.com/bytecodealliance/wasmtime) to develop similar functions into `wasmi`.

We estimate that we should at least implement the following two parts in `wasmi` in order to provide a printing function similar to `BackTrace` information in `wasmi`:

1. Keep the stack information of the WASM execution stack.
2. Parse the `Name Section` in the `*.wasm` source file with compilation information to provide corresponding debugging information.

## Detailed plan of v0.2 （6 weeks, 30 Nov ~ 11 Jan）：
   
* M1: Fork `FRAME Contracts pallet`. (3 developers \* 2 weeks) *
    1. Enrich the error types of the module, associate more error messages related to the internal `wasmi` interpreter, and attach some context information to the error and print it in the log.
    2. Provide the function of tracking the contract call stack.
    3. Add Event Tracking to the function defined in the `define_env!` macro to provide statistics on contract execution information.
    4. Provide a function to print statistical data of a period of contract execution to the log.
   
* M2: Provide `log` tools and function/macro in contracts. (3 developers \* 1 weeks) *
    1. Provide components similar to `RuntimeLogger` in Substrate Runtime
    2. Provide the corresponding method in `define_env!` of `FRAME Contracts Pallet`
    3. Provide wrapper functions and other functions for `RuntimeLogger` in `ink!`

* M3: Fork `wasmi`. (3 developers \* 2 weeks) *
    1. Investigate the design of `wasmer`, `wasmtime` and `wasmi`
    2. Design and implement functions similar to `Backtrace` for `wasmi`
   
* M4 : Integration and testing  (3 developers \* 1 weeks) *

The above-mentioned forked repos are independent of Europa repo, and the corresponding functions will not be submitted to the original repo. If there are similar functions in the original repo plan, the corresponding functions will be merged after discussion with the original repo author.

## Cost of v0.2 (18 developers \* weeks)

* Operating activities: $3600 ( Rent and Devices: $200 per developer * week )
* Employee payments: $36000 ($1900 per developer * week)
* —————————— +
* Total Cost: $37800
* Exchange Rate: $5.0 / DOT
* Treasury Proposal: 7560 DOT

## Verification : Github source & Treasury Report

1. Construct incorrect contracts and execute logs printing to determine whether it meets expectations
   1. Can trigger all wrong contracts in `wasmi`
   1. Can trigger all wrong contracts in `FRAME Contracts Pallet`
   1. Construct a contract to call a contract example and crash in it
1. Display the call statistics of the `define_env!` interface during contract execution
1. Execute the log printing function, provide formatted printing examples of different data, and judge whether it meets expectations
1. Construct a contract that crashes under different conditions and record the log after execution. Then judge whether the backtrace information of the contract execution is completely printed, and check whether it matches the actual execution of the collapsed contract.


Patract Hub's treasury proposal for Europa (sandbox) v0.2

- LocalCoinSwap is a platform for trading cryptocurrencies directly between people (P2P).
- It helps people in many places access cryptocurrencies, especially where banks are not available.
- They finished the first part of a project and are now working on the second and last part.
- In the first part, they created tools to help with trading on a special system called Polkadot.
- For the second part, these tools will help users trade Polkadot on LocalCoinSwap.
- Users will have features like wallet access, direct trading, and swapping different kinds of cryptocurrencies.
- They invite people to ask questions or give feedback on their plans.

After successful completion of the first milestone, we are pleased to submit our proposal for the second and final milestone of the LocalCoinSwap non-custodial trading implementation for Polkadot.

**Github:** https://github.com/LocalCoinSwap/

**Homepage:** https://localcoinswap.com/

**Intro:**

LocalCoinSwap is a P2P cryptocurrency exchange which focuses on providing trustless fiat on-ramp solutions, enabling global accessibility for cryptocurrencies. We bridge the gap between users and crypto where centralized exchanges fail, in particular across developing regions of the world where access to mainstream finance is limited.

In the first milestone of this project we extended the kusama-utils library that we previously built to create a generic substrate-utils library. We also extended the Kusama-api to create a generic Substrate-API. These packages are now generically useful for any number of substrate parachains and tokens.

For the second milestone, we will be utilizing these libraries to allow Polkadot to be fully tradable on the LocalCoinSwap API as well as through the LocalCoinSwap front-end application. This includes end-user wallet functionality, non-custodial P2P trading, basic and advanced pricing mechanisms as well as allowing crypto-to-crypto swaps.

Please check out our detailed proposal below and we welcome any questions or feedback: https://docs.google.com/document/d/1vP54xXbJxPC1nJQ0RA7TC4S16mFAuNvSP6iDxfFFcPc/edit

LocalCoinSwap Treasury Proposal - Python Substrate libraries upgrade & Polkadot integration: Milestone 2

- DoraHacks is hosting a Substrate Hackathon in Hangzhou, China on December 19-20, 2020.
- The event will bring together 80-100 people including developers, designers, and blockchain fans.
- There are 10 online workshops about Substrate and Polkadot leading up to the hackathon.
- The hackathon has 20 judges who will review the projects based on their technical and business ideas.
- They are asking for 3000 DOT as prizes and to cover costs of the event.
- Hacker projects will be shared on a specific website and bounties will also be posted there.
- DoraHacks is a big global hacker community known for organizing many hackathons.

**DoraHacks** is running a Substrate Hackathon in Hangzhou, China on December 19th-20th, 2020.

**Venue**: Future Science City, Hangzhou, China

**Time**: 19th-20th, December, 2020

There will be approximately 80-100 Substrate Devs, PMs, designers and other cypherpunks and blockchain enthusiasts joining this event and exploring the fun of hacking with Substrate. We currently received 50+ hacker registrations and are expecting a dev crowd of 80-100 during the weekend of the Hackathon.

This will be the **one and only** Substrate Hackathon taking place in China in the year of 2020, where all Chinese Substrate Developers will gather in Hangzhou to learn, explore, social and create.

We have 10 online workshops about Substrate and Polkadot Ecosystem Intro prior to this event, which will be livestreaming on Bilibili(dev's fav online video and live streaming platform) and recorded. The videos will also be displayed on DoraHacks's official account on Bilibili.

- 12.9 Litentry(John, core dev) : Connect Ethereum identity with offchain worker
- 12.10 Parity(Maggie Dong, Engineer): Introduction to Substrate and Polkadot
- 12.11 Parity(Maggie Dong, Engineer): Parachain and Cross-chain
- 12.12 OpenSquare(Yongfeng Li): How Substrate Treasury Pallet Works
- 12.13 Web 3 Foundation(Qinwen Wang) : Governance and Grants of Web 3 Foundation
- 12.14 Bandot(Feng Chen): Defi 2.0
- 12.15 Rust China Community(Bin Guo, core member): Rust Introduction
- 12.16 Rust China Community(Mike Tang, Founder): Rust in Depth-Future
- 12.17 Polkaworld(Xioajie Pang, Founder): The Development of Polkadot Ecosystem

We have 20 judges and mentors for this Hackathon. They will be commenting on hacker's projects' based on technical and business potential.

- Yaoqi Jia, Parity Technologies
- Maggie Dong, Parity Technologies
- Qinwen Wang, Web 3 Foundation
- Yin Cao, Digital Renaissance Foundation
- Fuyao Jiang, Acala Netwok
- Hanwen Cheng, Litentry
- Denny, Darwinia Network
- Marvin Tong, Phala Network
- Xiaojie Pang, PolkaWorld
- Lipeng Yue, Patract Labs
- Feng Chen, Bandot
- Kamie, Stafi
- Lurpis, Bifrost
- Charlie Hu, CANDAQ Group
- Kyrie Li, Delin Capital
- Jocy Lin, IOSG Capital
- Haiguang Huang, Cabin VC
- Stephanie Lu, Fenbushi Capital
- Mable Jiang, Multicoin Capital

**Our Ask:**

3000 DOT as Hackathon prizes(1500 DOT) and operational costs coverage(1500 DOT)

Hackathon prizes will be distributed to hacker team based on the number of votes they receive from judges and other teams.

Operation costs are mainly the cost of logistics of this Hackathon and our teams effort to make this Hackathon great.

**Hacker Projects** will be uploaded here: https://hackerlink.io/buidl 

**Hackathon Bounties** will be posted here: https://hackerlink.io/bounty

**About DoraHacks(DoraHacks.com): **

DoraHacks is an active global hacker community. We're Hackathon enthusiasts, and did 31 blockchain Hackathons in 2018 in 8 countries, 15 cities. We're also the organizer of the largest Hackathon in China history: the 4th Industrial Revolution Hackathon. We're also the largest blockchain developer community in China.

**About HackerLink(Hackerlink.io): **

Hackerlink has bounty, grant, BUIDL and Hackathon features catering to the needs of Chinese developers when they want to engage with blockchain projects.

**About DoraHacks Global Hackathon Series: **

DoraHacks GHS 2021 is coming back! We're running 15-20 offline hackathons in China, US and Europe in 2020-2021 despite the craziness of Covid-19. We're actively running offline blockchain hackathons in China recently. Our first Hackathon was DoraHacks x Binance Smart Chain Defi Hackathon in Beijing, November 14th-15th where 91 hackers created 17 new Defi Projects. You can find all their contributions here: https://www.theblockbeats.com/news/20748

The initial proposal can be found here: https://polkadot.polkassembly.io/post/193

Substrate Hackathon @ Hangzhou, China on Dec.19-20, 2020

- **Project Name**: Megaclite  
- **Goal**: Add zero-knowledge proof (ZK) support to Polkadot for better privacy and performance.  
- **Key Features**:  
  - Supports four cryptographic curves: alt_bn128, bls12_381, BLS12-377, and BW6_761.  
  - Provides basic math operations (ADD, MUL, Pairing) for these curves in both Native and WASM layers.  
  - Helps developers build privacy-focused apps using ZK Rollup technology.  
- **Future Plans**:  
  - Create tools for developers to use ZK proofs in smart contracts.  
  - Build a sample payment app using ZK Rollup for fast and secure transactions.  
- **Cost**: $31,500 for the first phase (v0.1).  
- **Verification**: Test on Jupiter Testnet, watch YouTube demos, and check GitHub libraries.

**The original post is https://polkadot.polkassembly.io/post/167, after the feedbacks from the group, we have decided to modify our proposal into this, and we have highlighted the difference (bond and deletion)**

## Suggestions from W3F and Parity

> [Arkworks](http://github.com/arkworks-rs/)' library is better than Zcash's old library
> 
> Ethereum's alt_bn128 is too old, we originally decided only add bls12_381, W3F suggests to add another two curves: BLS12-377, BW6_761
> 
> The native layer's design (Runtime interface or WASM boundary) for final complete crypto curves support is TBD, so we will not try to merge our code into Substrate about the crypto units in native layer. We will change this project as the POC and show the real benchmark difference of native and WASM implementation. So, we have decided to deliver two version of the crypto units (ADD, MUL, Pairing) of those four curves in native layer and in Runtime WASM layer.

Among the current Layer 2 solutions to the privacy and throughput problems of blockchains, zero-knowledge proof is considered the most powerful solution. Compared with Channels, Mixers, and Ring Signature, zero-knowledge proof is the most difficult to implement, but the effect is the best, and it can be applied to almost all scenarios on the blockchain. With the development of some technologies around the Ethereum community in recent years, the efficiency of zero-knowledge generation and verification has been greatly improved, and the upper layer abstract has become more and more mature, and the development difficulty has been greatly reduced. Recently, some related projects have appeared in the Polkadot community, such as [Matter Labs](https://matter-labs.io/), [Starks Network](http://www.gbctech.cn/), etc., but for WASM smart contract and Runtime development, the Substrate framework still lacks some underlying technical support.

Patract Hub https://patract.io develops local open source tool suite and a one-stop cloud smart IDE, and is committed to providing free development tools and infrastructure services for Polkadot's WASM smart contract ecosystem. Megaclite is the 5th project of Patract Hub. In the process of developing this project, we will also launch the 6th project at the same time: Metis, a WASM smart contract library. The Megaclite project will be dedicated to introducing basic zero-knowledge proof underlying support for the Polkadot ecology, so that developers can easily develop applications at the upper level through WASM smart contracts or Runtime. Megaclite will  support the more mature zkSNARK-related technologies firstly, and may also support zkSTARK-related underlying technologies later.

## ZK Rollup Introduction

Compared with the privacy function, the performance improvement brought by Rollup is the early application direction of zero-knowledge proof. At present, the Layer 2 expansion plan of the blockchain is to transfer a considerable part of the on-chain workload to off-chain to complete, and the most watched one is ZK Rollup. The essence of ZK Rollup is to compress the application on-chain state and store it in a Merkle tree, and move the state transition funtions to off-chain. At the same time, the correctness of the off-chain state transition process is guaranteed through the proof of zkSNARK. Compared with the high cost of directly processing state changes on the chain, the ZK Proof's on-chain smart contract verification is extremely cost low. At the same time, the compressed information will also be submitted to the chain together with the proof, which ensures data availability and obtains the same level of security as Layer 1.

The Ethereum Layer 2 protocols related to ZK Rollup are: [zkSync](https://zksync.io/), [aztec](https://aztec.network/), etc. Their contract verification modules share a part of the elliptic curve's basic algorithms. In 2017, Ethereum integrated three basic cryptographic calculation units of the alt_bn128 curve in the form of pre-compiled contracts, which are [EIP196](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-196.md)’s ADD and Scalar_MUL algorithms, and [EIP197](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-197.md)’s Pairing algorithm. On top of this, due to the lack of rapid upgrade capabilities of Ethereum, the community can only encapsulate some tool libraries through costly Solidity contracts. On top of these basic contract libraries, many DApps can combine ZK Rollup technology to achieve some innovations, such as [loopring](https://loopring.org/), [gitcoin](https://gitcoin.co/) and [uniswap](https://uniswap.org/) etc. However, in the past 3 years, ZK technology has further developed, such as the more practical [BLS curve](https://electriccoin.co/blog/new-snark-curve/), and [PLONK algorithm](https://eprint.iacr.org/2019/953/20190827:165656) etc. Ethereum has not yet supported it.

## Megaclite's Future Development Plan （v0.1 ~ v0.3）

Github：https://github.com/patractlabs/megaclite

Megaclite will firstly provide the following functions on our Jupiter smart contract testnet. ~~After full verification, we will apply to Parity to merge this into the Substrate framework.~~

- Provide more on-chain underlying cryptography support than Ethereum. The current stage includes two curves : [alt_bn128](https://github.com/zcash-hackworks/bn) and [bls12_381](https://github.com/zkcrypto/bls12_381) , **and two more: BLS12-377, BW6_761**

- Integrate ADD, MUL, Paring units in Native layer, and provide them to Runtime applications through Runtime-Interface, and further provide them to WASM contract applications through Contract-Seal

- **Integrate ADD, MUL, Paring units in Runtime WASM layer, and provide them to WASM contract applications through Contract-Seal**

- Through Pallet and Ink! contract libraries, providing more higher-level verification and crypto tools than Ethereum, improving execution efficiency and reducing development costs

- Provide off-chain cryptography toolbox through Rust SDK

- Provide typical sample applications through Ink! sample contracts

### v0.1: Provide on-chain support for elliptic curve alt_bn128 and bls12_381 **and BLS12-377, BW6_761**(5 weeks)

- Integrate addition (ADD), scalar multiplication (MUL) and Pairing functions of the curves in Native layer **and Runtime WASM layer**.

- Provide these three functions to the upper Runtime Pallets and Contracts to call.

- In the Runtime layer and the Ink! contract layer, provide two zkSNARK Verify upper-layer interfaces ( verification function of groth16, similar to the Verifier library of [ethsnarks](https://github.com/HarryR/ethsnarks)).

- Start the Metis project and implement EdDSA, MerkleTree, MiMC Hash, etc. contract library on the Ink! contract layer.

### v0.2: Provide off-chain toolbox support for Ink! contract (5 weeks)

[ZoKrates](https://github.com/Zokrates/ZoKrates) is the zkSNARKs toolbox on Ethereum. It helps developers generate computable proofs using high-level languages and verify the proofs in the Solidity environment. We will transform this toolbox based on ZoKrates to adapts to the Ink! smart contract environment.

-  Support the complete commands supporting the zkSNARKs protocol, including the use of Compile, Setup, Compute-witness, Generate-proof, Export-verifier and other commands in the Ink! smart contract environment

- Provide Javascript toolkit, support API interface, including compile, computeWitness, setup, generateProof, exportSolidityVerifier, etc.

### v0.3: Create a sample payment DApp based on Megaclite (6 weeks)

Payment is one of the typical scenarios for the large-scale popularization of blockchain applications. However, due to the performance, cost and scalability of the Layer 1 basic chain, low-latency and high-throughput payment applications cannot be implemented on the Layer 1 chain. Now benefiting from the basic capabilities of zkSNARKs provided by the previous two versions, we will implement a highly scalable payment application based on Layer 2 ZK Rollup technology for the community. 

The application has the following characteristics: completely trust-free, anti-censorship, high security, fast real-time, high throughput. Developers can reuse the application code with very few changes and directly apply it to the Polkadot WASM smart contract ecosystem to serve large-scale community users, and it will also bring great scalability to the Polkadot parachain.

- Provide a Metis smart contract library that supports deposit, withdrawal, transfer and verification of off-chain ZK proof
- Provide ZKP engine including transaction pool, Merkel state tree, circuit, and proof generation
- Provide state management module and transaction pool module

## Detailed Design of v0.1: 5 weeks (16 Nov - 21 Dec)

### M1: Integrate the basic units of alt_bn128 & bls12_381 & **and BLS12-377, BW6_761** (3 developer * 1 weeks)
1. ~~Prepare the 3 basic algorithm codes (Add, Scalar_Mul, and Pairing) of alt_bn128 elliptic curve from zcash's official library [bn](https://github.com/zcash-hackworks/bn)~~ 
2. ~~Prepare the same 3  basic algorithm codes of bls12_381 from zcash's official library [bls12_381](https://github.com/zkcrypto/bls12_381)~~
3. **Prepare the basic algorithm codes (Add, Scalar_Mul, and Pairing) for 4 curves from arkworks' library** 
4. Integrate the above algorithms into the under layer of Substrate Runtime **and Runtime WASM layer**.

### M2: Provide to upper runtime and smart contract applications (3 developers * 1 weeks)
1. Add Runtime_interface to the Jupiter testnet and provide it to Runtime applications.
2. Add Contract_Seal to the contract module of the Jupiter testnet and provide it to the WASM contract application.

### M3: Integrate upper-level verification and tool functions (3 developers * 1 week)
1. The runtime pallet that implements the zkSNARK verification algorithm.
2. The Metis contract library that implements the zkSNARK verification algorithm.
3. The Metis contract library that implements other commonly used algorithms, such as EdDSA, MerkleTree, MiMC Hash, etc. and other commonly used algorithms.

### M4: Test (3 developers * 1 week)
1. Test six basic elliptic curve algorithms
2. Test the zkSNARK verification algorithm of the Runtime layer
3. Test the zkSNARK verification algorithm implemented in the contract layer
4. Test EdDSA, MerkleTree, MiMC, etc. and other commonly used algorithm contract templates.

### M5: Benchmark (3 developers * 1 week)
1. Provide benchmark results of all the above functions and develop them for the community as a reference for transaction weight and pricing.

## Cost of v0.1 (15 developers * weeks)
* Operating activities: $3000 ( Rent and Devices: $200 per employee \* week )
* Developer payments: $28500 ($1900 per developer \* week)
* —————————— +
* Total Cost: $31500
* Exchange Rate: $5.8 / DOT
* Treasury Proposal: 5431 DOT

## How to verify v0.1: Jupiter Testnet & Youtube demo & Github library

1. The cryptographic units can be verified through the Runtime and Metis contract modules that we deploy on Jupiter.
2. The upper-level Verification function can be verified through the Runtime and Metis contract modules deployed on Jupiter.
3. The functions of the upper-level tools can be verified through the Metis contract module deployed on Jupiter.
4. You can view and reproduce our Benchmark results.


Patract Hub's treasury proposal for Megaclite (ZKP support) v0.1

Redspot is a tool developed by Patract Hub for creating smart contracts easily. Its main features and future plans include:

- It aims to simplify contract development and provide useful tools, like plugins for testing and checking performance.
- The next big updates will focus on promoting Redspot and making it easier for developers to join and use it.
- It will also support TypeScript and create plugins for specific needs like testing and performance reports.
- Redspot's team is working on building a user-friendly website with tutorials and FAQs for better guidance.
- They plan to create new plugins like the Jupiter testnet for customized contract development and a tool to report gas consumption during contract transactions.
- The estimated cost for their upcoming plans is around $32,700. 

You can learn more on their official website and GitHub.

This is copy from https://polkadot.polkassembly.io/post/157

Github: https://github.com/patractlabs/redspot

Homepage will be: https://redspot.patract.io

Patract Hub (https://patract.io) develops local open source toolkits and one-stop cloud smart IDE, committed to provide free development toolkits and infrastructure services for the entire smart contract ecosystem. Redspot's goal is to standardise the contract development process, hide the underlying compilation details of the contract, and combine the sandbox, library, API, SDK and other plugins to create a one-stop smooth contract development process. 

## Summary of Redspot’s Future Plan：

- ~~v0.1: Build core functions based on Truffle framework~~
- ~~v0.2: Migrate to Hardhat framework to enhance the extensibility of plugins and add some features to provide a smoother development workflow~~
- v0.3: Promote Redspot and allow more contract developers to participate. Combine the features of Substrate to add various plug-ins, such as Waffle, Jupiter, Gas report.
- v0.4: Provide Typescript type support for contracts (similar to Typechain), integrate multi-language SDK, etc.

We have finished the second [proposal](https://polkadot.polkassembly.io/treasury/13) requirements for v0.2,  and wrote a development [report](https://polkadot.polkassembly.io/post/156). This proposal will explain in detail the design details of Redspot v0.3. After ink! v3 was released last month, many developers began to pay attention to the development of the WASM contract. After the refactoring of v0.2, Redspot also has more powerful functions. We think now is the time to get help from Parity and W3F, and promote Redspot to the community. We hope to serve more developers and get their feedback to help us fix bugs and optimize Redspot.

We expect a major upgrade to the plugins system in the future. This upgrade is mainly to strengthen TypeScript support, simplify the introduction of plugins, and strengthen support for multiple contracts. We also plan to add more Redspot plugins:

1. Jupiter testnet plugin. Jupiter is a testnet we provide specifically for contract development. It has made some modifications to the pallet contract. We expect that after different chains integrate the pallet contract, there will be some customized modifications to the contract. Therefore, in the face of different chains with contract functions, Redspot will design plug-ins for the contract environment of this chain. The Jupiter test chain plugin will show how Redspot is compatible with different parachain contract development through plugins.

2. Gas report plugin v0.2. This plugin can print out gas consumption reports for all transactions of the contract.

3. Waffle's assertion library (https://ethereum-waffle.readthedocs.io/en/latest/matchers.html). It provides a lot of friendly matchers to make contract testing easier to write and read. Especially in polkadot.js, because all data is an object, testing is more difficult. You cannot directly judge `expect(A).to.Be(B)`, you must judge `expect(A.toHex()).to.Be(B.toHex())` like this. A custom matcher can simplify this step.


## Detailed design of v0.3 （5 weeks，03 Nov ~ 8 Dec）

### M1: Homepage and API docs page development  ((1 designer + 3 developer) * 1 week)

1. Develop https://redspot.patract.io, include logo design, UI design, UX design, and promotional materials.
2. Establish Redspot's brand reputation and draft promotional copy.
3. Technical selection of homepage and API documents, and development of front-end web pages.
4. Write CI that automatically publishes API documents to ensure real-time updates of documents.
5. Establish the i18n program, officially support Chinese and English, and accept translations from other languages in the community.

### M2: Write detailed tutorials and documents (3 developers * 1 week)

1. Add detailed comments to each externally provided function so that developers can get more detailed code hints when using TypeScript.
2. Add a tutorial on how to use Redspot and a tutorial on how to write a plugin for Redspot.
3. Add a page explaining the error code in detail. In the process of using Redspot, errors logs will link to this page.
4. Add a Q&A page that lists the problems and solutions frequently encountered by developers.
5. Write the plugins documentation.

### M3: Upgrade Redspot's plugin system (3 developers * 1 week)

1. Improve TypeScript support, so developers don't need to import the tsconfig.json file.
2. Delete the usePlugin function, developers can automatically import the plug-in when imported/required.
3. Better support for multi-contract projects, artifacts can generate nested directory structure.
4. Improve the TypeScript type support of the plugin, so developers don't need to manually import type-extensions.d.ts.
5. Develop CI, automated testing and release version.
6. Specify version number and release process. Write a changelog to record the changes made during each upgrade.

### M4: Develop Jupiter plugin and Gas Report v0.2 plugin (3 developers * 1 week)

1. The Jupiter testnet is optimized for contract address generation. We will add the Jupiter plugin, which can add new contract APIs and change the way the internal address is generated. This plugin will be used as an example to show the compatibility and scalability of Redspot in supporting contracts on different chains.
2. The previous version of Gas Report v0.1 will print Gas consumption when invoking transactions. In the new version of Gas Report, we will package it as a standalone plug-in. It can add a Task, which will print out the Gas consumption of all transactions in the current contract. It will also expand the test Task, and print out the Gas consumption of all transactions when the test is finished.

### M5: Develop assertion library (3 developers * 1 week)

1. Investigate existing matchers for contract testing on Ethereum and design matchers based on @redspot/patract.
2. Implement the matcher.
3. Implement a universal polkadot.js matcher.

## Cost of v0.3 (1 designer \* week + 15 developers \* weeks)
* Operating activities: $3200 ( Rent and Devices: $200 per employee \* week )
* Designer payments: $1000 ($1000 per designer \* week)
* Developer payments: $28500($1900 per developer \* week)
* —————————— +
* Total Cost: $32700
* Exchange Rate: $4.1 / New DOT
* Treasury Proposal: 7975 New DOT

## How to verify: Official Website & Youtube demo & Github library

* View Redspot's homepage https://redspot.patract.io
* Check out the documents and tutorials we wrote
* Jupiter plugin
    * Support unique settings on Jupiter
    * Modify the address calculation method of Redspot's contract
* Gas Report plugin v0.2:
    * A command to print gas consumption
    * At the end of the test, print gas consumption
* Demonstrate the usage of assertion library
    * Support `@redspot/patract` return value matching
    * Support matching of values in polkadot.js

Patract Hub's treasury proposal for Redspot v0.3

- The proposal is for funds to help cover expenses for SUBSCAN from December 2020 to February 2021.
- SUBSCAN is part of the Polkadot network and costs about $1500 per month for Google Cloud services.
- They have paid for their own operating costs for over a year and now need financial support.
- Operation and maintenance expenses include services like Cloud SQL and Cloud Storage.
- SUBSCAN is open to providing more details about the costs if needed, but some information is private.
- They plan to apply for funds every few months or at the start of each month based on previous costs.
- Their goal is to create a sustainable business model and eventually become independent.

The funds applied for in this proposal will be used for the operating expenses of SUBSCAN (Polkadot network) from** December 2020 to February 2021**. 

https://polkadot.subscan.io/

According to the October Google Cloud Platform bill from SUBSCAN, the cost to Polkadot network is about $1500. SUBSCAN have already borne the operation and maintenance costs for more than one year. Our project currently lacks sources of income, in order to continue to operate, we need to apply for financial support.

**Operation and maintenance costs include:**

Compute Engine

Cloud SQL

Stackdriver Logging

Cloud Storage

...

If a more detailed bill is required, we can provide it to council members privately. Please understand that this involves some trade secrets.

This time we did not include all the operation and maintenance costs in the proposal. We are willing to continue to afford part of the cost of these network and contribute to the ecology.

In the future, We are tentatively applying once every quarter. Or, at the beginning of each month, Apply for funding allocation based on last month's bill. We are looking for a sustainable business model. After earning income, we will gradually reduce the amount of application and become an independent ecological project.

The operating expenses of SUBSCAN (Polkadot network) from December 2020 to February 2021

- The Polkadot ecosystem is growing, but new users find it hard to join.
- New users usually have to use centralized exchanges, which can be difficult.
- There is a proposal for an easy way to buy DOT (Polkadot's currency) called Ramp.
- Ramp makes buying DOT simpler by allowing users to use one interface that connects to their wallet.
- Users can buy DOT quickly with cards or bank transfers without leaving their app.
- Ramp aims to make the onboarding process faster, from days to just minutes.
- This will help more people use and develop new projects in the Polkadot ecosystem.

[Following our discussion on Polkassembly](https://polkadot.polkassembly.io/post/150) - here is the proposal for on-ramp to polkadot ecosystem.

**Intro:**
We see the Polkadot ecosystem developing, but for usage numbers to come, easy access for new users must be ensured. Currently, the first-time user willing to enter the ecosystem must enter either via centralised exchange. These steps are bearable for the current users of the network and crypto-natives, but will be a huge obstacle to new participants.
To significantly improve the process for the end-user, networks need on-ramps for easy, streamlined access using fiat money.

**Solution**
Here enters Ramp. With Ramp the purchase process takes place in just one interface, it is directly correlated to the wallet user is using for the purchase and, usually, takes much less time and requires fewer data than centralised exchanges need.
Ramp offers a powerful SDK that allows developers to offer DOT purchases with cards, bank transfers and open banking within their apps. This means that Polkadot powered solutions requiring DOT to use wouldn't need to ask new users to leave the app to complete the purchase. Think of it as Stripe for crypto onboarding. 
With Ramp, we want to provide DOT users and developers with a battle-tested alternative to a centralised exchange: an on-ramp that easy to implement and delightful to use. It will shorten the onboarding process from a few days to a few minutes which will contribute to the overall development of the Polkadot ecosystem.

Details of the proposal: https://docs.google.com/document/d/1u0h1CRrK-a-a83mecWSzNfvlBxUCurFf6Z6cME_HHCA/edit?usp=sharing

Adding DOT to Ramp's SDK and enabling frictionless on-ramping across multiple dapps and wallets

- LocalCoinSwap is an online place where people can trade cryptocurrencies safely without needing a bank.
- They want to make it easier for everyone around the world, especially in places where banks are hard to reach.
- After testing their ideas with Kusama, they're ready to create new tools that can work with many different currencies.
- They plan to make a special way to trade Polkadot (DOT) that doesn't need someone to hold your money for you.
- The proposal has been updated to include more details about the project.
- They welcome questions and feedback about their plan.

Following on from our initial [Polkassembly discussion post](https://polkadot.polkassembly.io/post/144#9a968c2d-15a1-4252-9015-303d83145838) we are pleased to submit our proposal for the first milestone of the LocalCoinSwap non-custodial trading implementation.

**Github:** https://github.com/LocalCoinSwap/

**Homepage:** https://localcoinswap.com/

**Intro:**

LocalCoinSwap is a P2P cryptocurrency exchange which focuses on providing trustless fiat on-ramp solutions, enabling global accessibility for cryptocurrencies. We bridge the gap between users and crypto where centralized exchanges fail, in particular across developing regions of the world where access to mainstream finance is limited.

After a successful proof of concept with Kusama, we are now looking to extend the underlying infrastructure that we have developed to make a single package that is generically useful for any arbitrary number of parachains and tokens. We will then use this package to develop an open-source non-custodial trading integration for Polkadot. This will allow a trustless non-custodial fiat on/off ramp for DOT.

Following on from the discussion in the original thread, we have updated the proposal to better reflect the full scope of the project. Please check out our detailed proposal below and we welcome any questions or feedback: 
https://docs.google.com/document/d/1vP54xXbJxPC1nJQ0RA7TC4S16mFAuNvSP6iDxfFFcPc/edit#

LocalCoinSwap Treasury Proposal - Python Substrate libraries upgrade & Polkadot integration

### Moonbeam Multisig Proposal Summary

- **Objective**: Ensure the availability and support of the Moonbeam Multisig interface (Moonbeam Safe).
- **Tasks**: Include incident support, updates, and adding new features like Safe Apps and Wallets.
- **Team**: Comprised of a Chief Technology Officer, Project Manager, Blockchain Engineers, DevOps Engineers, and a Tester.
- **Experience**: The team has extensive experience with Gnosis Safe, including development and deployment across multiple chains.
- **Benefits**: Enhances security, attracts high-net-worth individuals, and supports TVL growth in the Moonbeam ecosystem.
- **Cost**: Requesting $51,359 for 7 months, covering infrastructure and team costs.
- **Use of Funds**: Allocated for infrastructure, support, and optimization services.

This is a treasury proposal whose proposer address (12Vv2LsLCvPKiXdoVGa3QSs2FMF8zx2c8CPTWwLAwfYSFVS1) is shown in on-chain info below. Only this user can edit this description and the title. If you own this account, login and tell us more about your proposal.

Moonbeam Multisig support and optimization services for Moonbeam, Moonriver and Moonbase for Dec/2023 and full 1st Semester/2024

Elara is a project by Patract Labs aimed at helping developers create smart contracts. Here are some key points:

- Elara is a free toolset for building smart contracts on Polkadot.
- It provides services to help developers easily access and manage their projects.
- The project is being developed in stages, with the next stage (v0.2) focusing on features like account management and project statistics.
- Developers can log in using their GitHub accounts to create and manage projects.
- Elara will help developers understand how their projects are performing with detailed statistics.
- The team plans to finish the next steps in about 5 weeks and has a budget of $35,200 for this phase.
- The goal is to make it easier for developers to focus on creating applications rather than worrying about infrastructure.

This is copy from https://polkadot.polkassembly.io/post/141

Github: https://github.com/patractlabs/elara

Homepage: https://elara.patract.io

[Patract Hub](http://patract.io/) is a community based non-profit organization, developed and maintained by [Patract Labs](https://patractlabs.com/?lang=en-US). We develop local open source toolkits and one-stop cloud smart IDE, dedicated to provide free development toolkits and infrastructure services for the entire smart contract ecosystem. 

Elara's goal is to build a similar infrastructure and network public access services to provide developers with a unified access layer based on Substrate multi-chain. In addition, Elara will be used as part of the smart contract development service, and will be integrated with other components of the Patract toolchain in the future, in terms of contract development environment support, development tools component, contract deployment and DApp release. Elara will be Polkadot’s infrastructure, allowing developers to focus on building upper-level applications.

## Summary of Elara’s future plan:
- ~~v0.1: Implement a server-side framework and proxy access to automatically monitoring and provide statistics for the Substrate node’s RPC service~~
- v0.2: Expand features about developer’s account management, project management, data access and traffic statistics to provide public access services for Polkadot
- v0.3: Performance optimization and architecture upgrade, support multi-chain architecture, access to multiple mainnets in the Polkadot ecosystem
- v0.4: Automatically access and maintain blockchains in Polkadot ecosystem

We have finished the development work of Elara v0.1 on time, and written a treasury report at https://polkadot.polkassembly.io/post/139. This proposal focuses on Elara v0.2, and will continue to develop the following features on the basis of v0.1.

- Implement the account space features, supporting developers to use Github as a third-party login system to create an account space.
- Support the creating and management of multiple projects under the developer’s account space
- Provide developers with detailed access statistics features on the single project dimension, showing statistical indicators such as daily and weekly requests, calling methods, and source of user groups.
- Officially launch https://elara.patract.io, providing the community with public access services to the Polkadot mainnet

## Detailed design of v0.2 (5 weeks, 27 Oct ~ 1 Dec)
### M1: UX Design & Project Management ( (1 designer + 4 developers) \* 1 week )
1. Product requirements analysis and developer experience design
2. UX design, showing related information such as the project mainnet, developer console and project statistics
3. Project demand management, feature tracking and project development, testing, integration progress control
4. Data structure design, store account space information, project information and statistical index information
5. System architecture design, storage structure design and program module definition.

### M2：Development （4 developer \* 3 weeks）
1. Implement developer account space
	1. Apply for Github OAuth Apps
	2. Deploy Redis storage service
	3. Develop authentication interface, dock Github OAuth, implement account information access
	4. Develop an account system to implement the storage and reading of developer account information
	5. Develop a login system to implement the session management of the developer's Github account
	6. Develop API function and provide external account related API interface

2. Implement project management
	1. Deploy Redis storage service
	2. Develop project creation, information showing, list showing features
	3. Develop the frequency and traffic restriction functions for project usage
	4. Develop API functions and provide external management interfaces for projects

3. Implement project monitoring and statistics
	1. Deploy Kafka message middleware
	2. Deploy Redis storage service
	3. Develop a log reporting interface to implement asynchronous reception of data reporting from other modules
	4. Develop data timer to implement statistics and analysis of reported data
	5. Develop API functions, provide external statistics API interfaces, provide project’s statistics for the current day and recent weeks on dashboard

4. Implement the official website
	1. Develop the official website pages to display information
	2. Develop authorization interaction with Github OAuth to implement account information access
	3. Develop the docking with the account system to implement the login interaction between the developers and the system
	4. Develop the console page, display the account's project information, and the corresponding operation information
	5. Develop the project’s details page to display detailed information and statistical results.

5. Implement  the open access to Polkadot mainnet
	1. Develop the log reporting feature of the agent access module to implement the monitoring log of the requests
	2. Deploy the node for Polkadot mainnet
	3. Configure access to Polkadot mainnet

### M3：Integration （4 developer \* 1 week)
1. Integrate developer account service and authorized access of Github OAuth
2. Integrate developer account system, project management and Elara’s console page
3. Integrate Kafka message middleware access proxy service and monitoring statistical service
4. Integrate Elara’s dashboard, project information page and back-end statistical data service
5. Implement client access to Elara’s sample service to provide a demo sample

### M4： Testing（4 developer \* 1 week)
1. Test account services, statistical services, and proxy access service programs
2. Test official website, project console and functional interaction
3. Test the client request access function
4. Test server monitoring statistics function
5. Test the dashboard page

## Cost of v0.2 (1 designer \* week + 20 developers \* weeks)

* Operating activities: $4200 ( Rent and Devices: $200 per employee \* week )
* Designer payments: $1000 ($1000 per designer \* week)
* Developer payments: $30000 ($1500 per developer \* week)
* —————————— +
* Total Cost: $35200
* Exchange Rate: $4.8 / New DOT
* Treasury Proposal: 7333 New DOT

## Verification：Public service & Youtube demo & Github source

- Developers can use Github account to log in to the developer account space from https://elara.patract.io
- Developers can create new projects and access related API keys under the account
- Developers can access the Polkadot node in Elara through Http and web-socket protocols
- Developers can view the monitoring statistics of the projects on the day and the recent weeks
- You can view the relevant monitoring statistics from the Elara dashboard

Patract Hub’s treasury proposal for Elara v0.2

**Polkadot and Kusama News Authoring Tool**

- Many people get news about Kusama and Polkadot from online sources like Twitter and blogs, but it can be slow and hard to access.
- Sharing links on platforms like Telegram isn't very effective for reaching audiences quickly.
- Developers and marketers find it difficult to create eye-catching posts or images for social media.
- There’s a need for a tool that helps create quick and easy news updates and knowledge tips.

**Proposed Tool Features:**
- Users can create an appealing image just by writing a title and details.
- It will have templates to choose from for different kinds of posts, making sharing smoother.

**Use Cases:**
1. Developers can quickly broadcast good news by generating an image, so viewers can see the full content by simply clicking on it.
2. Users can explain concepts like "what is the Kusama council" in an easy-to-understand way by sharing custom images.

**Goal:** The tool aims to improve how news and knowledge are shared in the Polkadot ecosystem.

Rejected

Previous discussion can be found at [post 138](https://polkadot.polkassembly.io/post/138).


# Problems
We got news about Kusama and Polkadot from twitter, social media, and blogs. But to get them, first we need to open the corresponding links in the browser and sometimes we may need to login. For knowledge, usually we search some topic with google, or go to [substrate.dev](https://substrate.dev/) to search the tip we are interested in.

Problems with current situation:  
- News are not fast enough and not effective to readers. Even in telegram when we share the link, though we can see a short description, it's not cool and not effective to audiences.
- Twitter message authoring and post writing is time consuming, while it's nearly impossible for a developer or marketing staff to create some cool images to polish the content.
- It's hard for developers to share some knowledge in a flash and effective way.
- Image is the most popular way to broadcast info in China. We broadcast them in wechat chat groups and friends circle, but currently there are no convenient ways to generate flash news or knowledge tips for Polkadot ecosystem projects.

# Authoring tool

We propose a **knowledge tip** and **flash news** authoring tool to solve the above problems. With this tool we can:
- Write only title and detail to generate a cool image which is very easy to broadcast and friendly to content audience.
- Some image banners are prepared, and authors just need to choose one from them.

Following scenarios will be supported to help Kusama, Polkadot and other ecosystem projects to broadcast news and knowledge tip.

1. Project may have a flash good news which they want to spread it fast. Then a developer generate a image contains the news, and broadcast it to the telegram channels. Telegram readers just click the image, and the full content is shown to them, and they don't have to open the browser.

2. A normal user open this cool, create a image which explain 'what is kusama council', then broadcast it to social media. The content readers can reach this explanation in a fast way and ecosystem users can get this knowledge in a very clear way.

# Design drafts of this tool

![](https://i.imgur.com/KxlccWi.png)

![](https://i.imgur.com/CPk8y4J.png)

And the generated image may look like follows:

![generated-image](https://i.imgur.com/LUurImp.png)

# Milestones

## M1(One week)
- Design, including the page layout and several banners for the templates. One designer and one developer will be involved.
- Front page components development and 2 developers will be involved.

Cost: 4000$ = 833Dots, while each Dot cost 4.8$.

# Future work

- More themes for Polkadot and Kusama
- More default banners for Polkadot and Kusama
- Support customized banner

---

We are [OpenSquare](https://www.opensquare.network/), and we are dedicated to facilitate the collaborations between Polkadot ecosystem projects and developers, designers, etc.

OpenSquare's treasury proposal for a knowledge tip authoring tool

- **Service**: BlastAPI provides high-performance HTTP and WSS APIs for Moonbeam, Moonriver, and Moonbase alpha networks.
- **Cost**: $21,000 for Q2 2023, payable 80% in GLMR and 20% in MOVR tokens.
- **Features**: 99.9% service availability, 24/7 monitoring, and support.
- **Regions**: Multi-region support in EU, US, and APAC.
- **Usage**: Free tier offers 12 million API calls/month with 40 calls/second.
- **Decentralization**: BlastAPI decentralized in Q2 2023, reducing costs by $1,000/month.
- **Public APIs**: Available for Moonbeam, Moonriver, and Moonbase alpha.
- **Support**: Ongoing since June 2021 for Moonbase alpha and Moonriver, and since January 2022 for Moonbeam.

This is a treasury proposal whose proposer address (15G4hfDNtNhRc82As8Ep2YfvpM5xVdX7De3P9qSdHerGA6wC) is shown in on-chain info below. Only this user can edit this description and the title. If you own this account, login and tell us more about your proposal.

Blast support for Moonbeam, Moonriver, and Moonbase alpha (Q2 2023)

Elara is a new project in the Polkadot ecosystem that aims to help developers manage connections to multiple blockchains, making it easier and cheaper to build apps.

- Elara allows developers to access the Polkadot network through a simple interface.
- It is inspired by a service called Infura used in Ethereum.
- The project will improve how developers connect to different blockchains.
- Elara will provide useful tools and services for smart contract development.
- There are plans for different versions to add more features over time.
- Version 0.1 will focus on creating a server for developers to monitor their requests.
- The project aims to support many developers and their app projects efficiently.

FYI: This is copy from: https://polkadot.polkassembly.io/post/103, and Elara is the fourth project that we planned in our roadmap https://polkadot.polkassembly.io/post/100.

Github: [https://github.com/patractlabs/elara](https://github.com/patractlabs/elara) and Homepage will be: [https://elara.patract.io](https://elara.patract.io)

In Polkadot, Kusama and other parachains, RPC is the interface between DApp and the network. As the Polkadot network continues to expand, more and more parachains will be online, and more and more parachains will support smart contract functions. Faced with more and more parallel chains, developers need to build and maintain multiple blockchain nodes in order to interact with them, which will be a huge development cost for them. Whether it is facing the development and testing needs of developers or users' online DApp usage requirements, a convenient, fast and stable network access is one of the necessary conditions, and it is also the infrastructure of the Polkadot ecosystem.

Elara is inspired by [Infura](https://infura.io/) from the Ethereum ecosystem, named after Jupiter’s seventh moon. Elara's goal is to build a similar infrastructure and network public access services to provide developers with a unified access layer based on Substrate multi-chain. In addition, Elara will be used as part of the smart contract development service, and will be integrated with other components of the Patract toolchain in the future, in terms of contract development environment support, development tools component, contract deployment and DApp release. Elara will be Polkadot’s infrastructure, allowing developers to focus on building upper-level applications.

### Summary of Elara's future plan:

1. ** 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 websocket 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

2. **v0.2: Implement function expansion and performance optimisation**
	* Create account space for developers, support developers to use Github as a third-party login method
	* Support multiple projects under the account space
	* Provide developers with detailed access information of the DApp project by multiple dimensions, including statistical indicators such as daily and weekly requests, calling methods, and source of user group requests
	* Optimise program performance

3. **v0.3: Implement multi-link entry**
	* Extended program structure, support multi-chain architecture
	* Access to Polkadot, Kusama, and other blockchains, such as Jupiter
	* Provide developers with public access services of Polkadot, Kusama, and other parachains, such as Jupiter
	* Provide multi-chain interface documentation

4. **v0.4: Implement Polkadot ecological access & service operation and maintenance**
	* Establish a parallel link in Github to enter the process automation specification
	* Access to more parallel chains in the Polkadot ecosystem
	* Deploy and maintain hundreds of nodes globally
	* Support 10,000 developers, each developer account can establish 20 DApp projects, and each DApp project can use 1M daily access service

### Detailed design of v0.1 (5 weeks, 21 Sept ~ 26 Oct)

**Milestone 1: Design ( (1 designer + 4 developers) * 1 week)**

* Design Dashboard UX, displaying relevant monitoring statistics
* Design the data structure to store information such as the number of requests, calling methods, response bandwidth, response codes, etc.
* Design the program framework and complete the technical selection

**Milestone 2: Development (4 developers * 2 weeks)**

* Deploy a local Substrate node
* Develop a server-side program framework to implement basic functions such as request monitoring, distribution and logging
* Develop proxy access module to implement proxy access for http and websocket requests
* Develop monitoring statistics module to implement the statistics and analysis of requested data
* Develop a front-end dashboard page to display relevant monitoring statistics of the RPC service of the Substrate node

**Milestone 3: Integration (4 developers * 1 weeks)**

* Integrate agent access module, monitoring statistics module to service program framework
* Integrate front-end dashboard and back-end statistical data services
* Develop a client request program to simulate access requests

**Milestone 4: Testing (4 developers * 1  weeks)**

* Deploy and test the back-end service program
* Test client request access functions
* Test server monitoring statistics functions
* Test dashboard page functions

### Cost of v0.1 (1 designer \* week + 20 developers \* weeks)

* Operating activities: $3400 ( Rent and Devices: $200 per employee * week )
* Designer payments: $1000 ($1000 per designer * week)
* Developer payments: $30000 ($1500 per developer * week)
* —————————— +
* Total Cost: $34400
* Exchange Rate: $4 / New DOT
* Treasury Proposal: 8600 New DOT

### How to verify v0.1: Youtube demo video & Github source

* The Substreate node of the service can be accessed through http and websocket protocols
* Can monitor RPC requests of Substrate nodes
* Can view the relevant monitoring statistics from the dashboard

Patract Labs' treasury proposal for Elara v0.1

Europa is a new project designed to help developers create and test apps using Substrate, a framework in the Polkadot ecosystem. Here are some key points about Europa:

- Europa is a special environment for testing, making it easier to develop and debug applications.
- It has no complicated parts like peer-to-peer connections, focusing only on running the code.
- The project plans to create three versions, starting with basic features and adding more support later.
- Version 0.1 lets developers quickly start a private Substrate chain for testing without needing a whole blockchain.
- Future versions will improve error notifications and work with other tools to enhance the development experience.
- The team is working on milestones that include setting up a database, creating a block packing feature, and integrating with other systems.

FYI: This is copy from: https://polkadot.polkassembly.io/post/102, and Europa is the third project that we planned in our roadmap https://polkadot.polkassembly.io/post/100.

Github: [https://github.com/patractlabs/europa](https://github.com/patractlabs/europa)

Europa is inspired by [Ganache](https://www.trufflesuite.com/ganache), [Ethereumjs-VM](https://github.com/ethereumjs/ethereumjs-vm) and [Buidler EVM](https://buidler.dev/buidler-evm/) from the Ethereum ecosystem. Europa is a sandbox of Substrate runtime environment, which would be used to simplify the developing, debugging, and integration test when developers develop Substrate runtime applications and test pallet-contracts. The sandbox will remove P2P and consensus functions, just remaining the execution environment and RPC interface. We will wrap the core modules, then provide a local database, a detailed log print function, a concept of workspaces which isolates different developing environments, and interact with different front-end UIs. The sandbox has no time interval between producing blocks, so debugging can be optimised to be very quickly.


### Summary of Europa's future plan:

**1. v0.1: Have an independent runtime environment to facilitate more subsequent expansion directions.**

 The independent runtime environment of excluded nodes can be expanded more without the constraints of the node environment and WASM compilation, and can be easily integrated with other components. In this version, it is more like simulating the Ganache project in Ethereum ecosystem, enabling contract developers to develop without having to build a contract blockchain. Developers can quickly fire up a personal Substrate chain, which can be used to run tests, execute commands, and inspect state while controlling how the chain operates.

**2. v0.2: Modify at contract module level to provide more information **

In this version, we will fork the pallet-contracts module for secondary development. We will strengthen the part of the error notification for contract developers, such as providing:

* WASM stack traces, the function call stack during WASM contract execution;
* Contracts stack traces, the call stack of a contract calling another contract;
* Console.log, provides libraries and methods to print command lines during contract development;
* Strengthen the error type and error display of the contract module;
* Simple integration with Redspot;

** 3. v0.3: Improve the developement experience, strengthen collaboration with other tools, and extend the sandbox to be compatible with other runtime modules**

* Strengthen the integration with Redspot
* Strengthen the integration with polkadot.js.org/apps to achieve complete RPC support
* Support status data query


### Detailed design of v0.1 (6 weeks, 21 Sept ~ 2 Nov):

**Milestone 1 : (3 developers * 1 weeks)**

* Implement an independent runtime executive environment
* Implement `Externalities` trait for a `Externalities` -like object
* Implement needed `Extension` trait interface.

**Milestone 2 : (3 developers * 1 weeks)**

* Implement a local database for this runtime executive environment to store all trie data, block and extrinsic
* Implement a local database  to store a bypath k/v state data, for exporting and querying from those data.

**Milestone 3 :  (3 developers * 1 weeks)**

* Implement a block packing function to pack blocks directly rather than through consensus process, allowing to pack one or multiple extrinsics at once. 
* Providing a workspace concept to isolate different environment.

**Milestone 4 :  (3 developers * 1 weeks)**

* Implement RPC functions of "forward to height" and "backward to height"
* Providing a way to pack blocks directly to assigned height
* Revert current state to a reverted height

**Milestone 5 : (3 developers * 2 weeks)**

* Integration and testing


### Cost of v0.1 (18 developers * weeks)

* Operating activities: $3600 ( Rent and Devices: $200 per developer * week )
* Employee payments: $36000 ($1900 per developer * week)
* —————————— +
* Total Cost: $37800
* Exchange Rate: $4/ New DOT
* Treasury Proposal: 9450 New DOT


### How to verify v0.1: Youtube demo video & Github source

* Build and run in an independent executable file
* Can start from different workspaces, and a new workspace is an empty chain
* Can receive extrinsics to set_code, deploy and call contracts directly
* Can interact with Redspot
* Can use RPC to jump over some blocks and revert to a specified height to revert states

Patract Labs' treasury proposal for Europa v0.1

Description to be found here: https://polkadot.polkassembly.io/post/111

SubstraTEE Scalability Proposal

Redspot is a tool for developing blockchain contracts. Its main goals are to make developing contracts easier and to hide complex processes.

Future plans for Redspot include:
- Version 0.1 finished core functions using the Truffle framework.
- Version 0.2 will switch to the Buidler framework, adding new features and plugins.
- Version 0.3 will improve integration with other tools and languages.
- Version 0.4 will add helpful libraries.

Some problems with version 0.1:
- There isn’t an easy way to interact with contracts.
- Private keys can't be well protected, making it less secure.
- Developers can only run deployment scripts once with the same settings.

The next version will focus on improving user experience by adding:
- An interactive command line.
- Support for multiple deployments.
- Enhanced safety for private keys.
- Reports on the gas used during contract activities.

Copy from: https://polkadot.polkassembly.io/post/101

Github: [https://github.com/patractlabs/redspot-0.2](https://github.com/patractlabs/redspot-0.2)

Redspot's goal is to standardise the contract development process, hide the underlying compilation details of the contract, and combine the sandbox, library, API, SDK and other plugins to create a one-stop smooth contract development process. We have finished the first [proposal](https://polkadot.polkassembly.io/motion/7) requirements for v0.1,  and written a development [report](https://polkadot.polkassembly.io/post/78).

### Summary of Redspot's future plan:

1. v0.1: Build core available functions based on Truffle framework.
2. v0.2: Migrate to the [Buidler](https://buidler.dev/) framework to enhance plugin extensibility and add some functions to provide a smoother development workflow.
3. v0.3: Imitating Buidler's plugins, combined with the characteristics of Substrate to add various plugins, such as waffle, and began to integrate multi-language SDK.
4. v0.4: Following the case of Buidler, add appropriate libraries, such as typechain, etc.

### Problems of Redspot v0.1:

Although we have completed all the basic functions of Redspot, there are still some inconveniences in use. E.g:

* There is no convenient interactive cli for simple interaction with deployed contracts;
* Only the private key in plain text is supported in the configuration file, derivation through seed is not supported, and the password cannot be hidden;
* Under the default instantiation address logic of pallet-contracts, the contract address generated by a single account with the same parameters and the same WASM code is unique. This is not like Ethereum's single account can repeatedly deploy the same contract with different addresses. Therefore, after the deployment script and test script are written in Redspot, they can only be executed once. Otherwise, during the second execution, the execution will be interrupted during the deployment phase because it cannot be deployed. This requires script developers to pay careful attention to the writing method, otherwise it is easy to make mistakes. Redspot hopes to simplify this process.
* When deploying scripts and test scripts are instantiating or calling contracts, gas_limit needs to be written in after estimated whether the current assets are sufficient to support contract execution. Redspot currently simply fills in a default value, and does not have an estimation method, and does not know the gas consumption after execution;

### Detailed design of v0.2 (6 weeks, 21 Sept ~ 2 Nov):

The Buidler framework provides a "plugin" model, which can give Redspot great scalability and flexibility. This framework can also support Redspot to connect with contract modules on different parachains. For example, you can replace the environment of the target chain through plugins, add SDKs in other languages, and add extensible functions. In v0.2, Redspot will migrate all the functions of v0.1 to the new Buidler framework, and write various plugins to solve the problems of v0.1.

**Milestone 1: (3 developers * 1 weeks )**

Fork Buidler framework and modify it to suit the Substrate blockchain, then migrate all the current features in  Redspot v0.1 as inner plugins to this new framework.

**Milestone 2: (3 developers * 1 weeks)**

Support an interactive cli to operate deployed contracts, this cli will include injected polkadot.js interface and other helper functions, global env, key pairs, and connected node.

**Milestone 3: (3 developers * 1 weeks)**

Plugin 1: key pair support.
* Developers can use a private key directly;
* Developers can use a seed, and can derive account from this seed;
* Developers can use indicate a path for the keystore file, so that the private key will not appear in the config file.

**Milestone 4: (3 developers * 1 weeks)**

Plugin 2: multiple executing test support. This plugin provides a way to allow developer to deploy contracts more than once using same account and parameters in tests.
* Developers can use “beforeTest” to derive accounts and transfer some balance to this new account.
* Developers can use this new account to deploy contracts.
* Every executing test command will derive new accounts automatically.

**Milestone 5: (3 developers * 0.5 week)**

Plugin 3: [Jupiter](https://github.com/patractlabs/jupiter) test-net support as deploying environment;
* Jupiter test-net will use a flag storage to allow developers to use same account, same parameters and same code to deploy more than once.
* This plugin will develop a matching interface to interactive with Jupiter to set flag.
* This plugin’s env will allow developers to do deploying and testing in a normal way.

**Milestone 6: (3 developers * 1.5 weeks)**

Plugin 4: gas usage report.
* This plugin can print gas usage per test phase and deploying actions.
* This plugin can print gas usage per interactive cli.

### Cost of v0.2 (18 developers * weeks)
* Operating activities: $3600 ( Rent and Devices: $200 per developer * week )
* Employee payments: $27000 ($1500 per developer * week)
* —————————— +
* Total Cost: $30600
* Exchange Rate: $4/ New DOT
* Treasury Proposal: 7650 New DOT

### How to verify v0.2: Youtube demo video & Github source

* Replay all v0.1 tests in v0.2
* Show how Redspot v0.2 interactive cli works

**Workflows:**

* Use "deploy" command and execute deploying scripts
* Use interactive cli
* Call deployed contract
* Send extrinsics to call a contract
* Deploy a new contract in cli

**Plugins:**

* key pair plugin:
    * allowing developers to use seed, private key or a keystore path in config
* multiple executing test plugin:
    * could repeat any test command without any changes in test scripts.
* Jupiter test-net plugin:
    * could connect with Jupiter test-net by using a config flag in config files
    * could repeat any test command without any changes in test scripts.
* Gas usage report plugin:
    * could print gas usage for every test phase
    * could print gas usage after calling a contract in interactive cli

Patract Labs' treasury proposal for Redspot v0.2

This is a treasury proposal whose proposer address (15psTaipmWG86U5vNkF7Guv9TRPMRLKHkGS8cXT74v3RCC5t) is shown in on-chain info below. Only this user can edit this description and the title. If you own this account, login and tell us more about your proposal.

PLEASE REJECT: wrong funds recipient

- A Polkadot meetup was held in Hangzhou, China, on September 12, 2020.
- The event was hosted by 8btc.com, a big crypto information platform in China.
- It aimed to help people learn about Polkadot and blockchain technology.
- The meetup had over 130 attendees and was free to join.
- 8btc also hosts other events like Hangzhou Blockchain Week annually.
- They want to hold more meetups in other cities in China.
- 8btc is recognized for translating the first Chinese Bitcoin whitepaper.

Proposal:#10 (motion 17)

Proponent: 146GTTVAZhU8epotD6ymKpRfhUwVLYrhL8Ho28LVeox4GrWC

Proposal date: 7.9.2020

Requested DOT: 1500

Short description: Polkadot Meetup in China

8btc.com (the proponent)  hosted a Polkadot meetup in Hangzhou, China.

[8btc](https://www.8btc.com/) is one of earliest and biggest crypto media in China. 8btc was founded by Changjia and Jihan Wu in 2011, and translated the very first Chinese version of bitcoin whitepaper. 8btc is an information and education platform for crypto users and people interested in cryptos in China. In 2016, [8btc English News](https://news.8btc.com/) was founded to act as a bridge between Chinese and foreign communities. 

8btc is also a host of [Hangzhou Blockchain Week](https://www.8btc.com/gbsf-2020?lang=en) and [World Blockchain Conference](https://www.8btc.com/wbc-2019/?lang=en), which will be held every year. Besides these two conferences, 8btc will host plenty of meetups with different themes every year. [Chainge](https://www.8btc.com/author/61023) is the name we gave to tech-related meetups, which is also for the Polkadot meetup we are about to host. Chainge has seen most famous blockchain teams in China joined in, including IRISnet, Nervos and PlatOn.

As a validating node of Polkadot, 8btc appreciates what Polkadot brings to the blockchain world and Web3 development. Though Polkadot is already a well-known project in China, most people know little about the related tech and what Polkadot can bring to the blockchain revolution.

So the meetup named ‘[Polkadot and the Trust World it Brings](https://www.chainnode.com/event/469852)’ will get more people to truly learn about what Polkadot is and will be, instead of pure speculation. Hangzhou is only our first station, there will be more in different cities of China.

The meetup was from 1:30pm to 5:00pm, on Sep. 12th (GMT+8). Entrance was free and there were more than 130 people to attend the meetup.

Please checked [here](https://docs.google.com/document/d/1RDutByvYe6n5nvIl2Jbx7PmQQwtS5xzYOe6iKc1v_Js/edit#heading=h.z7n65nftppgq) to see more budget details.

Pls feel free to ask me anything. Thanks!

Wendy, 
Head of 8btc English News


Polkadot Meetup in China - Proposal:#10 (motion 17)

please see https://polkadot.polkassembly.io/post/52 for the full description of our proposal

Treasury Proposal: Encointer Self-Sovereign Identity Parachain for Polkadot

### Summary of Proposal

- **Proposer**: 0x6f102978d4111becdda6029a6b4b72e371e6ab97
- **Date**: 10th May 2023
- **Requested Amount**: 567.82 MOVR
- **Objective**: Revamp stakeglmr.com and stakemovr.com to improve flexibility, expandability, and future-proof the design.
- **Key Features**:
  - Faster load times and improved user experience.
  - Advanced staking interface for diversification across multiple collators.
  - Support for multiple wallets.
  - Cost-effective and durable two-layer API setup.
- **Team**: Two senior developers with expertise in backend and frontend development.
- **Milestones**:
  - **M1**: 2 months for SvelteKit frontend, wallet integration, and backend indexing.
  - **M2**: 4 months for additional microservices, full integration, testing, and deployment.
- **Cost**: $44,800 for both milestones, with 50% upfront for each milestone.
- **Technical Stack**: SubSquid, Temporal.io, AWS DynamoDB, Postgres, AWS Lambda, SvelteKit, NodeJS, and Go.

V2 of stakemovr.com and stakeglmr.com

### Summary

- **Proponent:** 0xf1cCF19F71D820dB4cd1263516a958D3E6272021
- **Date:** 11th April 2023
- **Requested:** 1,764.6164 MOVR
- **Purpose:** Ongoing costs for Moonriver network infrastructure from January to March 2023.
- **Service Enhancements:**
  - Improved API service stability and support for multiple chains.
  - Auto Expand Storage and Geolocation Insights for better infrastructure decisions.
  - Partnership with POKT network to attract more developers.
  - Expanded support for new networks and reduced reliance on a single cloud provider.
- **Cost Details:** Total cost for Q1 2023 is USD $15,013.03, equivalent to 1,764.6164 MOVR.

This is a treasury proposal whose proposer address (143pzStAtMv3RbYbcHyr2xHipWPkme8VjVgAr4QDQP8d3Xrc) is shown in on-chain info below. Only this user can edit this description and the title. If you own this account, login and tell us more about your proposal.

OnFinality: High Performance Public Infrastructure (2023, Q1)

### Summary of Web3Go Proposal for Moonbeam and Moonriver Data Analytics

- **Objective**: Continue data analytics for Moonbeam and Moonriver using Web3Go's stream data processing system.
- **Motivation**: Moonbeam and Moonriver lack a data analytics platform, making it hard for users to access and view data. Web3Go fills this gap.
- **Web3Go's Role**: Developed a stream-based data analytics platform for Moonbeam and Moonriver, creating dashboards and tools.
- **Team Experience**: Web3Go has been working in the Polkadot ecosystem for over 2 years, recently expanding from 8 to 15 team members.
- **Rationale**: Web3Go is the preferred choice for data review and usage in the Moonbeam ecosystem but needs more resources for customized services.
- **Cost**: Proposal seeks $30,000 equivalent in GLMR or MOVR for server and manpower costs over three months (April to June 2023).
- **Deliverables**: Plans to deliver dashboards for Moonriver, inflation, and dApp activity for both networks.
- **Implementation**: Involves setting up archive nodes, indexing data, database maintenance, data processing, and visualization.

This is a treasury proposal whose proposer address (14tecGFzyEd5omn7RGifn5yyngZrnoCcLWNG3e7FjVZJzvZk) is shown in on-chain info below. Only this user can edit this description and the title. If you own this account, login and tell us more about your proposal.

Web3Go Data Analytics service for Moonbeam and Moonriver of Q2 2023

### Moonriver Network Infrastructure Proposal Summary

- **Objective**: Fund ongoing costs for high-performance, scalable, and reliable public infrastructure for the Moonriver network from August 1, 2022, to October 31, 2022.
- **Motivation**: Reduce the barriers to accessing the Moonbeam Networks by providing shared node API services, minimizing startup costs and secure node access expenses.
- **Team**: [OnFinality](https://onfinality.io/), a SaaS platform supporting the Polkadot/Substrate community by offering core infrastructure services.
- **Cost**: Total outstanding costs for Moonbeam Networks are 3,024.09 MOVR.
- **Use of Funds**: Funds will be used to cover infrastructure expenses from August to October 2022.
- **Infrastructure**: Includes multi-cloud and multi-region setups, API Insights, cost optimizations, new API plans, support for Alibaba Cloud, and health metric improvements.
- **Performance**: Achieved 99.99% uptime for Moonbeam and Moonriver networks.
- **Proposal Links**: Full proposal [here](https://docs.google.com/document/d/14oIJ-tKtkJM539WtAL8Shv-DIebUIk7T-8bqKzGFNno/edit#) and corresponding Moonbeam proposal [here](https://moonbeam.polkassembly.network/treasury/3).

This is a treasury proposal whose proposer address (13jniRpcWs5Wg4xZTuakzkP11L7djpofhg6HRL5zcrkzqujk) is shown in on-chain info below. Only this user can edit this description and the title. If you own this account, login and tell us more about your proposal.

Treasury Proposals