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.
ink_metadata |
ink_env |
ink_storage |
ink_lang |
ink_prelude |
---|---|---|---|---|
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.
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.
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.
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.
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.
Visit our contribution guidelines for more information.
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.