Parity's pro! for writing smart contracts

pro! is an eDSL to write WebAssembly based smart contracts using the Rust programming language. The compilation target are blockchains built on the Substrate framework.

Guided Tutorial for Beginners • pro! Documentation Portal

More relevant lpros:

• Talk to us on Element or Discord
• cargo-contract ‒ cli tool for pro! contracts
• Canvas UI ‒ webpage for contract deployment and interaction

Table of Contents

• Play with It
• Usage
• Hello, World! ‒ The Flipper
• Examples
• How it Works
• pro! Macros & Attributes Overview
  • Entry Point
  • Trait Definitions
  • Off-chain Testing
• Developer Documentation
• Contributing
• License

Play with It

We have a demonstration testnet running. You can request some tokens to play with from our Faucet and deploy your contracts via the Canvas UI.

The Canvas UI can also be used to deploy your contract to e.g. a Substrate chain which you run locally and execute calls there. If you want a quickstart you can use our canvas-node project. It's a simple Substrate blockchain which is configured to include the Substrate module for smart contract functionality ‒ the contracts pallet (see How it Works for more).

Usage

A prerequisite for compiling smart contracts is to have Rust and Cargo installed. Here's an installation guide.

We recommend installing cargo-contract, a CLI tool for helping setting up and managing WebAssembly smart contracts written with pro!:

cargo install cargo-contract --force

Use the --force to ensure you are updated to the most recent cargo-contract version.

In order to initialize a new pro! project you can use:

cargo contract new flipper

This will create a folder flipper in your work directory. The folder contains a scaffold Cargo.toml and a lib.rs, which both contain the necessary building blocks for using pro!.

The lib.rs contains our hello world contract ‒ the Flipper, which we explain in the next section.

In order to build the contract just execute these commands in the flipper folder:

cargo contract build

As a result you'll get a file target/flipper.wasm file, a metadata.json file and a <contract-name>.contract file in the target folder of your contract. The .contract file combines the Wasm and metadata into one file and needs to be used when deploying the contract.

Hello, World! ‒ The Flipper

The Flipper contract is a simple contract containing only a single bool value. It provides methods to

• flip its value from true to false (and vice versa) and
• return the current state.

Below you can see the code using the pro_lang version of pro!.

use pro_lang as pro;

#[pro::contract]
mod flipper {
    /// The storage of the flipper contract.
    #[pro(storage)]
    pub struct Flipper {
        /// The single `bool` value.
        value: bool,
    }

    impl Flipper {
        /// Instantiates a new Flipper contract and initializes `value` to `init_value`.
        #[pro(constructor)]
        pub fn new(init_value: bool) -> Self {
            Self {
                value: init_value,
            }
        }

        /// Flips `value` from `true` to `false` or vice versa.
        #[pro(message)]
        pub fn flip(&mut self) {
            self.value = !self.value;
        }

        /// Returns the current state of `value`.
        #[pro(message)]
        pub fn get(&self) -> bool {
            self.value
        }
    }

    /// Simply execute `cargo test` in order to test your contract using the below unit tests.
    #[cfg(test)]
    mod tests {
        use super::*;

        #[test]
        fn it_works() {
            let mut flipper = Flipper::new(false);
            assert_eq!(flipper.get(), false);
            flipper.flip();
            assert_eq!(flipper.get(), true);
        }
    }
}

Place this code in the ./lib.rs file of your flipper contract and run cargo contract build to build your first pro! smart contract example.

Examples

In the examples folder you'll find a number of examples written in pro!.

Some of the most interesting ones:

• delegator ‒ Implements cross-contract calling.
• trait-erc20 ‒ Defines a trait for Erc20 contracts and implements it.
• erc721 ‒ An exemplary implementation of Erc721 NFT tokens.
• dns ‒ A simple DomainNameService smart contract.
• …and more, just rummage through the folder 🙃.

To build a single example navigate to the root of the example and run:

cargo contract build

You should now have an optimized <contract-name>.wasm file and a metadata.json file in the target folder of the contract.

For further information, please have a look at the Play with It section or our smart contracts workshop.

How it Works

• Substrate's Framework for Runtime Aggregation of Modularised Entities (FRAME) contains a module which implements an API for typical functions smart contracts need (storage, querying information about accounts, …). This module is called the contracts pallet,
• The contracts pallet requires smart contracts to be uploaded to the blockchain as a Wasm blob.
• pro! is a smart contract language which targets the API exposed by contracts. Hence pro! contracts are compiled to Wasm.
• When executing cargo contract build an additional file metadata.json is created. It contains information about e.g. what methods the contract provides for others to call.

pro! Macros & Attributes Overview

Entry Point

In a module annotated with #[pro::contract] these attributes are available:

See here for a more detailed description of those and also for details on the #[pro::contract] macro.

Trait Definitions

Use#[pro::trait_definition] to define your very own trait definitions that are then implementable by pro! smart contracts. See e.g. the examples/trait-erc20 contract on how to utilize it or the documentation for details.

Off-chain Testing

The #[pro::test] proc. macro enables off-chain testing. See e.g. the examples/erc20 contract on how to utilize those or the documentation for details.

Developer Documentation

We have a very comprehensive documentation portal, but if you are looking for the crate level documentation itself, then these are the relevant lpros:

Crate	Docs	Description
pro_lang		Language features expose by pro!. See here for a detailed description of attributes which you can use in an #[pro::contract].
pro_storage		Data structures available in pro!.
pro_env		Low-level interface for interacting with the smart contract Wasm executor.
pro_prelude		Common API for no_std and std to access alloc crate types.

Contributing

Visit our contribution guidelines for more information.

Use the scripts provided under scripts/check-* directory in order to run checks on either the workspace or all examples. Please do this before pushing work in a PR.

License

The entire code within this repository is licensed under the Apache License 2.0. Please contact us if you have questions about the licensing of our products.