Skip to content
/ ink Public
forked from use-ink/ink

Parity's ink to write smart contracts

License

Notifications You must be signed in to change notification settings

oznfc/ink

 
 

Repository files navigation

ink! - Parity's ink to write smart contracts

Linux Codecov Coveralls LoC
linux codecov coveralls loc

IMPORTANT NOTE: WORK IN PROGRESS! Do not expect this to be working.

ink! is an eDSL to write WebAssembly based smart contracts using the Rust programming language targeting Substrate blockchains.

For more information please visit the ink! tutorial.

Developer Documentation

ink_metadata ink_env ink_storage ink_lang ink_prelude

Interaction with Substrate

Substrate's Framework for Runtime Aggregation of Modularised Entities (FRAME) contains the contracts pallet, which provides a generic smart contract interface for Wasm blobs. It takes care of e.g. state rent, storage, costs, etc..

ink! is a smart contract language which targets the interface exposed by contracts. As such, ink! smart contracts are compiled to Wasm.

Scripts

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

Examples

For building the example smart contracts found under examples you will need to have cargo-contract installed.

cargo install cargo-contract --force

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

Build example contract and generate the contracts metadata

To build a single example and generate the contracts Wasm file, navigate to the root of the example smart contract and run:

cargo contract build

To generate the contract metadata (a.k.a. the contract ABI), run the following command:

cargo contract generate-metadata

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

For further information, please have a look at our smart contracts workshop.

Hello, World! - The Flipper

The Flipper contract is a simple contract containing only a single bool value that it can flip from true to false and vice versa and return the current state.

To create your own version of the flipper contract, you first need to initialize a new ink! project in your working directory.

cargo contract new flipper

Below you can see the code using the ink_lang version of ink!.

use ink_lang as ink;

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

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

        /// Instantiates a new Flipper contract and initializes `value` to `false` by default.
        #[ink(constructor)]
        pub fn default() -> Self {
            Self::new(false)
        }

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

        /// Returns the current state of `value`.
        #[ink(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 default_works() {
            let flipper = Flipper::default();
            assert_eq!(flipper.get(), false);
        }

        #[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 && cargo contract generate-metadata to build your first ink! smart contract example.

Contribution

Visit our contribution guidelines for more information.

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.

About

Parity's ink to write smart contracts

Resources

License

Stars

Watchers

Forks

Packages

No packages published

Languages

  • Rust 99.6%
  • Shell 0.4%