| 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_abi |
ink_core |
|---|---|
 |
 |
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(version = "0.1.0")]
mod flipper {
use ink_core::storage;
/// The storage of the flipper contract.
#[ink(storage)]
struct Flipper {
/// The single `bool` value.
value: storage::Value<bool>,
}
impl Flipper {
/// Instantiates a new Flipper contract and initializes `value` to `init_value`.
#[ink(constructor)]
fn new(&mut self, init_value: bool) {
self.value.set(init_value);
}
/// Instantiates a new Flipper contract and initializes `value` to `false` by default.
#[ink(constructor)]
fn default(&mut self) {
self.new(false)
}
/// Flips `value` from `true` to `false` or vice versa.
#[ink(message)]
fn flip(&mut self) {
*self.value = !self.get();
}
/// Returns the current state of `value`.
#[ink(message)]
fn get(&self) -> bool {
*self.value
}
}
/// As in normal Rust code we are able to define tests like below.
///
/// Simply execute `cargo test` in order to test your contract.
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_works() {
// Note that `#[ink(constructor)]` functions that above have been
// defined as `&mut self` can be used as normal Rust constructors
// in test mode.
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.