We studied this project, in their current progress:

1. They did not organise the contract structure, but directly provided the compiled WASM and ABI files. We imitate truffle, allowing developers to write contracts directly in the project, shielding the WASM compilation layer.

1. They did not provide test cases. In our plan, polkadot.js needs to be packaged to provide a packaging interface similar to web3.js for contracts. The example provided by his Assertions is too simple.

1. We are building a large development team and will continue to iterate the Suite architecture in all directions. Of course, we will also learn from their project.

Would be super excited to see a sandbox contract dev environment, especially since it would benefit several projects in the ecosystem at once! (edit: referring to Europa) 

This is very beneficial for smart contract projects like us. I would like to try it on Plasm Network.

Here's an idea for extending Europa to be more general-purpose, though this might be Milestone 3 material:

- we create an IPFS directory which can host WASM runtimes
- anyone can host any WASM blob, provided its meta info contains a commit hash of a source codebase. That way, people can verify that the blob is what it says it is by building the runtime locally as well.
- When running Europa, a user can provide a URL or IPFS hash of the WASM blob to load (custom URLs should also be supported, as well as file:// urls) and run Europa in no-compile mode, and Europa would load this blob as its runtime, running a local version of that particular chain, exposing the RPCs that a node would usually expose.

This would provide developers with an extremely easy and resource-efficient way to power up local copies of a chain without a Rust environment, in order to effectively experiment no only on smart contracts if the chain supports them, but also rapid development of front ends and other helper tools.

Coupled with a chain state exporter like [this one](https://github.com/maxsam4/fork-off-substrate), Europa could be used to power up a local WASM fork of any live chain in minutes.

Additional feature Europa could (should?) have is time travel: rewind blocks by X blocks into the past, rerun transactions, change Tx on block X-n to fork off and see another outcome

You might want to take a look at https://github.com/halva-suite. They are currently developing truffle for substrate. 

## Problems Explanation

On the Polkadot mainnet, there will be one or more parachains that act as smart contract platforms. Compared with indenpendent parachain development, smart contract pallet enables developers to build their DApp in a simpler, faster, economical and high iterable way.  But for now, the smart contract platform in Polkadot lacks supporting tools, like [Truffle](https://github.com/trufflesuite/truffle), [Ganache](https://github.com/trufflesuite/ganache), [ERC Standards](https://eips.ethereum.org/erc), [OpenZeppelin Contracts](https://github.com/OpenZeppelin/openzeppelin-contracts), [Remix](https://remix.ethereum.org/) and [Infura](https://infura.io/) in Ethereum. Without those off-chain upper level tools, services and standards, Polkadot’s powerful underlying parachain infrastructure, graceful developability of ink!, and high speed of WASM still can’t persuade most of the developers to migrate their DApps to Polkadot, because it will be too complex or slow to write qulified smart contracts. 

## Labs Introduction

**Patract Labs **([patract.network](https://patract.network)) provides solutions for Polkadot's parachain smart contract ecosystem, supporting smart contract parachains in Polkadot's public blockchain network, and smart contract consortium blockchains based on Polkadot's technology. Patract Labs operates as an  offshore company and will not issue any new crypto currency. All solutions will focus on the usage and value of DOT. ([Introduction on Medium](https://medium.com/@Patractlabs/patract-labs-polkadots-parachain-smart-contract-solutions-provider-c846d5d7248c))

**Patract Developer Hub** ([patract.io](https://patract.io)) is the portal for DApp developers. Patract Developer Hub is learning from Ethereum's EVM smart contract ecosystem to improve the WASM smart contract ecosystem in Polkadot, and developing a series of essential tools for DApp developers in Polkadot platform. We think Polkadot will create a new era of smart contract 2.0. Substrate now supports both EVM and native WASM which is written by ink! or Rust, but we will mainly focus on the native WASM technology. The products will include development suites, token standards, contract libraries, security instructions, contract APIs, multi language SDKs, IDE, and analysis tools, etc.

**Patract DApp Market** ([patract.app](https://patract.app)) is the portal for DApp users. Patract Market will connect with multiple smart contract parachains in Polkadot ecosystem, tracking and recording enrich DApps, becoming the preferred portal for DApp users. The products will include DApp store,  contract explorer, and contract governances.

## Proposals Introduction

Patract Lab’s first group of proposals are focusing on Patract Suite, which is a series of development tools to simplify developing, debugging, testing and deploying smart contracts, like Truffle Suite in Ethereum.

Patract Lab’s next group of proposals may focus on Patract Library, which is an implementation of public contract modules and Polkadot standards, like OpenZeppelin Contracts and ERC Standards and in Ethereum. Patract Labs will participate in the discussion of those libraries with Web3 foundation and all the community.

Patract Lab’s future development roadmap is TBD.

## Patract Suite Milestones

#### Project1: Redspot
Github: https://github.com/patractlabs/redspot

The first project is "**Redspot**", named after Jupiter's Great Red Spot, which is also the largest DOT in the solar system. Redspot is inspired by Truffle (https://github.com/trufflesuite/truffle) in Truffle Suite.  Redspot is a development environment, testing framework and asset pipeline for pallet-contracts. Redspot is trying to let the development of ink! be projectized and simplify the testing and interacting with contracts.

**In Redspot v0.1, we will finish：**
see details at on-chain proposal #0 [ https://polkadot.polkassembly.io/treasury/0](https://polkadot.polkassembly.io/treasury/0)


#### Project2: Europa
Github: https://github.com/patractlabs/europa

The second project is “**Europa**”, named after Jupiter's second moon. Europa is inspired by Ganache (https://github.com/trufflesuite/ganache) in Truffle Suite. Europa is a sandbox of Substrate runtime environment, which would be used to simplify the developing, debugging, and integration test when developers develop Substrate runtime applications and test pallet-contracts. 

The sandbox will remove p2p and consensus functions, just remaining the execution environment and RPC interface. We will wrap the core modules, then provide a local database, a detailed log print function, a concept of workspaces which isolates different developing environments, and a front-end UI to interact with this sandbox. In the first phase, Europa would just integrate the pallet-contracts module. In the second phase, we would refactor the sandbox to be more general that could let developers to add their runtime module and test.

**In Europa v0.1, we will finish：**

1. Split the part of runtime execution in Substrate.
1. Local implementations for the interface of runtime execution.
1. Implement local Externalities.
1. Provide local storage.
1. Implement a local block producer to create blocks and call runtime execution to execute blocks.

**How to Verify:  Europa demo**

1. Can receive extrinsics and generate some blocks in tests.
1. Can execute a block and get the correct extrinsics_root and state_root in test.
1. Can persist changed data in the local database and check them.

## Contact

* Applicant: Lipeng Yue
* Company: Patract Labs
* email: lipeng@patract.network


#15 Patract Labs’ Proposals