- The proposal is for rewarding the Polkadotters community, started in August 2020, for all their activities.
- The community is the largest Polkadot group in the Czech/Slovak region and aims to expand internationally.
- The author has left their job to promote Polkadot and Web 3.0 as an ambassador.
- They share updates on social media: Facebook (4.3k members), Twitter (1.5k followers), and Medium (600 followers).
- The group has created over 60 articles in Czech and English and has 20k YouTube views on their videos.
- Other activities include founding the DOT Validator Alliance, educating others, and participating in events and hackathons.
- They are asking for 2,736 DOT (about $41,280) to cover their contributions to the community.
- The author welcomes feedback and is open to adjusting the proposal.

proposalId

The purpose of this proposal is to reward all the activities by the Polkadotters community that was founded in August 2020. We have started the biggest Polkadot community in the Czech/Slovak region that is nowadays a central hub for all Polkadot users from the region. But our plans were always to go international and therefore we created a Polkadotters brand and started to publish everything in English as well.
The reason why we are asking for this reward is that I left my full-time job in order to become a Polkadot ambassador and devote my professional life to the promotion of the Polkadot and Web 3.0 vision. I didn't have any other means of income except being a validator (Polkadotters enjoys the freedom of the press by not being paid for promotions or marketing :-) 

I know we should have asked for this some time ago but I finally got the courage to reach the Polkadot council for our support as of now. 

A detailed version of our proposal with calculations and rationales can be found [here](https://docs.google.com/document/d/1iYqRt1ZB1E1XSZhwk5zH1J8Io_SkjtH8MINl9-ibN8k/edit#heading=h.4uhl8jouxvv5), however, I will try to sum up our activity over here as well

**Social media**

- Facebook (Polkadot CZ/SK) - 4.3k members
- Twitter (Polkadotters) - over 1.5k followers
- Medium (Polkadotters) - over 600 followers

**Content**
- Medium - over 60 original articles in both Czech and English
- YouTube - over 20k views on Polkadot videos in the Czech language

**Other activities**
 - founding the [DOT Validator Alliance](http://dotvalidators.org/manifesto)
 - education about Substrate and development (being a developer myself)
 - hackathon participation
 - promotion of Polkadot on various Czech cryptocurrency events
 - participating in testnets and helping projects to start their networks
 - and many others

I created this post as the basis for the discussion with the council since I am not sure how much I can ask and what's the view of the council on such a proposal. I will appreciate any feedback and I am looking forward to the council's response.  

According to the 30-day DOT price average, we are currently asking for 2,736 DOT or roughly $41,280. This includes all the activities we have been doing for the community as well as the creation of our content and spreading it out to the Polkadot communities all over the world. 

I am really grateful for the council's support and I am definitely open to the adjustment of my proposal. II tried to back my request with some numbers because I know it would be outright rejected s so here they are and I would love to discuss the details with you! Thank you very much :-)



 Funding of Polkadotters community

- A person wants to write a book about Polkadot, which is a network like Ethereum.
- Many books exist about Ethereum, but almost none are about Polkadot.
- The goal is to make a simple book that anyone can understand, even if they are not tech experts.
- They think it's important for more people to learn about Polkadot.
- A draft of the book is almost finished, and they want feedback to improve it.
- The book will be available for free under a specific sharing license.
- The request for funds to support this project was made on June 16, 2021.

**Proponent**: **12WarfbFeUm5L9Fs5zkTaQQH7L5hqaGPEgM9vQ1UFK8kiUSK** 

**Date**: 16th June 2021

**Requested DOT**: 829 DOT (in 3 installments @ $30.156/DOT using Subscan’s 30 day EMA) = ~$25,000 

**Short description**: Although Ethereum is a much less complicated system, google ‘books on Ethereum’, then google ‘books on Polkadot’. You’ll notice that while there are more than 10 books on Ethereum, Polkadot (the network) has nothing. Of course, this is more a sign of age than anything, but I’m proposing a way to start our journey.

This proposal brings to light the lack of a holistic and easy-to-understand explanation of Polkadot in a book form. It outlines the importance of a book and proposes a solution to create one. But not just another book about blockchains but one focused on Polkadot and written from a totally non-technical perspective.

Please visit this [link to read the full proposal](https://docs.google.com/document/d/11NT6BzM8nOcbXR7wD1C2IJlsi0XyeJaS5Hv50Wy4rJ0/edit#)

**A first draft has already been drafted** (90% finished). You can view the [first draft here](https://docs.google.com/document/d/15p4Xy-I6_44zexCsPcZXHHlCj7L3Jcddle_8567B3x8/edit#). Please leave your feedback to help shape the second draft.

**The book will be published under a Creative Commons License (CC BY)**

**Edited on 6th Oct 2021.*

Proposal to expand the Polkadot ecosystem with a book for blockchain beginners

Metis is a special library being developed by Patract Labs to help build smart contracts with Wasm technology. Here are some key points about it:

- Metis aims to create a library like Openzeppelin, which is popular for Solidity contracts, making it easier for developers.
- It will include common contract components that are well-tested and secure, such as tokens and access control.
- Metis will help solve existing problems in current contract development by providing better tools and support.
- The library will adapt features to match different programming languages like Rust, which is used for Wasm contracts.
- Metis has a structured plan with several milestones to gradually add new features and support for developers.
- The first phase focuses on creating essential components and testing them to ensure they work well.
- By using Metis, developers can create smarter contracts more efficiently and with less confusion.

This is copy from [https://polkadot.polkassembly.io/post/469](https://polkadot.polkassembly.io/post/469)

[Metis](https://github.com/patractlabs/metis) will be the Wasm contract standard library developed by Patract Labs. Patract Labs will work with community forces to formulate various Wasm contract standards, develop corresponding implementations of ink! and Ask! versions, and conduct audits by professional institutions.

## 0. Motivation

We believe that in the Wasm contract ecosystem, a development library similar to Openzeppelin-contracts is very necessary. This is Metis. For the sake of simplicity and readability, the patterns and meta-language provided by this library should be as consistent with Openzeppelin-contracts as possible, so as to reduce the burden on developers and effectively absorb the experience accumulated in the Solidity ecosystem.

But you need to realize that the Wasm contract development based on ink! and Ask! is very different from the EVM contract development based on Solidity. Wasm's mature system support allows developers to use a variety of different languages and tools to develop smart contracts. Based on these mature or rapid iteration platforms, developers can enjoy a large number of underlying facilities support and development experience accumulation, but different languages and tools often have different considerations and trade-offs. This means that developers will use completely different codes to express the same mechanism and design, which will bring huge communication costs and mental burdens to the community.

Faced with such problems, we need to summarize and accumulate the implementation model in the development of smart contracts. This idea was introduced in the book "Implementation Patterns" by Kent Beck. The purpose of summarizing the implementation mode is to clearly and accurately express the developer's intentions and ideas through these clear patterns, so that "code that others can understand" can be implemented. In contract development, this idea is very important.

From Openzeppelin-contracts, we can see that it summarizes several implementation models in the development of smart contracts, such as the "contract expansion model" based on the Solidity inheritance grammar. These implementation models are valuable experience accumulated in the Solidity ecology. Of course, different languages have different ways of practicing these modes. Metis will implement these modes and provide corresponding support on different platforms. For example, in Rust, it is obvious that you cannot directly use inheritance to implement contract expansion. For this, Metis will provide code implementation examples and provide a series of help libraries to reduce the developer's mental cost.

Metis will be more than just a Wasm contract standard library. We hope that through the practice of Metis, we can fully inherit and absorb previous contract development experience while exploring the best practices of Wasm contract development.

## 1. Problem

At present, contract-based developers mainly face the following problems:

- Lack of reliable implementation of common contracts (such as ERC20)
- It is difficult to achieve contract combination and expansion similar to the Solidity inheritance mechanism
- Lack of a series of reliable public components to implement contracts
- Lack of experience accumulation and model summary based on ink! development contracts

The above problems severely limit the current ink!-based contract development ecology. Metis will solve these problems while avoiding the existing problems in Solidity.

## 2. Contract Standard Library

Metis will implement a series of common components, similar to the Openzeppelin-contracts development library. These components will be thoroughly tested and code audited. These components will be as consistent as possible with Openzeppelin-contracts, which can reduce the burden on developers and effectively absorb the experience accumulated in the Solidity ecosystem.

Metis will include the following components:

- Openzeppelin-contracts-like components, including basic Access and Security components, as well as Token and Governance components
- Component developed for ink! contracts, wasm-based contracts can support better abstraction mechanisms, and we can implement more complex and practical components
- Summarizing abstract components from mature contract projects, metis will absorb the experience and accumulation of the community, including both the mature Solidity ecology and emerging blockchain contract projects.
- The expansion of ink! contracts, including basic data structures for different scenarios, etc.

In the previous version of Metis, we will first implement Openzeppelin-contracts-like components for developers to use. These components include:

- Token: ERC20, ERC721, ERC777, ERC1155 and the expansion contract of the above Token contract
- Access: Ownable, AccessControl, TimelockController
- Security: PullPayment, ReentrancyGuard, Pausable

## 3. ink! component

Most of Metis development libraries are composed of contract components. In Solidity, the introduction of contract components can be implemented based on inheritance. Generally, the contract components will include the following parts:

- Component Storage: The storage state related to the logic of the component itself, these states do not need to be exposed to the outside
- Component Message: The externally-facing Message of the component
- Component Event: The event that the component's own logic will  emit
- Component internal interface: an interface for other logic in the contract to call

For example, common Ownable contracts:

```Solidity
abstract contract Ownable is Context {
    // Component Storage
    address private _owner;

    // Component Event
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    
    // Component internal interface
    modifier onlyOwner() {
        ...
    }

    // Component Event
    function renounceOwnership() public virtual onlyOwner {
        ...
    }

    ...
}
```

If a contract needs to be Ownable, just inherit the contract:

```Solidity
contract Escrow is Ownable {
...
}
```

Similarly, other components can also have Ownable through inheritance:

```Solidity
contract Pausable is Ownable {
  ...
  function unpause() public onlyOwner whenPaused {
      ...
  }
}
```

The intention of inheritance here is actually composition rather than an `is-a` relationship. Although excessive use of inheritance in Solidity will cause many problems, inheritance for specific intentions is still an important way to achieve it.

In contract development based on ink!, through metis, we can also achieve the same motivation based on generics and traits:

```rust
...

#[metis::contract] // metis contract macro, will use ink_lang::contract auto
mod flipper {
    ...

    #[ink(storage)]
    #[import(ownable)] // flipper import the ownable
    pub struct Flipper {
        ownable: ownable::Data<Flipper>, // data by ownable

        value: bool,
    }

    #[ink(event)]
    #[metis(ownable)] // TODO: event in ink! will refactor
    pub struct OwnershipTransferred {
        ...
    }

    impl Flipper {
        ...

        #[ink(message)]
        pub fn flip(&mut self) {
            // check owner
            ownable::Impl::ensure_caller_is_owner(self);

            self.value = !self.value;
        }

        ...

        #[ink(message)]
        pub fn renounce_ownership(&mut self) {
            ownable::Impl::renounce_ownership(self) // owner message
        }

        ...
    }
}
```

Metis assists developers to achieve the same function through a series of helper macros. In order to improve the auditability of the contract, here we hope that users clearly implement storage, event and message declarations.

At the same time, metis has improved the implementation of components:

```rust
...

// Storage
#[metis::component::storage]
pub struct Data<E>
where
    E: Env,
{
    owner: Lazy<Option<E::AccountId>>,
}

// Event trait
pub trait EventEmit<E: Env>: EnvAccess<E> {
    ...
}

// Impl trait
pub trait Impl<E: Env>: Storage<E> + EventEmit<E> {
    // logics
    fn init(&mut self) {
        self.get_mut().set_ownership(&Some(Self::caller()));
    }

    fn renounce_ownership(&mut self) {
        self.ensure_caller_is_owner();

        self.emit_event_ownership_transferred(
            self.get().get_ownership().clone(),
            None);

        self.get_mut().set_ownership(&None);
    }

    ...

    /// Panic if `owner` is not an owner
    fn ensure_owner(&self, owner: &E::AccountId) {
        assert!(&self.get().get_ownership().clone().unwrap() == owner);
    }

    ...
}

```

Such components can extend their functions by inheriting other components, such as an ERC20 component with the function of destroying tokens:

```rust
...

pub trait Impl<E>: erc20::Impl<E>
where
    E: Env,
{
    fn _burn(&mut self, account: &E::AccountId, amount: E::Balance) -> Result<()> {
        ...
    }

    fn burn(&mut self, amount: E::Balance) -> Result<()> {
        self._burn(&Self::caller(), amount)
    }

    fn burn_from(&mut self, account: &E::AccountId, amount: E::Balance) -> Result<()> {
        ...
    }
}
```

Based on metis, we can implement various contract combination modes implemented by Solidity through inheritance under limited intent, and at the same time, with the help of rust's zero-cost abstraction, these abstractions will not bring additional performance consumption.

## 4. Overall Roadmap

Metis for ink! is divided into several milestones:

- **[M1]** Implement basic component macros and components, improve component testing support, developers can build regular DAPPs based on Metis
- **[M2]** Complete component macros, complete component development support, developers can build custom components. Complete the api support corresponding to the metis component.
- **[M3]** Rich component library, complete component and API support for governance and financial mechanism, perfect mathematical library suitable for contract development to support DeFi-type contracts that require complex calculations.

Considering that the current ink! and contract-pallet are still in iteration, some metis features will be implemented based on subsequent improvements, including:

* Contract proxy and upgradeable support will depend on the improvement of subsequent contract calls, by [739](https://github.com/paritytech/ink/issues/739).
* The Event in the component, the Event in the current ink! cannot be independent of the contract, by [759](https://github.com/paritytech/ink/issues/759), the event in the current component is only an early implementation, and it will be refactored based on the improvement of ink! in the future.

With the richness and completeness of the ink! contract community, metis will further implement more public components and libraries to assist developers in developing large-scale contract projects. Therefore, we may arrange [MR] milestones. It will be developed based on the iterative schedule of ink!

* **[MR]** According to the ink!'s iterative progress, community feedback, contract upgrades, contract proxy and cross-contract call support, refactor Event-related implementations, improve basic components and add development assistance macros to reduce duplication while ensuring auditability Code.

## 5. Detailed timeline of M1 (3 developers * 5 weeks)

- Week 1: 
  - M1.1 Design and develop macros that support the development of metis components, and determine the component development paradigm
  - M1.2 Design and develop macros that support the introduction of metis components into contracts, and determine the development paradigm for contract expansion and introduction of components
- Week 2:
  - M1.3 Design and develop unit test support for components
  - M1.4 design and develop integration test support based on Redspot
- Week 3:
  - M1.5 Complete the implementation and testing of Access related components
  - M1.6 Complete the implementation and testing of Security related components
- Week 4:
  - M1.7 Complete the implementation and testing of Token related components
  - M1.8 Complete the detailed Metis component design document
- Week 5:
  - M1.9 Complete documentation and examples of metis components

Cost of M1 (15 developers \* weeks):
* Operating activities: $3000 ( Rent and Devices: $200 per employee \* week )
* Developer payments: $28500 ( $1900 per developer \* week )
* Total Cost: $31500
* Treasury Proposal: 1525 DOT ($20.65/DOT @ 28Jun)

## 6. How to verify M1

Complete the macros and tests related to the metis component, and all the tests can pass. Complete the detailed metis component design document. Complete the implementation and testing of the following contract components, all tests can pass:

- ERC20 and its expansion components (including increasingly issuance, destruction, etc.)
- ERC721 and its expansion components
- ERC777 and its expansion components
- ERC1155 and its expansion components
- Ownable
- AccessControl
- TimelockController
- PullPayment
- ReentrancyGuard
- Pausable

Complete the documentation and examples of the above contract components. 

Patract's treasury proposal about Metis M1 (ink! and Ask! Standard Library)

- MIDLDEV OÜ is a company in Estonia that provides blockchain database snapshots for Polkadot.
- They make new snapshots at least once a day to help node operators and validators.
- A website, polkashots.io, hosts these snapshots along with download links and information.
- The service has been running for 6 months and is the only one of its kind, helping validators recover quickly from issues.
- They plan to request funding from the Polkadot treasury every 6 months to cover their operating costs.
- The total monthly cost for their service is around 1,450 EUR, which includes labor and cloud expenses.
- The proposal will switch to a different snapshot method if new technology is available that works better.
- Payment will be adjusted based on the price of Polkadot on the day of submission.

This treasury proposal is Between the Polkadot Council and MIDLDEV OÜ, a company registered in Estonia with registry number 14973249, commonly known as [MIDL.dev](https://midl.dev/).

# Service description

1.  A functioning infrastructure to provide usable blockchain database snapshots for the Polkadot network, to the benefit of node operators and validators,
    
2.  New snapshots at least once per day. Snapshots are filesystem dump of the Polkadot node storage backend file, of variety RocksDb, of type pruned, with a depth of 1000 blocks, compressed in 7z format, that can be used by validators to quickly spin up or restore their infrastructure,
    
3.  A website frontend at [polkashots.io](https://polkashots.io/) with relevant metadata and download links, including a permanent link that always redirects to the most recent snapshot,
    
4.  Best effort incident and problem management,
    
5.  Redundant implementation setup which allows for continuity, seamless upgrades and basic disaster recovery & contingency management.
    
6.  Make snapshots available on IPFS and pin them for 3 days
    

### Context

The website [polkashots.io](https://polkashots.io/) has been operational for 6 months now and providing Polkadot and Kusama pruned snapshots for validators. It has had excellent uptime. It is currently the only provider for this service. It is very frequently mentioned in the Validator Lounge Matrix channels and there are [youtube videos](https://www.youtube.com/watch?v=UE6GJGvIur8) referencing them. It is beneficial to the ecosystem by providing a path for validators to quickly and safely recover from a storage failure or migrate their operations.

## Evolution over time

Shall substrate/polkadot add support for a useful native snapshot format, the platform will switch to providing these formats instead of a filesystem dump.

Shall substrate/polkadot implement a “warp sync” technology or any other technology, if this technology results in centrally managed snapshot services no longer be the most expedient way of starting or recovering a validator node, this agreement will expire and the service will cease.

## Operational expenses

The labor cost is 1000 EUR/month including 2 engineers in 2 different time zones. The cloud cost varies and is currently estimated at 300 EUR/month.

## Funding request from Polkadot treasury

MIDLDEV OÜ will make funding requests to the Polkadot treasury every 6 months:

-   The first request will cover the period January-June 2021. The future requests will cover post-paid funding of operational expenses, for the previous 6 months.
    
-   Operational expenses consist of labor costs of 1000 EUR/month plus the cloud costs with a 50% markup. Cloud costs include costs of operating the node, storing the files and operating the website frontend.
    
-   We will be operating the polkashots service in a dedicated Google Cloud project (or equivalent in a different cloud provider) for accurate metering and pricing.
    
-   This proposal is for Polkadot, we submitted [an equivalent proposal for the Kusama network](https://kusama.polkassembly.io/treasury/93)
    
## Budget
```
| Cost item                             | Monthly cost             |
|---------------------------------------|--------------------------|
| Labor                                 | 1000 EUR /mo             |
| 150% Cloud costs (estimate)           | 450 EUR /mo              |
| Total (monthly)                       | 1,450.00 EUR /mo         |
| Total (bi-annually)                   | 8,700 EUR bi-anually     |
| Exchange rate DOT/EUR                 | 17.34 EUR (20.666 USD)   |
| Total base price in DOT (bi-annually) | 501.730                  |
| Slippage + conversion fee 5%          | 25.087                   |
| Proposal (DOT)                        | 526.817                  |
```

## Payment conditions

-   to calculate the price, we use Subscan's 30 avg tool at the day of submission:
    

       -   Polkadot: [https://polkadot.subscan.io/tools/charts?type=price](https://polkadot.subscan.io/tools/charts?type=price)
    
     -   Kusama: [https://kusama.subscan.io/tools/charts?type=price](https://kusama.subscan.io/tools/charts?type=price)
    
 
-  Trading-slippage will be taken into account by adding a 5% surplus to the DOT base-price
    
-   Proposal should be approved to cover the upcoming 6 months, not the 6 months of work done before.
    
-   Work will start upon approval.

Polkashots.io maintenance + improvements

- The proposal asks for money from the Polkadot Treasury to help a Chinese non-profit group.
- The group's goal is to create better Chinese content about Polkadot.
- They want to explain complex ideas in a simple way for Chinese users.
- They plan to keep everyone updated on important Polkadot projects.
- The goal is to help more people learn about Polkadot and get involved.
- They are asking for about 1,883.18 DOT for three months to cover costs.
- The funds will help Polkadot grow and succeed in China.

Hi, all councillors:

The proposal aims to seek support from the Polkadot Treasury for the June/July/August operating cost for the Chinese non-profit organization Polkadot Ecology Research Institute, in order to create more original and quality Chinese content, and to relay the otherwise boring technical language to Chinese users in a colloquial way, so that Chinese users can have a real knowledge of Polkadot and increase the breadth of Polkadot in the Chinese market. On the other hand, we will also follow up on the outstanding projects of the Polkadot ecology to keep everyone informed of the latest developments of the Polkadot ecology.

Polkadot's success cannot be separated from the prosperity of the Polkadot Ecological Projects. Our goal is to make more people aware of Polkadot and also to make more people aware of the development of Polkadot ecology, which in turn will lead them to join in the participation and construction of Polkadot ecology, so that Polkadot and Polkadot ecology can flourish.

So this is a proposal for our three months operation cost. We apply approx 1,883.18 DOT total allocation for June, July, August depending on EMA(30) AVG rate (DOT = 22.90 USDT) [here](https://polkadot.subscan.io/tools/charts?type=price) and you can get all details [here](https://docs.google.com/document/d/1njBTICPm8HNAzsmJExZdCCW2GqowrJac0UuMyrphOfw/edit?usp=sharing)

If you have any questions, please give me feedback.

Thanks!

Treasury proposal: The June/July/August operating cost for the nonprofit organization Polkadot Ecology Research Institute

- A proposal is being made to change nominator limits so more people can join.
- Right now, current nominators can't change how much they want to stake.
- The update will let existing nominators not be affected by any new limits.
- The nominator capacity will increase by 2,500, reaching a total of 22,500.
- The amount needed to stake will also change to 40 DOTs.
- These changes will help keep things stable until the next upgrade.
- If too many people join quickly, the stake limit may need to go up again.

proposalHash

The proposal will upgrade the nomination limits such that more people can start nominating. Note that this is a time-sensitive action, because currently existing nominators cannot change their intentions. [This pull request](https://github.com/paritytech/substrate/pull/9193) will change this logic, so that those who are already a nominator will not be affected by any limit, and **will be placed in the next Polkadot  runtime upgrade**.

The new limits increase the nominator capacity by `2500` (making it `22500` in total), and increase the the stake threshold to `40DOTs`. It is intended that these numbers would keep the current count of nominators (all of whom must have 40 or more DOTs) below the new count limit (`22500`) **until the next runtime upgrade**: If an influx of nominators is observed over a very short period of time, the stake limit might need to be increased again proportionally to keep the staking system stable.  

Preimage [HERE](https://drive.google.com/file/d/1Pp8mkUkFCkYiauUAe2RXFBhzk5wgulGV/view?usp=sharing).

Please vote at your convenience!

Upgrade the nomination limits on Polkadot

- The proposal limits the number of validators to 1200.
- Nominators' parameters remain unchanged (20000/20DOTs).
- It started as an external motion, needing Council approval and community referendum.
- Discussions on a minimum DOT stake limit for validators are ongoing.
- These limits aim to ensure network safety and will increase as the network grows.
- The proposal's preimage is available [here](https://drive.google.com/file/d/1W8J1zSPobzNMSAoAWaSeTWvLRI7QdmwH/view?usp=sharing).
- More context and explanations are in the [last runtime upgrade post](https://polkadot.polkassembly.io/motion/88).
- Please vote when you can!

The proposal **sets a limit on the maximum number of validators**, namely `1200`, and leaves the rest of the parameters unchanged (`20000`/`20DOTs`) for nominators. This proposal started as an **external motion**, meaning that if the Council passes this, the community needs to vote in referenda queue to be executed. 

The validator community should be aware that the discussion around minimum DOT stake limit for validators (similar to what was imposed recently on nominators) has already begun [on the Polkadot Direction channel](https://matrix.to/#/!OwgojQyBzTlUQGGLhq:matrix.parity.io?via=matrix.parity.io&via=matrix.org&via=corepaper.org), and will be proposed **as soon as discussion reaches consensus**. Similar to the nominator limits, **these limits are for the safety of the network and will grow as the network grows.**

The preimage of this proposal can be found [HERE](https://drive.google.com/file/d/1W8J1zSPobzNMSAoAWaSeTWvLRI7QdmwH/view?usp=sharing). 

Context on why this is needed and an explanation of the scaling issues we are seeing on Polkadot Network can be found on the [last runtime upgrade post](https://polkadot.polkassembly.io/motion/88).

Please vote at your convenience!

Limit on the maximum number of validators, based on scaling issues

- Polkadot is proposing an upgrade to its system called v9050.
- This upgrade is important for fixing problems with how staking works on the Polkadot Network.
- It will set a limit on how many nominators can be on the chain, which can be changed by the community.
- There are discussions and details available about this upgrade and its effects.
- Important information about staking elections and solutions is also shared by Wei.
- A blog post explains the changes in staking limitations due to this upgrade.
- Everyone is encouraged to vote on this upgrade soon!

The proposal, upgrading Polkadot Runtime to v9050, is up for vote. Release notes, runtime changes and hash can be found [HERE](https://github.com/paritytech/polkadot/releases/tag/v0.9.5). This release resolves the scaling issues we are seeing on Polkadot Network with staking, introducing hard limits on the number of nominators on chain: which is configurable with governance.

- Previous discussions about the runtime upgrade on the Polkadot Direction channel can be found [HERE](https://matrix.to/#/!OwgojQyBzTlUQGGLhq:matrix.parity.io/$EVsIkHKQaZHNrnOCSrLWwE918yPa3u6srpziFs4usvo?via=matrix.parity.io&via=matrix.org&via=corepaper.org).
- Wei’s post on Polkadot’s staking election situations, problems and discussions about potential solutions can be found [HERE](https://corepaper.org/polkadot/staking/). 
- The blogpost by Polkadot explaining the staking limitations and changes with this runtime upgrade proposal can be found [HERE](https://polkadot.network/polkadot-and-kusama-staking-changes/).

Please vote at your earliest convenience!

Runtime v9050 on Polkadot Network

- Subscan is a website that helps people explore and check information on blockchain networks like Polkadot and Kusama.
- They have seen more users using their service since last August.
- However, the increased number of users makes it hard to keep everything running smoothly and costs a lot of money.
- Subscan wants to become financially independent but needs help right now.
- They are asking for financial support from the Polkadot Treasury to improve their services.
- They spent around $18,000 on costs related to Polkadot in a recent time period.
- They are requesting 780 DOT (a type of currency) to help cover these costs.

Subscan is an aggregated Blockchain explorer for Substrate-based chains. We have supported several chains, such as Polkadot, Kusama, and Westend, for more than one year. We have seen an encouraging trend in the number of users and their activeness since last August. However, with the rapid growth of users, stability and reliability in infrastructure are becoming a challenge. We have to pay large bills to ensure the quality of our service.

Subscan is supposed to be a financially independent service in the long run. However, although it is starting to generate some revenue, it still falls short for the time being. Therefore, we wish to get some financial support of the Polkadot Treasury to continue our commitment to the improvement of our service.

Following are some statistics of the current service scale of Subscan.

## Current Service Scale of Subscan

![](https://media.githubusercontent.com/media/itering/subscan-treasury-proposals/master/infrastructure-costs-2021-march-to-may/subscan-cloudflare.png)

![](https://media.githubusercontent.com/media/itering/subscan-treasury-proposals/master/infrastructure-costs-2021-march-to-may/subscan-qps-per-network.png)

We can see from the charts that Polkadot accounts for the absolute majority of all requests by Subscan.

## Billing Info

The infrastructure cost refers to what we spent on Subscan for Polkadot Network (<https://polkadot.subscan.io/>) on the Google Cloud Platform. Following are the rounded figures for the past three months (March to May 2021).

March 2021:  $6593.67

April 2021: $6524.53

May 2021: $7668.53

**Subtotal: $20786.73**


![](https://media.githubusercontent.com/media/itering/subscan-treasury-proposals/master/infrastructure-costs-2021-march-to-may/cost-table-march.png)

![](https://media.githubusercontent.com/media/itering/subscan-treasury-proposals/master/infrastructure-costs-2021-march-to-may/cost-table-april.png)

![](https://github.com/itering/subscan-treasury-proposals/raw/master/infrastructure-costs-2021-march-to-may/cost-table-may.png)

*Compute Engine*, *Stackdriver Logging*, and *Cloud SQL* are the three primary services, among which *Compute Engine* alone constitutes around 80% of the total cost. Detailed billing info and other relevant proof are available in private upon request.

**The estimated infrastructure cost we spent on Polkadot adds up to $18,000. Therefore, the amount we are requesting is 780 DOT (1 DOT ≈ 23 $USD). Such support is indispensable for our goal to capitalize on economies of scale.**

## References

- Subscan for Polkadot Network: <https://polkadot.subscan.io/>
- Subscan Service Status: <https://subscan.statuspage.io/>



> The source code of this proposal is hosted on [GitHub](https://github.com/itering/subscan-treasury-proposals/blob/master/infrastructure-costs-2021-march-to-may/polkadot.md).

The Infrastructure Costs of Subscan for Polkadot Network from March 2021 to May 2021

- Polkassembly is important for the Polkadot and Kusama networks.
- A proposal is being made for money to cover costs every three months.
- The money will help pay for maintenance, upgrades, and other expenses.
- The proposal will share costs for July, August, and September 2021.
- Funds are requested from the Polkadot treasury.
- The proposal will alternate between Kusama and Polkadot every three months.
- Links are provided to view the full proposal and discussions.

[Polkassembly](https://polkadot.polkassembly.io/) is an integral part of polkadot and kusama governance. This submission proposes a recurring payment (quarterly) to cover maintenance, operations and human resource costs for Polkassembly, including general maintenance, runtime upgrades changes and could/infrastructure cost. Since Polkassembly supports both Kusama and Polkadot Networks, this maintenance proposal will alternate networks for submission every three months. This submission covers costs for July, August, September of 2021. We are requesting the Polkadot treasury to provide funds this time.

The full proposal is available [here](https://docs.google.com/document/d/1iyV_F6L9FjGx6gAf8EdTDFsENGqWhpfqYYFYTRZNXHo/edit?usp=sharing). Disussion can be found [here](https://polkadot.polkassembly.io/post/484)

Social Contract between Polkassembly and Polkadot Treasury

- **Proponent:** Figment  
- **Date:** June 8, 2021  
- **Requested DOTs:** 1,300 DOTs  
- **Purpose:** To grow the Polkadot developer ecosystem.  
- **Platforms:** Figment Learn (education) and DataHub (infrastructure).  
- **Goal:** Help developers learn Web 3 and build apps for free.  
- **Incentives:** All DOTs go to developers; Figment keeps 0 DOTs.

**Proponent:** 142hWpBmGsePS1tSopxg4JWaRirGgVpZubz5h251m31KJXdf

**Date:** 06/08/21

**Requested DOT:** 1,300 DOTs for Milestones 5 - 100% of the DOTs will be distributed to developers as incentives. Figment retains 0 DOTs for operational costs as part of this proposal.

**Short description:** Figment is creating a proposal to request DOTs to be used as incentives to grow the Polkadot developer ecosystem via its platforms Figment Learn and DataHub. Learn is the education and onboarding platform for developers interested in Web 3 development. With Learn, developers gain access to the most comprehensive developer portal which standardizes documentation across networks and offers in-depth practical tutorials to help them get to the next level.

Tutorials can be completed seamlessly with DataHub which provides easy access to the protocols via our highly available full node infrastructure and suite of middleware. Developers then get to build and scale their DApps for free using the DataHub infrastructure.

**Original proposal doc:**

**[Visit this link for the full proposal](https://docs.google.com/document/d/1GkgnwLhjVCCrKY43uRgzg6vFI6yN_aoD_TCxBdkNAg8/edit#l)**

Figment Treasury Proposal: Figment Learn & DataHub Milestone 5

bountyId

This is a motion whose proposer address (1363HWTPzDrzAQ6ChFiMU6mP4b6jmQid2ae55JQcKtZnpLGv) 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

- Some validator nodes on Polkadot had a problem where they couldn't find enough memory.
- This happened during an important event called the staking election.
- The issue is related to an off-chain worker that uses a special memory setting called WASM.
- Right now, the off-chain worker and the main program share the same memory limits.
- The team thinks increasing the memory pages for the off-chain workers will help solve the problem.
- They plan to do this temporarily while working on a permanent solution.
- The current default memory setting is 1024 pages, and it's checked on-chain.
- A member of the team is focusing on a long-term fix to separate the memory settings.

**UPDATE: Please be so kind to reject this proposal, the team has included the heap pages increase on an upgrade and this seems to be the best way to approach the issue.**

---

We’ve noticed that some validator nodes on polkadot, encounter a “allocator failed to allocate memory” error around the time when the staking election (phragmen) is being computed. Recall that this computation is happening in an **offchain worker thread**. Nonetheless, in the current implementation, the offchain worker thread, which itself is executed in WASM, uses the same WASM environment as the canonical runtime, and therefore has limited memory. To prevent the situation where no validator submits an election solution, the amount of memory accessible to the offchain worker environment should be increased.

Note that ideally, this change should only affect the offchain worker thread, and not the main runtime. But as mentioned, currently they share the same configurations. A long term solution is to separate these configurations and only increase the amount of memory that is accessible to the offchain worker ([PR](https://github.com/paritytech/substrate/pull/8885)). But, since this is not readily possible, we opt to propose increasing the overall WASM runtime memory pages, which affects both block execution and offchain worker. We expect this decision to have **no notable effect** on the main runtime’s progress and execution.

The amount of memory available to WASM is determined in the number of “pages of memory” that can be allocated in the called, aka. “**Heap pages**”. This value lives on-chain, and you can inspect it similar to other [well-known-keys via “:heappages](https://github.com/paritytech/substrate/blob/28107d402cb88cf50119c4ecb16555fcacf3a3e6/primitives/storage/src/lib.rs#L166)”. Currently, no value is set there and a [default of 1024](https://github.com/paritytech/substrate/blob/ef0e22e11535abaa393122209f83ed02a068a464/client/executor/src/native_executor.rs#L48) is used.

More info can be found [HERE](https://docs.google.com/document/d/12CFQlgBxWwBOcpyoJiNhifvAoPQKBDej9f3YRf9Moq8/edit?usp=sharing). This proposal is a temporary solution, Kian from Parity is working on a permanent fix [here](https://github.com/paritytech/substrate/pull/8885).

Preimage for the motion [HERE](https://drive.google.com/file/d/1p1gQKqzYKo2CL-GrsZI2qNonH_kwGZXG/view?usp=sharing).

Increasing the WASM heap pages.

- Polkadot Ecology Research Institute is a nonprofit group in China. 
- They have written 16 articles about Polkadot that many people have read.
- They want help from the national treasury for their work.
- With the support, they plan to create more good content about Polkadot.
- They also want to reach more people through different media.
- More information about their proposal is available in a document.
- They welcome any questions or feedback from councillors.

Hi, all councillors:

Polkadot Ecology Research Institute is a nonprofit organization in China [which has produced 16 professional articles of Polkadot with over three million pageviews](https://docs.google.com/spreadsheets/d/1eNXFc0QS-EHTZemMGnLb0pvju665T5h-KJrbs-XSQFY/edit?usp=sharing).

We hope to obtain the support of the national treasury so that we can continue to output high-quality content about Polkadot, expand more media channels, and let more people understand all aspects of Polkadot.

You can get more details about proposal [here](https://docs.google.com/document/d/1muYtZp_qnQFWuzkiUEHCAc8zKCYHyZEcAly65bqCPfs/edit?usp=sharing).

If you have any questions, please give me feedback.

Thanks!

Treasury proposal: The April operating cost for the nonprofit organization Polkadot Ecology Research Institute

- Patract Labs created the Patract Open Platform to help with Wasm contract technology in Polkadot.
- Many projects, like Europa, are using this platform for development.
- Europa is a testing environment for running special contracts called Pallet-Contracts.
- Europa enables developers to debug their code and offers useful tools for contract development.
- The future plan for Europa includes making it easier to use and adding a new user interface.
- Europa will show more information about how contracts run and their connections with other accounts and actions.
- It will also package everything together to help developers set it up without trouble.
- The team plans to finish updates for Europa by June 17.

This is copy from [https://polkadot.polkassembly.io/post/410](https://polkadot.polkassembly.io/post/410)

[Patract Labs](https://patract.io) started Patract Open Platform to promote Wasm contract technology in the Polkadot community. At present, dozens of parachain and DApp projects have joined, and [Europa](github.com/patractlabs/europa) has also been widely used in the community. 4 months ago we applied   [treasury proposal #27](https://polkadot.polkassembly.io/treasury/27) for Europa v0.2, and 3 months ago we wrote a [development report #250](https://polkadot.polkassembly.io/post/250). In the past 3 months, we have also followed up with the updates of `Pallet-Contracts` and `ink!`.

Europa is a sandbox environment for running `Pallet-Contracts`. Contract developers can use the executable files compiled by Europa to debug `ink!` contracts. Europa is also a framework that provides a sandbox environment for Substrate Runtime. Parachain developers can implement a sandbox environment for their specific Runtime.

Europa provides minimal service components that support Runtime to package and execute extrinsics normally. Therefore, although Europa can be regarded as a node, this node does not have a consensus system, no network connection, and only retains the Runtime executor, RPC and some other necessary services. In addition, as a sandbox for Wasm contract operation, we modified `Pallet-Contracts` to provide more detailed debugging information, including contract execution information (information in `Pallet-Contracts`) and Wasm execution information. 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 plan

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

* v0.2(finished): Modify at contract module level to provide more information。

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

The original v0.3 plan about expanding Europa's compatibility with other Runtime modules has been completed in v0.1, so the focus of now work in v0.3 is to improve Europa's usablity, which is mainly divided into the following two parts:

1. We plan to design the UI interface for Europa and implement the following product functions:

   Currently, the only UI interface that can directly operate Europa is the Polkadot apps, but apps are for chain operations rather than contract operations. We expect to show more information and elements for the wasm contracts, and improve the contract interaction experience.

   1. Strengthen the functions related to the contract execution system in the contract UI section:
      1. Visualization of contract execution process information: The current important information about contract execution in Europa is directly printed to the log. Developers need to spend a lot of effort to filter out the required information in the log. Therefore, Europa will display it visually and provide some indexing functions;
      2. The relationship between the contract and related extrinsics and events: for example, when you click on the contract address, you can list the contract extrinsics related to this contract; when you click on an account address, you can list all the related extrinsics of this account, etc., this feature can assist developers in the relationship between related extrinsics, accounts and contracts;
      3. Scan all the contracts in the current Europa storage and build the relationship;
      4. Link with a Redspot project in Europa, scan the account and executed extrinsics in the Redspot configuration file, and build the relationship between contracts, accounts, and extrinsics.
   2. Provide the interface and UI to operate Europa's special RPC functions and display state changes. Europa has some special functions for the sandbox environment. Currently, it can only be executed or displayed through RPC calls, such as backward of block height, forward of block height, state execution changes, etc. Operating these functions through the UI interface lowers the threshold for users.
   3. Combined with Europa's workspace function, you can create and select different workspaces through the UI interface.

1. Similar to Ganache, Europa and UI will be made into binary packages for different platforms for distribution

   Although Europa is open source, there will be a lot of trouble if you directly use the source code to compile on a different platform (such as Windows). Moreover, the compilation process is time-consuming and requires resources. Therefore, we will package Europa together with the UI into a binary executable file for distribution. Contract developers can download and execute the packaged Europa binary file directly, so that contract developers can run the node directly without worrying about how to set up the environment for running the contract. .

## Detailed design of v0.3

### 1. The UI Interface

#### 1.1. Visualization of contract execution process

In v0.2, the execution information of the contract in Europa will only be displayed in the log, and the structure is as follows:

```text
1: NestedRuntime {
    ext_result: [success] ExecReturnValue { flags: 0, data:  },
    caller: d43593c715fdd31c61141abd04a99fd68...(5GrwvaEF...),
    self_account: 0144d6fc570d7bddda6f8e3614...(5C6NMXaS...),
    selector: 0x9bae9d5e,
    args: 0x40420f00000000000000000000000000,
    value: 10000000000000000,
    gas_limit: 200000000000,
    gas_left: 190018947968,
    env_trace: [
        seal_input(Some(0x9bae9d5e40420f00000000000000000000000000)),
       ...
    ],
    sandbox_result_ok: Value(I32(0,),),
    nest: [],
}
```

Europa UI needs to interpret and reorganize the information implemented by Europa in v0.2. Therefore, the implementation details of this development are as follows:

1. Europa: In this version, the information needs to be associated with the extrinsic and stored in the Europa database developed by v0.1, and provide RPC for the outside to call.
2. Europa UI: Return contract execution information by calling RPC with tx hash, analyze and draw it into Europa UI in a visual form . **you can see all the [15 prototype diagrams](https://modao.cc/app/c8a2d9ec53de7ccaf412fe7caf6275ec151ab9ed)**

The visualization of the contract execution process information is the most complicated part of the v0.3 product. **The focus of this part is to convert the intuitionally difficult or even unreadable information originally provided by Europa into visualized information combined with the matadata information of the contract, providing developers with an intuitive display of the contract execution process**.

One of the detailed prototype diagram is

![](https://user-images.githubusercontent.com/44688313/115189910-d41f2f80-a119-11eb-8303-e2e0cc0fe267.png)

Contract execution is associated with a extrinsic, which is divided into details and states. Details clearly shows the contract execution details originally in the log, and states shows the state changes involved in this extrinsic.

The top data is the overall data of the entire extrinsic, including the hash, result, block, timestamp, gas limit, gas used, extrinsic fee of the entire extrinsic, each box below represents a call, and boxes with different colors and indents represent calls For different levels, the same depth of call uses arrows of the same color. More complex details are displayed through the drop-down box of more details.

Therefore, the important meaning of this prototype diagram is to show that the "calling relationship of the contract (including the cross-contract call process)" can visually show this process, and developers can only obtain relevant information by analyzing the relationship in the log of Europa in v0.2.

The meaning of the text in the diagram is as follows:

* Result: ext_result in the output of nestedRuntime. A green check is displayed for success, and a red cross is displayed for failure.
* Block: the block that the extrinsic is in 
* TimeStamp: The timestamp of the block
* From: extrinsic caller
* To: extrinsic recipient
* value: the token sent by the extrinsic
* extrinsic fee: extrinsic fee, based on the token of the chain
* Gas Limit: The maximum gas that the extrinsic can consume
* Gas used: The actual gas consumed by each call, followed by a percentage that occupies the limit
* more details: This part is the details of each layer of contract calls, and contains more important information.

Take the above picture as an example, the a81ac user calls the contract c650f, which is call 1. In the contract c650f, there are two more contracts called call 2 and call 3. The call depth of these two contracts is the same, so the same color arrow is used to display. Each call has a corresponding consumed gas and remaining gas. In the picture, call 2 consumes 2139256707 gas, and the remaining gas is 397860743293.

After clicking "more details":

The correct execution is as follows:

![](https://user-images.githubusercontent.com/44688313/115189966-eb5e1d00-a119-11eb-8b64-4e8663138a6b.png)

This part includes

* Function: Function selector
* Args: The parameters of the calling function.
* trap reason: the reason for the end of this execution
* env trace: host_function called during the execution of this contract

After the user uploads the ABI of the contract, he can click the "Decode parameters" button to analyze the functions and parameters called by the contract.
![](https://user-images.githubusercontent.com/44688313/115190258-5871b280-a11a-11eb-9fbd-866db9c72dc1.png)

When the Wasm contract executes panic, a Wasm execution call stack (backtrace) message will appear:

![](https://user-images.githubusercontent.com/44688313/115190363-7c34f880-a11a-11eb-862d-229628cff6ae.png)

#### 1.2. The association between the contract, related extrinsics, events, accounts, and Redspot

The realization of this function requires Europa to be able to index extrinsics. At present, Substrate provides the function of index extrinsic by hash, which is basically about to be developed. Therefore, Europa first needs to transplant this function to the Europa framework to provide the function of index extrinsic.

Europa UI needs to write related code. After each startup, scan the block data under the current workspace from block height 0 to build the index relationship between contracts, extrinsics, and accounts.

For the association of Redspot, the corresponding interface needs to be provided on the UI, and the corresponding configuration of Redspot is parsed after the call. (Similar to the association between Ganache and Truffle)

Take the display of the contract address in Explorer as an example.

![](https://user-images.githubusercontent.com/44688313/115190442-98d13080-a11a-11eb-9ddc-635330a3f3de.png)
![](https://user-images.githubusercontent.com/44688313/115190483-aab2d380-a11a-11eb-977b-b853e74755f1.png)

This interface not only displays the creator of the contract and the created extrinsic, but also allows the user to upload the contract ABI and directly call the related functions of the contract on this interface. At the same time, since the extrinsics sub-page lists all the related extrinsics of the contract, after the call is completed, the user can directly view the execution status of the call extrinsic initiated by the user under the sub-page, and retrieve the execution status of the historical extrinsic at any time.

#### 1.3. Europa's special founction RPC

Europa's backward of block height, and the forward of block height. These two RPCs can currently only be called directly from the outside. So this time in Europa UI, we will combine this feature with the operability of the UI.

Take the Forks interface display in apps as an example:

![](https://user-images.githubusercontent.com/44688313/115190540-c28a5780-a11a-11eb-973f-19e43850d2c6.png)

When the user wants to return to the 4455515 block, he only needs to click on the block to send a request to Europa, Europa will execute the backward logic to this block, and the block information displayed on the UI will also be returned to the block.

When the user wants to forward to a higher block, there will be an input box on the UI interface. After the user enters, Europa can forward the block to the specified height.

#### 1.4. Europa's display of state change

The current state change information of Europa only records changes in blocks (because it is directly related to StorageOverlay), and does not record Subtrie changes.

Therefore, Europa UI needs to display the status changes of the current extrinsic execution on the interface, and Europa needs to continue to develop the following 2 functions:

1. Europa refines the information of the state changes as a unit of extrinsic, and records it.
2. Europa needs to store the state changes of Subtrie.

After the development of these two functions, the UI can develop the corresponding interface for the corresponding function. In this version, only state changes similar to the hex format in Etherscan will be displayed. In future versions, we will try to display the real data after analyzing the metadata.

#### 1.5. Europa's function of workspace

This part is similar to Ganache and provides an interface for creating and managing workspace in the UI. The main logic is to call the Europa and workspace-related command interfaces in the UI and switch the Europa workspace. Under the management of workspace, different spaces can be stored and switched under the same path.

### 2. Europa's binary package

Similar to Ganache, in this version Europa will be distributed together with UI into binary packages for different platforms. To make binary, we use Electron to package Europa node and UI together. Therefore, this part needs to implement the following functions:

1. Introduce Electron to package Europa node and UI
2. Solve the problem of node compilation on multiple platforms, macOS, Windows and Linux.
3. Produce CI's long-term support for the compilation and packaging of Electron's multi-platform nodes.

The difficulty in this part is to solve the compatibility problem between different platforms. After the completion of this part, Windows users will greatly reduce the difficulty of configuring the environment in the process of constructing the contract development environment and lower the threshold for contract developers.

## Detailed timeline of v0.3 (May 6 - Jun 17)

Europa is divided into the following two parts in this proposal:

- Europa Node: refers to the node part of Europa, that is, the content in the original [Europa](https://github.com/patractlabs/europa) repository;
- Europa UI: refers to the interface part of Europa in this version. Europa-UI repository may be created or merged into the original Europa repository.

Therefore, the plan for this development is as follows:

1. **Week1-2: Refactor part of the code in Europa Node and design the corresponding interface for Europa UI. (3 developers * 2 weeks)***

* Update Europa and track to the latest Substrate version, and transplant related functions of extrisic indexing;

* Persist contract execution information (Contract trace, the log information of NestedRuntime above) and provide corresponding RPC to obtain this information;

* Refactor the storage module of state change information, associate the state change information with the extrisic hash, persist the data and provide the corresponding RPC;

* Support storage and access to Subtrie's state change information.

2. **Week3-5: Build Europa UI. (3 developers * 3 weeks + 1 designer * 1 week)**

* Europa UI framework;

* Index the storage of Europa Node, and construct the relationship between accounts, extrinsics, and contracts, and make corresponding persistence;

* Construct a visualization module of contract execution process information, and analyze the corresponding data obtained from Europa Node according to the contract Metadata information;

* Build extrinsic, block, event, and detailed information interface of each part;

* Associate each part with the RPC, storage and other parts provided by Europa Node.

3. **Week6: Integrate and test, build the CI of Europa UI binary package, and release the binary. (3 developers * 1 week)**

##  Cost of v0.3 (1 designer * week + 18 developers * weeks)

- Operating activities: $3800 ( Rent and Devices: $200 per developer * week )
- Employee payments: $35700 ($1500/$1900 per designer/developer * week)
- Total Cost: $39500 and EMA30 price: $36.2 / DOT
- Treasury Proposal: 1091 DOT

## Verification

1. Directly download the binary packages of Windows, macOS and Ubuntu from [Europa Release](https://github.com/patractlabs/europa/releases), which can be run directly on the corresponding platform.
2. After deploying any contract through Europa and calling it through a extrinsic, the functions planned in the prototype diagram are presented:
   1. In the associated account, you can click to jump between extrinsics and contracts. For example, click on an account to list the contracts deployed under this account and initiate invocation extrinsics, and click on the corresponding extrinsic or contract to jump to the corresponding detailed interface;
   2. Click on a extrinsic that deploys or invokes a contract, and the detailed information of the contract execution will be listed in a visual form; click on the state interface of the extrinsic, and the state information changed during the execution of the extrinsic will be listed;
   3. On the main page displaying block information, you can click on a block and roll back to that block, or enter a block height to forward the height of the Europa block to that block;
3. You can create and switch between different workspaces through the workspace interface;
4. After Europa is closed and restarted, the relationship between accounts, extrinsics and contracts before closing will be reconstructed based on the information in Europa's workspace.

Patract's Treasury proposal for Europa v0.3 (contract and runtime sandbox)

- PolkaWorld wants to make a plan called a **Social Contract** with the Polkadot Treasury.
- PolkaWorld is the first Polkadot community in China and has been running for two years.
- They have helped the community by writing articles and organizing events to teach people about Polkadot.
- Now, they want financial support from the Polkadot Treasury to keep helping the community.
- They are asking for about **1885.98 DOT** for the months of June, July, and August.
- This funding will help them build a strong and fair Polkadot community in China.
- Everyone is welcome to share their thoughts or comments on this proposal!

This proposal aims to establish a **Social Contract** between PolkaWorld and the Polkadot Treasury. PolkaWorld is the first Polkadot Chinese community in China. For the past two years, PolkaWorld was running as an independent Polkadot Chinese community funded by Web3 Foundation. We contribute to the Polkadot community by publishing Polkadot related articles (translated from Polkadot Blog/wiki or produce the original content), interviewing Polkadot eco-constructors, and organizing Meetup/Polkadot China Tour /Substrate Workshop and Substrate Hackathon in different cities in China to help people learn Polkadot well and build a strong Polkadot Chinese community!

As Polkadot became a decentralized, on-chain governance network, PolkaWorld would like to apply for funding from the Polkadot Treasury to continue to contribute to the Polkadot community and help build and maintain a strong, decent, and neutral Chinese community!

So this is an open social contract for a 3 months OKR and we apply approx **1885.98 DOT** total allocation for **June**, **July**, **August** depending on EMA(30) AVG rate（DOT = 36.04 usdt） [here](https://polkadot.subscan.io/tools/charts?type=price) and you can get all OKR details [here](https://docs.google.com/document/d/1ocWQuGWJ50JW3y00DG5pZhhZA3_eoIgZnmt07kkEfR8/edit?ts=6062dd8e&pli=1) 

Please feel free to comments!


A Social Contract between PolkaWorld and Polkadot Treasury - Ops and Maintenance proposal

Encode Club helps students learn about blockchain technology. Here are some important points:

- They work with 75 universities around the world.
- Encode Club organizes events like educational programs and hackathons.
- They want to start a new program to involve students in the Polkadot ecosystem.
- The program includes learning series, a special hackathon, and an accelerator.
- They are asking for money in five steps to support their projects.
- The first step needs about £30,000 to help 50 universities and 1000-2000 students.

[Encode Club](https://www.encode.club/) educates, supports and backs the next-generation of university and hacker talent coming into blockchain. We work across 75 universities worldwide. We mainly organise educational programmes, hackathons and accelerators.

After the success of Polkadot's involvement in a recent [Encode Club hackathon](https://medium.com/encode-club/encode-hack-club-polkadot-overview-5689abfa62d0), we would like to extend our work, bring more adoption and new talent to the ecosystem.

We propose a year-long programme to build student involvement in the Polkadot ecosystem, including:

- An education series and curriculum
- A dedicated hackathon
- A dedicated accelerator

Please find more details in our proposal deck, attached [here](https://docs.google.com/presentation/d/1eMwwFDkJS1FrKN1IBD6fuXHrO-bBXpxVrUNOAqt0R4A/edit?usp=sharing).

**Our proposal is split across 5 tranches:**

**For the first tranche, we are asking for 1087.90 DOT** (roughly £30,000) to cover the education series and curriculum. With this first tranche funding, we aim to achieve the milestone of delivering 8 events, with 50 universities participating and 1000-2000 students attending.

There are five tranches in total, these are:

- **Now**: £30k to pay for the education series and curriculum

- **August 2021**: £30k once the education series and curriculum is over to pay for hackathon

- **December 2021**: £30k once the hackathon is over to pay for the accelerator.

- **December 2021** :up to £20k to reward hackers and pay prizes

- **April 2021**: up to £30k to pay grants to the accelerator teams.

All milestone info is in the [deck.](https://docs.google.com/presentation/d/1eMwwFDkJS1FrKN1IBD6fuXHrO-bBXpxVrUNOAqt0R4A/edit#slide=id.gc4baf28d3e_0_847)

Encode Club - university engagement programme - Phase 1 (out of 5)

**Motion 78** upgrading Polkadot Runtime to **v30** is up for vote.   Release notes, runtime changes and hash can be found [HERE](https://github.com/paritytech/polkadot/releases/tag/v0.8.30). 

All council members please vote at your earliest convenience!

Runtime v30 on Polkadot

- OnFinality is a platform that helps people build on the Polkadot blockchain.
- They have a new service called a shared node API, which was recently launched.
- The service helps developers by providing important tools they need.
- OnFinality has recorded over 1 billion requests for this service.
- They offer a free plan allowing 500,000 requests each day for users.
- You can create a free account to use their public API service.
- Their goal is to support all types of developers, from beginners to big teams.

OnFinality is a SaaS platform providing infrastructure services for the Polkadot/Substrate community. We just launched our beta version of a shared node API Service and are already listed in the Polkadot.js app. This service expands on our core mission - to support all blockchain developers in the world by providing core infrastructure so they can focus on building the next dApp.

**This funding grant is for the ongoing running costs of two pools of Polkadot nodes for Q2 2021 (April, May, June) - this will be proposed again every three months.**
- These costs are currently estimated at USD $9,714.86 each quarter
- In Q1 2021 we served ([see previous proposal report](https://polkadot.polkassembly.io/treasury/31)):
    - A grand total of 666,946,005 requests over the quarter.
    - A record 31,447,298 daily requests
    - A rolling 7 day average at the end of the Q1 period of 9,441,503 requests each day
- Earlier today (21st April) we just passed 1 Billion requests to this service so usage is only accelerating
- We’ll maintain our free tier for users of 500,000 requests a day. This is so we can maintain and ensure that Polkadot is accessible by all, from the largest and most funded development teams, to the many amateurs tinkering away.
- We’ll maintain the [one click deploy dedicated node](https://onfinality.io/dedicated_nodes) access to Polkadot for customers that need more than what our API service is intended for
- You can access our public API service by creating a [free account for our admin portal](https://support.onfinality.io/hc/en-us/articles/900004222183), or by connecting to it using [Polkadot.js](https://polkadot.js.org/)

[You can read more about this proposal, including detailed itemised costing here](https://docs.google.com/document/d/1VbNyiJ1az_4khvG0yCuf2vof-yxivplgBN5rfs_OKes/edit?usp=sharing)

High Performance Public Infrastructure (Ongoing Costs for Q2 2021)

This is a treasury proposal whose proposer address (12dEoCBb6UPPRDwQm86p2oSY6JwSWqHLcYrJx1dA7MreBZmF) 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.

Redspot is a tool that helps people create special contracts using something called Wasm. Here are some important points about it:

- Redspot makes contract development easier by hiding complicated technical details.
- Several teams, like Acala and Plasm, are already using Redspot to build applications.
- Redspot has finished different versions, with the latest one being v0.3 which helps more developers join.
- In the upcoming version (v0.4), Redspot plans to support multiple contracts and create a user-friendly web interface.
- It will also allow users to compile contracts using Docker, making it easier for different computer systems to work together.
- There will be new features like plugins that make coding easier, such as using easy-to-read amounts for transactions.
- The goal is to make Redspot helpful for both new and experienced developers in building contracts smoothly.

[Redspot](https://redspot.patract.io/) is one of [Patract](https://patract.io)'s Wasm contract development tool suite. Redspot's goal is to standardize 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. Patract had finished 3 proposals for Redspot at 4 months ago, the latest one is for v0.3 at [treasury #23](https://polkadot.polkassembly.io/treasury/23), and the report is at [post #207](https://polkadot.polkassembly.io/post/207) . We also had followed up the changes of Pallet-Contracts and ink! during the last 4 months.

There are also many parachain teams already in use of Redspot, including [Acala](https://acala.network/), [Plasm](https://www.plasmnet.io/), [Litentry](https://www.litentry.com/), [OpenSquare](http://opensquare.network/) etc. At the ParityAsia Hackathon, the [inkBridge](https://github.com/ParityAsia/hackathon-2021-spring/blob/main/teams/26-InkBridge/docs/project.md) and [SkyePass](https://github.com/ParityAsia/hackathon-2021-spring/blob/main/teams/30-SkyePass/docs/project.md) all used Patract suite (Redspot, Europa, PatraStore, etc.) to develop Wasm contract DApps from zero and win the 2nd and 3rd prizes.

## Summary of Redspot’s Future Plan (old)：

* v0.1(finished): Build core functions based on Truffle framework
* v0.2(finished): Migrate to Hardhat framework to enhance the extensibility of plugins and add some features to provide a smoother development workflow
* v0.3(finished): 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.

In the old design of the v0.4, the plan we expected is no longer suitable for the recent situation:

1. Typescript support for contracts: After discussing with Jacob (`api-contract` in `polkadot.js` is going to support Typescript), we believe that its importance is not high and does not affect the current use, so the support for contract Typescript is placed after `api-contract` supports this function.

2. Integrate multi-language SDK: Since `pallet-contracts` changed the interfaces in 3.0.0 and the recent changes are huge, the Himalia project of Patract’s multi-lang SDKs currently has only the Go version to catch up with the latest changes, and the python version is not updated in time. Moreover, the java version and .NET version have not been launched yet, so the multi-lang SDKs are not yet fully prepared, so they are temporarily unable to be integrated into Redspot in this version.

## Summary of Redspot’s v0.4 Plan (new)：

1. Support multi-contract: In the recent updates of ink! and cargo-contracts, multi-contracts can finally be compiled normally. Therefore, Redspot will revise its support system for multiple contracts.
2. Support docker compilation: Because of the current different environments, Wasm compilation results will be inconsistent (for example, Substrate's Runtime uses [srtool](https://github.com/paritytech/srtool) to solve this problem). On the other hand, It may be difficult to build a compilation environment under different operating systems (such as Windows), so supporting docker can solve many environmental problems.
3. Support web interface: Although Redspot is basically a command line tool, it is not very attractive to programmers who are just getting started. Therefore, Redspot plans to introduce a contract deployment and operation interface similar to Canvas-UI, and add rich functions to this interface, strengthen the contract-related attributes in product design, and visualize some Redspot functions. And this interface can also add additional functions such as calling the polkadot{.js} extension for transaction signing (the browser extension cannot be called in the Redspot command line).
4. Add some other plugins to enrich the Redspot ecosystem, such as support for chain types, plugins for monitoring file changes, and so on.

## Detailed design of v0.4:

### 1. Multi-contract support

The problem of ink! and cargo-contracts compiling multiple contracts has been corrected after the submission of [Cargo-contract PR#199](https://github.com/paritytech/cargo-contract/pull/199). Therefore, Redspot can restart the supports for multi-contract compilation (Redspot once supported the multi-contract organization structure to a certain extent, but was stopped due to the inability to compile)

Redspot's multi-contract support will start from the following aspects:

1. Multi-contract indexing and identification of document structure.
2. `redspot.config.ts` supports configuration by file index.
3. Judgment and sorting of compilation results (including the processing of compilation result of the contracts with same name)
4. Support the use of multiple languages for mixed compile

Redspot will automatically find all contract files in this directory through the configured search directory. Then compile through the configured compile tool, and finally all compile results will be output to the `artifacts` directory. At the same time, a `buildInfo` file will be generated, which records the project directory structure before compilation.

### 2. docker compilation support

Supporting the invocation of docker in Redspot can solve many problems related to environment setup. For related discussions, see [cargo-contract issue #188](https://github.com/paritytech/cargo-contract/issues/188) and [cargo-contract issue #184](https://github.com/paritytech/cargo-contract/issues/184), submitted by us. Therefore, when we noticed that the cargo-contracts `dockerfile` appeared in the [CI of scripts](https://github.com/paritytech/scripts/tree/master/dockerfiles/contracts-ci-linux ), we can add related functions for Redspot about calling docker.

Redspot will detect whether there is an existing docker environment. And automatically pull the docker image of the specified version. On the other hand, Redspot will maintain a docker image as the default testnet.

### 3. Web interface support

Since the main functions of Redspot have been relatively complete, the follow-up of Redspot will do more easy-to-use development on the product. For example, providing a contract-related UI interface to Redspot can make it easier for beginners to get started with the contract development process. On the other hand, there are some functions in Redspot that need to evoke the browser to participate in the corresponding operation (for example, call the polkadot{.js} extension to sign).

Although parity has provided [Canvas UI](https://paritytech.github.io/canvas-ui/#/) and Developer-Contracts in [https://polkadot.js.org/apps](https://polkadot.js.org/apps) , these two cannot reach our demand in terms of the specialization of the contract part. For example, Canvas-ui provides a more intuitive contract operation interface, but it does not has chain-related display information. Although apps has a more comprehensive information display, the contract call part is stronger than canvas-ui, but regardless of canvas-ui or apps are still lacking in contract-related functions, such as scanning and recording existing contracts, parsing contract parameters, and associating with the secret key in the Redspot configuration, and so on.

On the other hand, like Truffle, Redspot will also be designed to be used in a production environment to deploy contracts, so Redspot needs to provide a secure way to sign transactions. For example, hardware wallets such as ledger and parity-signer can be used in the future to deploy and call contract transaction signing. In this way, developers can firstly uses a configuration similar to `development`, configures the test key to test the contract in the test environment, then switches to production environment, configures the key of the production environment to deploy the contract. In order to take care of all environments, we think that calling the browser to interact is a better method. So this time we try to integrate the call of polkadot{.js} extension.

In summary, Redspot's web interface will provide beginners with a wealth of information to start contract operations, and also integrate some operations that cannot be handled in the cli environment:

1. The interface will contain basic information such as chain blocks, transactions, events, etc., and the contract operation interface is similar to Canvas-UI.
2. The web will scan or record (different strategies according to different chains) existing contracts, and read the Redspot config environment to associate with the existing keys
3. The web interface will display detailed information related to contract operations on the contract interface, such as gas, selector, parameter content, etc. in a contract call
4. The web interface will visualize some operations of Redspot, such as introducing Redspot's console interface to display the log of the executed operation, or it can display test and script information, and call and execute it through the interface.
5. When the security key is configured in Redspot's config, the web interface will need to call polkadot{.js} to sign the transaction.
6. Support the storage query of the contract.
7. The latest local compilation result will be uploaded automatically. It is convenient to deploy and call contracts manually.

### 4. Add some other plugins

4.1. Redspot-watcher

Currently Redspot executes commands such as `redspot test`, `redspot console`, etc. to check whether the contract file is modified when it is executed. Therefore, the developer needs to judge whether the contract needs to be compiled and add the `--no-compiled` command to inform redspot that the contract does not need to be compiled for this execution. Therefore, after the introduction of `redspot-watcher`, before calling the redspot runtime to execute, the `redspot-watcher` can determine whether there are file changes, so as to determine whether the compilation process needs to be invoked.

redspot-watcher will modify redspot's test, run and console commands. Before each run, the file hash will be calculated and stored in the buildinfo file, and then compared with the previous file hash. If there is no change, the compilation will be skipped.

4.2. Balances decimal plugin

In `web3.js`, you can use methods such as `1 ETH` to replace inputs like `10000...000`. This human-readable approach can greatly reduce the probability of making mistakes when developer write scripts and tests. However, because the precision of Ethereum is fixed, and when Substrate introduces `pallet-contracts`, the precision is determined by this chain, so the plug-in is not a static conversion, but needs to get the relevant information of the chain (decimal, symbol ) to be converted.

Therefore, the plug-in will eventually achieve functions similar to the following:

* '1 DOT' = '10000000000'
* '1 KSM' = '1000000000000'
* '1 nano’ = ’10^-9 DOT'

4.3. default blockchain types plugin

Since Substrate has not yet integrated `scale-info`, each chain provides `types` to support the parsing of polkadot.js. Currently, Redspot requires developers to fill in the type information in `redspot.config.ts`, which causes some troubles for developers. This plug-in obtains the types of different chains that already exist in apps, provides it to polkadot.js by default, and allows developers to override the form in `redspot.config.ts`, so that in most cases, developers do not need to worry about the need of providing polkadot.js the types.

We will discuss with polkadot apps and hope to release the @polkadot/apps-config package. Then all types provided in this package will be registered. We will also process the known contract chains with wasm functions. Maintain the types of their test chain. In this way, as long as the chain’s specversion is correctly set, there is no need to worry about the version.

## Detailed timeline of v0.4（5 weeks, 4 Apr ~ 10 May）

- Week 1: Implement docker support (3 developers)
   - can specify docker image as a node.
   - can specify docker image as the contract compiler.

- Week 2: Support multi-contract compilation and redspot-watcher plugin (3 developers)
   - Multi-contract compilation is possible
   - The compiled product can maintain the directory structure
   - Can detect whether the contract file has been modified, and skip the compilation if there is no modification

- Week 3-4: Web interface design and development (3 developers \* 2 weeks + 1 designer \* 1 week)
   - can browse to view contract events
   - You can query the storage of the contract
   - Can automatically upload local wasm and metadata files
   - Automatically inject locally configured accounts
   - Can call contracts and deploy contracts

- week 5: Develop balances decimal plugin and default blockchain types plugin (3 developers)
   - The amount can be passed in in a human-readable way.
   - In most cases, there is no need for developers to pass in types.

## Cost of v0.4 (1 designer \* week + 15 developers \* weeks)
* Operating activities: $3200 ( Rent and Devices: $200 per developer * week )
* Employee payments: $30000 ($1500/$1900 per designer/developer * week)
* Total Cost: $33200 and monthly average: $36 / DOT
* Treasury Proposal: 922 DOT

## How to verify v0.4:  Github library

* Multi-contract support: able to compile the delegator contract in ink/example and the multi-contracts contract project provided by redspot
* Support docker compilation: redspot can automatically pull and run the docker image containing cargo-contract component under the user's choice to compile the contract. The compiled structure can be moved to the `artifacts` directory, and the file permissions are correct.
* Redspot's web interface:
  1. Display the information and contract interface of the connected node
  2. When a contract is deployed, the contract information and related transactions will be recorded. And can be associated with the deployer. For Europa, it can directly scan the deployed contracts and associate relevant information.
  3. Display detailed contract operation information
  4. The information that Redspot originally displayed on the command line can be displayed in the web interface, and redspot test cases can be called and executed from the web interface.
  5. Able to call the polkadot.js extension to sign Redspot transactions.
* Other plug-ins
  * redspot-watcher: When the file is not edited, the contract will not be compiled if the relevant commands are re-executed. When the file is compiled, the compilation process will be called when re-executed
  * Balances decimal plug-in: Use canvas, Jupiter and Europa to test, respectively test `1 Unit`, `1 DOT`, etc.
  * default blockchain types: Connect Canvas-node and Jupiter. You no longer need to fill in types and you can send transactions normally.

Patract’s treasury proposal for Redspot v0.4 (Wasm contract scaffold)

- The project has finished the first part (M1) and it was approved.
- They will now work on the second part (M2).
- M2 has five main tasks to do.
- The first task is to let users manage multiple accounts.
- The second task adds notifications for important events.
- The third task customizes notifications based on user roles.
- The fourth task allows users to customize notification details.
- The fifth task improves the governance dashboard with new views.

Followed by the completion of M1 of our [proposal](https://polkadot.polkassembly.io/motion/49) and its successful [review](https://polkadot.polkassembly.io/motion/49#d617672a-1999-442f-94df-3a150cb8a176), we want to proceed the development as outlined in M2.

The tasks in M2 mainly focus on:

1. Offer user the interface to interact with multiple accounts under each network.
2. Basic support on Push Notification to subscribe important event.
3. Support different Push Notification type based on user roles
4. Basic customization support on the granularity of the Push notification
5. Further support of the governance dashboard by implementing missing views, e.g. Referendum list and detail view, treasury detail view.

Detail breakdown and its estimate can be found under the proposal [here](https://docs.google.com/document/d/1kZoYFv6hVodf-hTYZofNZ37ShkcNU97LXDaFlg0ouSs/edit?usp=sharing)


----
Reference links:

- M1 Review form: [here](https://docs.google.com/spreadsheets/d/17PRwueKUVH5NuJl7xItaURnAKFtxfLWgnGSPdo4wYQY/edit?usp=sharing)

- M1 Intake review report: [here](https://docs.google.com/document/d/1fwhb8rnitTNx_GuRX4-Ou4EIxJv3RhgzrCxYSTs8pUs/edit?usp=sharing)

- Original proposal: [here](https://polkadot.polkassembly.io/motion/49)


Milestone 2 of Governance-focused Mobile App for all Substrate-based networks 

- Dotreasury is a project funded by Kusama that provides accounting information and allows community comments on expenses.
- The team plans to integrate Polkadot into Dotreasury and make improvements, like better code for supporting multiple chains and a price tracker.
- They will show fiat values of tokens instead of just amounts and will deploy a Polkadot archive sync node for better performance.
- The total cost for the project is $11,300, which includes expenses for developers and server fees.
- The team expects to deliver the updates within a month.
- They want to discuss the credit model for future work and have plans to share a draft document for it soon.

Copied from [post 368](https://polkadot.polkassembly.io/post/368)

---

As you may know we developed [dotreasury](https://www.dotreasury.com/) with 2 milestones funded by Kusama. Generally now dotreasury provide a detailed accounting info and a place for community members to comment the expense. Please check following links for more details.
- The initial post and discussions: [link](https://kusama.polkassembly.io/post/352)
- 1st milestone work report: [link](https://kusama.polkassembly.io/post/352#870d76ca-0cf3-4f87-8c94-012fccc939ea)
- 2nd milestone proposal page: [link](https://kusama.polkassembly.io/treasury/75)
- 2nd milestone work report: [link](https://www.dotreasury.com/proposals/75#60489b5e98f65074c4c9036a)

Or just check [here](https://www.dotreasury.com/projects/dotreasury) for the dotreasury project page on dotreasury. We propose to integrate polkadot to dotreasury.

## Work 
### Code refactor
Now the code is highly coupled with Kusama, and we need to refactor all the packages(scan, restful server, react app) to support multiple chains.
- We don't plan to use 2 subdomains for kusama and polkadot separately, so the front page url may become from `/proposals `to `/[ksm|dot]/proposals`. Benefit is user don't have to login again after switching chains.

### Price tracker
Some metrics now in dotreasury are ranked by the token amount, while it will be better if we can rank them with the fiat cost. Generally we will create a price ticker and call the api of some exchanges(maybe binance, huobi, ok) maybe every minute. Finally we may show the fiat value with the proposed time price and we don't have to make it so accurate to reduce development cost.

### Others
- A polkadot archive sync node will be deployed on our server to better scan performance
- Expense related links will be collected to show on the corresponding pages.
- Collect the funded projects, show the list the detailed page with the timeline.
- Listen the direct transfers to treasury address.
- Polish. For example, we may provide a link to the staking remaining explanation pages to user to better understand the inflation. Some UX tips will also be improved.

## Cost and delivery

Cost details
- 3 developers * 2 weeks equivalent work = $3500 * 3 = $10500
- Server fee for 2021.03 and 2021.04:  (8vCPU + 16GiB + 500GiB SSD + 10Mbps) * 2 = $800
- Auxiliary work from 1 designer and 1 executive intern = $0

So the final price is $11300. Taking dot price as $30, the request dot amount is 376. 

We will deliver it as soon as possible, but since we are developing other products as well, we hope deliver it no later than one month. Output will be:
Output: 
- Polkadot shown on [dotreasury.com](https://www.dotreasury.com/)
- [Code repo](https://github.com/opensquare-network/dotreasury) better support multiple chains.

## Possible questions

1. Why not develop the M3(credit model) first, and the polkadot?
    - We want the credit building rules are fully discussed before we finally build it. Even so, we may build it by steps. But the work of M1 and M2 is meaningful to polkadot too.
    - Though polkadot integrated, M3 work will be done for kusama, and then polkadot when no big disputes.
    - Better to adjust code structure first before add big new features from the view of development.

2. How to discuss the credit model?  
  We have a draft doc for it and will create a post soon for discussion. But it may be posted in the kusama polkassembly first.

---
We are [OpenSquare](https://www.opensquare.network/) team, dedicated to facilitate the collaboration between projects and developers.

OpenSquare's treasury proposal for doTreasury polkadot integration

account

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

- PolkaWorld is asking for help to improve their website for the Polkadot Chinese community.
- They are the biggest Chinese community on WeChat but can only share one article each day.
- Many important articles are not shared quickly because of this limit.
- Currently, their information is only available on WeChat, which makes it hard for more people to learn about Polkadot.
- They want to add new features like real-time news and videos to their website to share content better.
- They are requesting 647.07 DOT to support the changes for the first three milestones.
- More details about the project and budget are in a provided link.

Hi, all councilors,

PolkaWorld is submitting a proposal for polkaworld.org website development and enhancement for the Polkadot Chinese community. PolkaWorld is the largest Chinese community in China, based solely on wechat so far.

Problem Description As Polkadot ecology flourishes, more content is produced by PolkaWorld. Due to the WeChat official account platform restrictions, we can only publish one article per day. As a result, we have accumulated a lot of useful content that cannot be released in time.

At present, PolkaWorld information can only be displayed on the mobile terminal of WeChat ecosystem, not on a public website, which to some extent affects more people who learn Polkadot.

With the growth and development of the community, the current content form is too restricting: we need more forms (Real-time News/live streams) to spread the content of Polkadot and Substrate.

The deliverable of this proposal is the enhancement of the website on polkaworld.pro, which will allow us to post content at any time and add a section of Real-time News and videos to enrich the form of content, providing the community with real-time information.

We requested 647.07 DOT (Rate: 34.37 USD/DOT based on a EMA30 rate on [subscan](https://polkadot.subscan.io/tools/charts?type=price)) for milestone 1 ~ milestone 3.

You can get more details about the milestones and budget [here](https://docs.google.com/document/d/1nxJNfGgLoiZcbmqpTCDD5TstCxAPUlgnX1a28Byd3pE/edit#)

Pls feel free to feedback me if you have any confuse/questions!

Many thanks!

Council Motions