- 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.

proposalId

**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

- 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

- A bug was fixed in the Polkadot v26 runtime that affected some accounts.
- This bug caused unfair slashing of candidacy bonds in the council.
- Motion 43 is a plan to refund those affected accounts.
- It aims to help candidates and runners-up who were hurt by the bug.
- A system called `utility.batch` will handle all refunds together.
- Councillors are asked to vote on this motion.
- If it passes, the community will also vote on the proposal.

proposalHash

As you might remember from past discussions, with the v26 runtime being in Polkadot, [a bug](https://github.com/paritytech/substrate/pull/7384) that caused immature slashing of candidacy bonds in council was fixed, and now's the time to proceed with refunding affected accounts.

Based on our experience in Kusama Network, **Motion 43** aims to reimburse candidates and runners-up who were slashed due to this bug. In order to verify hash, please review this [gist](https://gist.github.com/kianenigma/93c3a86a72823a3f703c442e00929a0a) (generated using [this snippet](https://github.com/paritytech/substrate-debug-kit/blob/b6b818ae1bc6a834f2010e8a58726231034ed8c1/remote-ext-elections-phragmen/js/src/index.ts#L597-L624)). The motion wraps all of the reimbursement calls inside a `utility.batch`, creating a single batch of force transfers from the treasury to the affected accounts. 
All councillors please vote at your convenience! If the motion passes, the proposal will be after voted by the community.

Original post can be found [here](https://polkadot.polkassembly.io/post/165).

Incorrect Slashing on Council Caused by elections-phragmen Pallet Bug

- **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

- A person who made a proposal to increase validators to 259 wants to cancel it.
- They said it was a mistake.
- The Council is checking to make sure the person is the one who made the proposal.
- They verified this using a special call.
- The person knows what happens when they cancel their proposal.
- A motion has been made to cancel the proposal.
- All council members are asked to vote on this.

propIndex

The submitter of [Proposal 8](https://polkadot.polkassembly.io/proposal/8) has requested the Council to cancel his proposal (aiming to increase the number of validators on the network to 259) claiming the submission was an error on his side. 

The beginning of the discussion can be read [here](https://matrix.to/#/!HzySYSaIhtyWrwiwEV:matrix.org/$1605171498740448HOoIr:matrix.org?via=matrix.parity.io&via=matrix.org&via=corepaper.org).

We have gone through the process of verifying the user is indeed in control of the address: The [Remark call](https://polkascan.io/polkadot/transaction/0xea6bae8ef9f430e2a189968621fad64917afdeedc3c33e3f3097fd1a712f5242) with the same [GitHub username](https://github.com/zhouziyan) can be read on the call, executed this morning upon request. 

The submitter is aware of the consequences of the cancellation. **Motion 41** cancels proposal 8 as requested. 

All councillors, please vote at your convenience. 

Cancellation of Proposal 8

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

- Motion 38 is a vote to upgrade to a new version called v26.
- The priority for this upgrade is medium.
- There are some important changes in this upgrade:
  - It fixes how target names with dashes are logged.
  - It stops using old substreams that aren't needed anymore.
  - It makes certain functions unsafe for remote use.
- People can find more details in the release notes.

**Motion 38** is up for vote: the motion upgrades the runtime to v26.   Upgrade priority: Medium due to changes: Fixes logging of target names with dashes ([#7281](https://github.com/paritytech/substrate/pull/7281)), No longer actively open legacy substreams ([#7076](https://github.com/paritytech/substrate/pull/7076)), Make queryStorage and storagePairs unsafe RPC functions ([#7342](https://github.com/paritytech/substrate/pull/7342)))

Hash and release notes can be found [here](https://github.com/paritytech/polkadot/releases/tag/v0.8.26). 

Runtime upgrade to v26

- 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

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.

Untitled Post

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

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

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

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.

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

- A referendum is a way for a community to vote on something important.
- Referendum 7 did not work because it was set to start at zero instead of one.
- The code needed to check if the start time was in the past.
- If it had been set to one, it would have started as soon as the next block happened.
- The writer wants to propose the same idea again to the Council.
- They hope the Council will send it to the voting queue like before.

Referendum 7 (passed by the Council and the community) failed to come into place given the parameter to be executed after was 0 (zero) instead of 1.

```
let when = match when {
			DispatchTime::At(x) => x,
			DispatchTime::After(x) => now.saturating_add(x)
		};

		if when <= now {
			return Err(Error::<T>::TargetBlockNumberInPast.into())
		}
```

0 fails to check, but 1 would happen next block after the referendum is passed. I am proposing the exact same motion to Council and requesting TC to pass to referenda queue in the same way as before.

Proposal to gradually increase the number of validators

This is a motion whose proposer address (13RDY9nrJpyTDBSUdBw12dGwhk19sGwsrVZ2bxkzYHBSagP2) 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.

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

- Motion 25 wants to add 1 more validator slot every time a new era starts.
- This will happen for 100 eras, which is a lot of blocks.
- The motion will be voted on after the council discusses it.
- The voting process takes about 7 days.
- Councillors need to check a special code called the presage hash.
- Everyone is welcome to share comments or questions. 
- More details can be found in the original proposal link.

**Motion 25** schedules an increase of validators slots by 1 every era (14,400 blocks) with a repetition of 100 eras. 

The motion is to be voted on referenda queue if passed by council for approx. 7 days, after the TC fast-tracks, as explained [here](https://polkadot.polkassembly.io/post/93).   Councillors: **to verify presage hash** you can check [here](https://polkadot.polkassembly.io/post/93#3baa6f49-06c7-4d47-9cb8-44bd19f789d6). Feel free to add any comments or questions. 

Original proposal: https://polkadot.polkassembly.io/post/93

A proposal to gradually increase the number of validators

This is a CouncilMotion post. It can only be edited by the proposer of the post .

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.

Motion 20 upgrading Polkadot Runtime to v24 is up for vote.

Upgrade priority: Medium (timely upgrade recommended) To see changes and for release notes and hash, please check [here](https://github.com/paritytech/polkadot/releases/tag/v0.8.24).

All council members please vote at your earliest convenience.

Council Motions