>();
- let description = contract
- .get("description")
- .expect("contract.description not found");
- let documentation = contract
- .get("documentation")
- .expect("contract.documentation not found");
- let repository = contract
- .get("repository")
- .expect("contract.repository not found");
- let homepage = contract
- .get("homepage")
- .expect("contract.homepage not found");
- let license = contract.get("license").expect("contract.license not found");
-
- let user = metadata_json.get("user").expect("user section not found");
-
- // calculate wasm hash
- let wasm = fs::read(&crate_metadata.dest_wasm)?;
- let mut output = [0u8; 32];
- let mut blake2 = blake2::VarBlake2b::new_keyed(&[], 32);
- blake2.update(wasm);
- blake2.finalize_variable(|result| output.copy_from_slice(result));
-
- let mut expected_hash = String::new();
- write!(expected_hash, "0x").expect("failed writing to string");
- for byte in &output {
- write!(expected_hash, "{:02x}", byte).expect("failed writing to string");
- }
- let expected_language =
- SourceLanguage::new(Language::Ink, crate_metadata.ink_version).to_string();
- let expected_rustc_version =
- semver::Version::parse(&rustc_version::version()?.to_string())?;
- let expected_compiler =
- SourceCompiler::new(Compiler::RustC, expected_rustc_version).to_string();
- let mut expected_user_metadata = serde_json::Map::new();
- expected_user_metadata
- .insert("some-user-provided-field".into(), "and-its-value".into());
- expected_user_metadata.insert(
- "more-user-provided-fields".into(),
- serde_json::Value::Array(
- vec!["and".into(), "their".into(), "values".into()].into(),
- ),
- );
-
- assert_eq!(expected_hash, hash.as_str().unwrap());
- assert_eq!(expected_language, language.as_str().unwrap());
- assert_eq!(expected_compiler, compiler.as_str().unwrap());
- assert_eq!(crate_metadata.package_name, name.as_str().unwrap());
- assert_eq!(
- crate_metadata.root_package.version.to_string(),
- version.as_str().unwrap()
- );
- assert_eq!(crate_metadata.root_package.authors, authors);
- assert_eq!("contract description", description.as_str().unwrap());
- assert_eq!("http://documentation.com/", documentation.as_str().unwrap());
- assert_eq!("http://repository.com/", repository.as_str().unwrap());
- assert_eq!("http://homepage.com/", homepage.as_str().unwrap());
- assert_eq!("Apache-2.0", license.as_str().unwrap());
- assert_eq!(&expected_user_metadata, user.as_object().unwrap());
-
- Ok(())
- })
- }
-}
diff --git a/src/cmd/mod.rs b/src/cmd/mod.rs
index 00881e55d..5d3456d0b 100644
--- a/src/cmd/mod.rs
+++ b/src/cmd/mod.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -24,7 +24,12 @@ pub mod deploy;
mod instantiate;
pub mod metadata;
pub mod new;
+pub mod test;
+pub(crate) use self::{
+ build::{BuildCommand, CheckCommand},
+ test::TestCommand,
+};
#[cfg(feature = "extrinsics")]
pub(crate) use self::{
call::call_regular_contract, call::execute_call, call::execute_contract_call,
diff --git a/src/cmd/new.rs b/src/cmd/new.rs
index 39d794530..23eccd409 100644
--- a/src/cmd/new.rs
+++ b/src/cmd/new.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -23,12 +23,21 @@ use std::{
use anyhow::Result;
use heck::CamelCase as _;
-pub(crate) fn execute(name: &str, dir: Option
) -> Result
+pub(crate) fn execute(name: &str, dir: Option
) -> Result>
where
P: AsRef,
{
- if name.contains('-') {
- anyhow::bail!("Contract names cannot contain hyphens");
+ if !name.chars().all(|c| c.is_alphanumeric() || c == '_') {
+ anyhow::bail!("Contract names can only contain alphanumeric characters and underscores");
+ }
+
+ if !name
+ .chars()
+ .next()
+ .map(|c| c.is_alphabetic())
+ .unwrap_or(false)
+ {
+ anyhow::bail!("Contract names must begin with an alphabetic character");
}
let out_dir = dir
@@ -57,7 +66,7 @@ where
let contents = contents.replace("{{name}}", name);
let contents = contents.replace("{{camel_name}}", &name.to_camel_case());
- let outpath = out_dir.join(file.sanitized_name());
+ let outpath = out_dir.join(file.name());
if (&*file.name()).ends_with('/') {
fs::create_dir_all(&outpath)?;
@@ -73,10 +82,7 @@ where
.open(outpath.clone())
.map_err(|e| {
if e.kind() == std::io::ErrorKind::AlreadyExists {
- anyhow::anyhow!(
- "New contract file {} already exists",
- file.sanitized_name().display()
- )
+ anyhow::anyhow!("New contract file {} already exists", file.name())
} else {
anyhow::anyhow!(e)
}
@@ -96,21 +102,48 @@ where
}
}
- Ok(format!("Created contract {}", name))
+ Ok(Some(format!("Created contract {}", name)))
}
#[cfg(test)]
mod tests {
use super::*;
- use crate::{cmd, util::tests::with_tmp_dir};
+ use crate::util::tests::{with_new_contract_project, with_tmp_dir};
#[test]
fn rejects_hyphenated_name() {
- with_tmp_dir(|path| {
- let result = cmd::new::execute("rejects-hyphenated-name", Some(path));
+ with_new_contract_project(|manifest_path| {
+ let result = execute("rejects-hyphenated-name", Some(manifest_path));
+ assert!(result.is_err(), "Should fail");
assert_eq!(
- format!("{:?}", result),
- r#"Err(Contract names cannot contain hyphens)"#
+ result.err().unwrap().to_string(),
+ "Contract names can only contain alphanumeric characters and underscores"
+ );
+ Ok(())
+ })
+ }
+
+ #[test]
+ fn rejects_name_with_period() {
+ with_new_contract_project(|manifest_path| {
+ let result = execute("../xxx", Some(manifest_path));
+ assert!(result.is_err(), "Should fail");
+ assert_eq!(
+ result.err().unwrap().to_string(),
+ "Contract names can only contain alphanumeric characters and underscores"
+ );
+ Ok(())
+ })
+ }
+
+ #[test]
+ fn rejects_name_beginning_with_number() {
+ with_new_contract_project(|manifest_path| {
+ let result = execute("1xxx", Some(manifest_path));
+ assert!(result.is_err(), "Should fail");
+ assert_eq!(
+ result.err().unwrap().to_string(),
+ "Contract names must begin with an alphabetic character"
);
Ok(())
})
@@ -121,7 +154,7 @@ mod tests {
with_tmp_dir(|path| {
let name = "test_contract_cargo_project_already_exists";
let _ = execute(name, Some(path));
- let result = cmd::new::execute(name, Some(path));
+ let result = execute(name, Some(path));
assert!(result.is_err(), "Should fail");
assert_eq!(
@@ -139,7 +172,7 @@ mod tests {
let dir = path.join(name);
fs::create_dir_all(&dir).unwrap();
fs::File::create(dir.join(".gitignore")).unwrap();
- let result = cmd::new::execute(name, Some(path));
+ let result = execute(name, Some(path));
assert!(result.is_err(), "Should fail");
assert_eq!(
diff --git a/src/cmd/test.rs b/src/cmd/test.rs
new file mode 100644
index 000000000..98b9dae13
--- /dev/null
+++ b/src/cmd/test.rs
@@ -0,0 +1,94 @@
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
+// This file is part of cargo-contract.
+//
+// cargo-contract is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// cargo-contract is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with cargo-contract. If not, see .
+
+use crate::{maybe_println, util, workspace::ManifestPath, Verbosity, VerbosityFlags};
+use anyhow::Result;
+use colored::Colorize;
+use std::{convert::TryFrom, path::PathBuf};
+use structopt::StructOpt;
+
+/// Executes smart-contract tests off-chain by delegating to `cargo test`.
+#[derive(Debug, StructOpt)]
+#[structopt(name = "test")]
+pub struct TestCommand {
+ /// Path to the `Cargo.toml` of the contract to test.
+ #[structopt(long, parse(from_os_str))]
+ manifest_path: Option,
+ #[structopt(flatten)]
+ verbosity: VerbosityFlags,
+}
+
+impl TestCommand {
+ pub fn exec(&self) -> Result {
+ let manifest_path = ManifestPath::try_from(self.manifest_path.as_ref())?;
+ let verbosity = TryFrom::<&VerbosityFlags>::try_from(&self.verbosity)?;
+
+ execute(&manifest_path, verbosity)
+ }
+}
+
+/// Result of the test runs.
+pub struct TestResult {
+ /// The `cargo +nightly test` child process standard output stream buffer.
+ pub stdout: Vec,
+ /// The verbosity flags.
+ pub verbosity: Verbosity,
+}
+
+impl TestResult {
+ pub fn display(&self) -> Result {
+ Ok(String::from_utf8(self.stdout.clone())?)
+ }
+}
+
+/// Executes `cargo +nightly test`.
+pub(crate) fn execute(manifest_path: &ManifestPath, verbosity: Verbosity) -> Result {
+ util::assert_channel()?;
+
+ maybe_println!(
+ verbosity,
+ " {} {}",
+ format!("[{}/{}]", 1, 1).bold(),
+ "Running tests".bright_green().bold()
+ );
+
+ let stdout = util::invoke_cargo("test", &[""], manifest_path.directory(), verbosity)?;
+
+ Ok(TestResult { stdout, verbosity })
+}
+
+#[cfg(feature = "test-ci-only")]
+#[cfg(test)]
+mod tests_ci_only {
+ use crate::{util::tests::with_new_contract_project, Verbosity};
+ use regex::Regex;
+
+ #[test]
+ fn passing_tests_yield_stdout() {
+ with_new_contract_project(|manifest_path| {
+ let ok_output_pattern =
+ Regex::new(r"test result: ok. \d+ passed; 0 failed; \d+ ignored")
+ .expect("regex pattern compilation failed");
+
+ let res =
+ super::execute(&manifest_path, Verbosity::Default).expect("test execution failed");
+
+ assert!(ok_output_pattern.is_match(&String::from_utf8_lossy(&res.stdout)));
+
+ Ok(())
+ })
+ }
+}
diff --git a/src/crate_metadata.rs b/src/crate_metadata.rs
index 660dd836f..945cd8983 100644
--- a/src/crate_metadata.rs
+++ b/src/crate_metadata.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with cargo-contract. If not, see .
-use crate::workspace::ManifestPath;
+use crate::ManifestPath;
use anyhow::{Context, Result};
use cargo_metadata::{Metadata as CargoMetadata, MetadataCommand, Package};
use colored::Colorize;
@@ -52,8 +52,12 @@ pub struct ComposableScheduleMetadata {
pub struct CrateMetadata {
pub manifest_path: ManifestPath,
pub cargo_meta: cargo_metadata::Metadata,
+<<<<<<< HEAD
pub package_name: String,
pub t3rn_composable_schedule: Option,
+=======
+ pub contract_artifact_name: String,
+>>>>>>> 8e86572b4b4ed2442de131c8e3506dee219fb0b7
pub root_package: Package,
pub original_wasm: PathBuf,
pub target_directory: PathBuf,
@@ -62,28 +66,50 @@ pub struct CrateMetadata {
pub documentation: Option,
pub homepage: Option,
pub user: Option>,
+ pub target_directory: PathBuf,
}
impl CrateMetadata {
/// Parses the contract manifest and returns relevant metadata.
pub fn collect(manifest_path: &ManifestPath) -> Result {
let (metadata, root_package) = get_cargo_metadata(manifest_path)?;
+ let mut target_directory = metadata.target_directory.as_path().join("ink");
- // Normalize the package name.
+ // Normalize the package and lib name.
let package_name = root_package.name.replace("-", "_");
+ let lib_name = &root_package
+ .targets
+ .iter()
+ .find(|target| target.kind.iter().any(|t| t == "cdylib"))
+ .expect("lib name not found")
+ .name
+ .replace("-", "_");
+ let absolute_manifest_path = manifest_path.absolute_directory()?;
+ let absolute_workspace_root = metadata.workspace_root.canonicalize()?;
+ if absolute_manifest_path != absolute_workspace_root {
+ // If the contract is a package in a workspace, we use the package name
+ // as the name of the sub-folder where we put the `.contract` bundle.
+ target_directory = target_directory.join(package_name);
+ }
+
+<<<<<<< HEAD
// {target_dir}/wasm32-unknown-unknown/release/{package_name}.wasm
let mut original_wasm = metadata.target_directory.clone();
+=======
+ // {target_dir}/wasm32-unknown-unknown/release/{lib_name}.wasm
+ let mut original_wasm = target_directory.clone();
+>>>>>>> 8e86572b4b4ed2442de131c8e3506dee219fb0b7
original_wasm.push("wasm32-unknown-unknown");
original_wasm.push("release");
- original_wasm.push(package_name.clone());
+ original_wasm.push(lib_name.clone());
original_wasm.set_extension("wasm");
- // {target_dir}/{package_name}.wasm
- let mut dest_wasm = metadata.target_directory.clone();
- dest_wasm.push(package_name.clone());
+ // {target_dir}/{lib_name}.wasm
+ let mut dest_wasm = target_directory.clone();
+ dest_wasm.push(lib_name.clone());
dest_wasm.set_extension("wasm");
let mut composable_schedule: Option = None;
@@ -117,23 +143,31 @@ impl CrateMetadata {
None
}
})
- .ok_or(anyhow::anyhow!("No 'ink_lang' dependency found"))?;
+ .ok_or_else(|| anyhow::anyhow!("No 'ink_lang' dependency found"))?;
- let (documentation, homepage, user) = get_cargo_toml_metadata(manifest_path)?;
+ let ExtraMetadata {
+ documentation,
+ homepage,
+ user,
+ } = get_cargo_toml_metadata(manifest_path)?;
let crate_metadata = CrateMetadata {
manifest_path: manifest_path.clone(),
cargo_meta: metadata.clone(),
root_package,
- package_name,
- original_wasm,
- dest_wasm,
+ contract_artifact_name: lib_name.to_string(),
+ original_wasm: original_wasm.into(),
+ dest_wasm: dest_wasm.into(),
ink_version,
documentation,
homepage,
user,
+<<<<<<< HEAD
t3rn_composable_schedule: composable_schedule,
target_directory: metadata.target_directory.clone(),
+=======
+ target_directory: target_directory.into(),
+>>>>>>> 8e86572b4b4ed2442de131c8e3506dee219fb0b7
};
Ok(crate_metadata)
}
@@ -143,7 +177,7 @@ impl CrateMetadata {
fn get_cargo_metadata(manifest_path: &ManifestPath) -> Result<(CargoMetadata, Package)> {
let mut cmd = MetadataCommand::new();
let metadata = cmd
- .manifest_path(manifest_path)
+ .manifest_path(manifest_path.as_ref())
.exec()
.context("Error invoking `cargo metadata`")?;
let root_package_id = metadata
@@ -163,16 +197,21 @@ fn get_cargo_metadata(manifest_path: &ManifestPath) -> Result<(CargoMetadata, Pa
Ok((metadata, root_package))
}
+/// Extra metadata not available via `cargo metadata`.
+struct ExtraMetadata {
+ documentation: Option,
+ homepage: Option,
+ user: Option>,
+}
+
/// Read extra metadata not available via `cargo metadata` directly from `Cargo.toml`
-fn get_cargo_toml_metadata(
- manifest_path: &ManifestPath,
-) -> Result<(Option, Option, Option>)> {
+fn get_cargo_toml_metadata(manifest_path: &ManifestPath) -> Result {
let toml = fs::read_to_string(manifest_path)?;
let toml: value::Table = toml::from_str(&toml)?;
let get_url = |field_name| -> Result> {
toml.get("package")
- .ok_or(anyhow::anyhow!("package section not found"))?
+ .ok_or_else(|| anyhow::anyhow!("package section not found"))?
.get(field_name)
.and_then(|v| v.as_str())
.map(Url::parse)
@@ -196,5 +235,9 @@ fn get_cargo_toml_metadata(
})
.transpose()?;
- Ok((documentation, homepage, user))
+ Ok(ExtraMetadata {
+ documentation,
+ homepage,
+ user,
+ })
}
diff --git a/src/main.rs b/src/main.rs
index 10c9be88c..1f09e1828 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -17,8 +17,13 @@
mod cmd;
mod crate_metadata;
mod util;
+mod validate_wasm;
mod workspace;
+use self::workspace::ManifestPath;
+
+use crate::cmd::{metadata::MetadataResult, BuildCommand, CheckCommand, TestCommand};
+
#[cfg(feature = "extrinsics")]
use sp_core::{
crypto::{AccountId32, Pair},
@@ -26,8 +31,10 @@ use sp_core::{
};
use std::{
- convert::{TryFrom, TryInto},
+ convert::TryFrom,
+ fmt::{Display, Formatter, Result as DisplayResult},
path::PathBuf,
+ str::FromStr,
};
#[cfg(feature = "extrinsics")]
use subxt::PairSigner;
@@ -40,9 +47,11 @@ use crate::crate_metadata::CrateMetadata;
#[derive(Debug, StructOpt)]
#[structopt(bin_name = "cargo")]
+#[structopt(version = env!("CARGO_CONTRACT_CLI_IMPL_VERSION"))]
pub(crate) enum Opts {
/// Utilities to develop Wasm smart contracts.
#[structopt(name = "contract")]
+ #[structopt(version = env!("CARGO_CONTRACT_CLI_IMPL_VERSION"))]
#[structopt(setting = clap::AppSettings::UnifiedHelpMessage)]
#[structopt(setting = clap::AppSettings::DeriveDisplayOrder)]
#[structopt(setting = clap::AppSettings::DontCollapseArgsInUsage)]
@@ -97,34 +106,116 @@ impl ExtrinsicOpts {
}
}
-#[derive(Debug, StructOpt)]
-struct VerbosityFlags {
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum OptimizationPasses {
+ Zero,
+ One,
+ Two,
+ Three,
+ Four,
+ S,
+ Z,
+}
+
+impl Display for OptimizationPasses {
+ fn fmt(&self, f: &mut Formatter<'_>) -> DisplayResult {
+ let out = match self {
+ OptimizationPasses::Zero => "0",
+ OptimizationPasses::One => "1",
+ OptimizationPasses::Two => "2",
+ OptimizationPasses::Three => "3",
+ OptimizationPasses::Four => "4",
+ OptimizationPasses::S => "s",
+ OptimizationPasses::Z => "z",
+ };
+ write!(f, "{}", out)
+ }
+}
+
+impl Default for OptimizationPasses {
+ fn default() -> OptimizationPasses {
+ OptimizationPasses::Z
+ }
+}
+
+impl std::str::FromStr for OptimizationPasses {
+ type Err = Error;
+
+ fn from_str(input: &str) -> std::result::Result {
+ // We need to replace " here, since the input string could come
+ // from either the CLI or the `Cargo.toml` profile section.
+ // If it is from the profile it could e.g. be "3" or 3.
+ let normalized_input = input.replace("\"", "").to_lowercase();
+ match normalized_input.as_str() {
+ "0" => Ok(OptimizationPasses::Zero),
+ "1" => Ok(OptimizationPasses::One),
+ "2" => Ok(OptimizationPasses::Two),
+ "3" => Ok(OptimizationPasses::Three),
+ "4" => Ok(OptimizationPasses::Four),
+ "s" => Ok(OptimizationPasses::S),
+ "z" => Ok(OptimizationPasses::Z),
+ _ => anyhow::bail!("Unknown optimization passes for option {}", input),
+ }
+ }
+}
+
+impl From for OptimizationPasses {
+ fn from(str: String) -> Self {
+ OptimizationPasses::from_str(&str).expect("conversion failed")
+ }
+}
+
+#[derive(Default, Clone, Debug, StructOpt)]
+pub struct VerbosityFlags {
+ /// No output printed to stdout
#[structopt(long)]
quiet: bool,
+ /// Use verbose output
#[structopt(long)]
verbose: bool,
}
-#[derive(Clone, Copy)]
-enum Verbosity {
+/// Denotes if output should be printed to stdout.
+#[derive(Clone, Copy, serde::Serialize)]
+pub enum Verbosity {
+ /// Use default output
+ Default,
+ /// No output printed to stdout
Quiet,
+ /// Use verbose output
Verbose,
}
-impl TryFrom<&VerbosityFlags> for Option {
+impl Default for Verbosity {
+ fn default() -> Self {
+ Verbosity::Default
+ }
+}
+
+impl Verbosity {
+ /// Returns `true` if output should be printed (i.e. verbose output is set).
+ pub(crate) fn is_verbose(&self) -> bool {
+ match self {
+ Verbosity::Quiet => false,
+ Verbosity::Default | Verbosity::Verbose => true,
+ }
+ }
+}
+
+impl TryFrom<&VerbosityFlags> for Verbosity {
type Error = Error;
fn try_from(value: &VerbosityFlags) -> Result {
match (value.quiet, value.verbose) {
- (false, false) => Ok(None),
- (true, false) => Ok(Some(Verbosity::Quiet)),
- (false, true) => Ok(Some(Verbosity::Verbose)),
+ (false, false) => Ok(Verbosity::Default),
+ (true, false) => Ok(Verbosity::Quiet),
+ (false, true) => Ok(Verbosity::Verbose),
(true, true) => anyhow::bail!("Cannot pass both --quiet and --verbose flags"),
}
}
}
-#[derive(Debug, StructOpt)]
+#[derive(Default, Clone, Debug, StructOpt)]
struct UnstableOptions {
/// Use the original manifest (Cargo.toml), do not modify for build optimizations
#[structopt(long = "unstable-options", short = "Z", number_of_values = 1)]
@@ -155,6 +246,199 @@ impl TryFrom<&UnstableOptions> for UnstableFlags {
}
}
+/// Describes which artifacts to generate
+#[derive(Copy, Clone, Eq, PartialEq, Debug, StructOpt, serde::Serialize)]
+#[structopt(name = "build-artifacts")]
+pub enum BuildArtifacts {
+ /// Generate the Wasm, the metadata and a bundled `.contract` file
+ #[structopt(name = "all")]
+ All,
+ /// Only the Wasm is created, generation of metadata and a bundled `.contract` file is skipped
+ #[structopt(name = "code-only")]
+ CodeOnly,
+ CheckOnly,
+}
+
+impl BuildArtifacts {
+ /// Returns the number of steps required to complete a build artifact.
+ /// Used as output on the cli.
+ pub fn steps(&self) -> usize {
+ match self {
+ BuildArtifacts::All => 5,
+ BuildArtifacts::CodeOnly => 3,
+ BuildArtifacts::CheckOnly => 2,
+ }
+ }
+}
+
+impl std::str::FromStr for BuildArtifacts {
+ type Err = String;
+ fn from_str(artifact: &str) -> Result {
+ match artifact {
+ "all" => Ok(BuildArtifacts::All),
+ "code-only" => Ok(BuildArtifacts::CodeOnly),
+ _ => Err("Could not parse build artifact".to_string()),
+ }
+ }
+}
+
+impl Default for BuildArtifacts {
+ fn default() -> Self {
+ BuildArtifacts::All
+ }
+}
+
+/// The mode to build the contract in.
+#[derive(Eq, PartialEq, Copy, Clone, Debug, serde::Serialize)]
+pub enum BuildMode {
+ /// Functionality to output debug messages is build into the contract.
+ Debug,
+ /// The contract is build without any debugging functionality.
+ Release,
+}
+
+impl Default for BuildMode {
+ fn default() -> BuildMode {
+ BuildMode::Debug
+ }
+}
+
+impl Display for BuildMode {
+ fn fmt(&self, f: &mut Formatter<'_>) -> DisplayResult {
+ match self {
+ Self::Debug => write!(f, "debug"),
+ Self::Release => write!(f, "release"),
+ }
+ }
+}
+
+/// The type of output to display at the end of a build.
+pub enum OutputType {
+ /// Output build results in a human readable format.
+ HumanReadable,
+ /// Output the build results JSON formatted.
+ Json,
+}
+
+impl Default for OutputType {
+ fn default() -> Self {
+ OutputType::HumanReadable
+ }
+}
+
+/// Result of the metadata generation process.
+#[derive(serde::Serialize)]
+pub struct BuildResult {
+ /// Path to the resulting Wasm file.
+ pub dest_wasm: Option,
+ /// Result of the metadata generation.
+ pub metadata_result: Option,
+ /// Path to the directory where output files are written to.
+ pub target_directory: PathBuf,
+ /// If existent the result of the optimization.
+ pub optimization_result: Option,
+ /// The mode to build the contract in.
+ pub build_mode: BuildMode,
+ /// Which build artifacts were generated.
+ pub build_artifact: BuildArtifacts,
+ /// The verbosity flags.
+ pub verbosity: Verbosity,
+ /// The type of formatting to use for the build output.
+ #[serde(skip_serializing)]
+ pub output_type: OutputType,
+}
+
+/// Result of the optimization process.
+#[derive(serde::Serialize)]
+pub struct OptimizationResult {
+ /// The path of the optimized wasm file.
+ pub dest_wasm: PathBuf,
+ /// The original Wasm size.
+ pub original_size: f64,
+ /// The Wasm size after optimizations have been applied.
+ pub optimized_size: f64,
+}
+
+impl BuildResult {
+ pub fn display(&self) -> String {
+ let optimization = self.display_optimization();
+ let size_diff = format!(
+ "\nOriginal wasm size: {}, Optimized: {}\n\n",
+ format!("{:.1}K", optimization.0).bold(),
+ format!("{:.1}K", optimization.1).bold(),
+ );
+ debug_assert!(
+ optimization.1 > 0.0,
+ "optimized file size must be greater 0"
+ );
+
+ let build_mode = format!(
+ "The contract was built in {} mode.\n\n",
+ format!("{}", self.build_mode).to_uppercase().bold(),
+ );
+
+ if self.build_artifact == BuildArtifacts::CodeOnly {
+ let out = format!(
+ "{}{}Your contract's code is ready. You can find it here:\n{}",
+ size_diff,
+ build_mode,
+ self.dest_wasm
+ .as_ref()
+ .expect("wasm path must exist")
+ .display()
+ .to_string()
+ .bold()
+ );
+ return out;
+ };
+
+ let mut out = format!(
+ "{}{}Your contract artifacts are ready. You can find them in:\n{}\n\n",
+ size_diff,
+ build_mode,
+ self.target_directory.display().to_string().bold(),
+ );
+ if let Some(metadata_result) = self.metadata_result.as_ref() {
+ let bundle = format!(
+ " - {} (code + metadata)\n",
+ util::base_name(&metadata_result.dest_bundle).bold()
+ );
+ out.push_str(&bundle);
+ }
+ if let Some(dest_wasm) = self.dest_wasm.as_ref() {
+ let wasm = format!(
+ " - {} (the contract's code)\n",
+ util::base_name(dest_wasm).bold()
+ );
+ out.push_str(&wasm);
+ }
+ if let Some(metadata_result) = self.metadata_result.as_ref() {
+ let metadata = format!(
+ " - {} (the contract's metadata)",
+ util::base_name(&metadata_result.dest_metadata).bold()
+ );
+ out.push_str(&metadata);
+ }
+ out
+ }
+
+ /// Returns a tuple of `(original_size, optimized_size)`.
+ ///
+ /// Panics if no optimization result is available.
+ fn display_optimization(&self) -> (f64, f64) {
+ let optimization = self
+ .optimization_result
+ .as_ref()
+ .expect("optimization result must exist");
+ (optimization.original_size, optimization.optimized_size)
+ }
+
+ /// Display the build results in a pretty formatted JSON string.
+ pub fn serialize_json(&self) -> Result {
+ Ok(serde_json::to_string_pretty(self)?)
+ }
+}
+
#[derive(Debug, StructOpt)]
enum Command {
/// Setup and create a new smart contract project
@@ -166,8 +450,9 @@ enum Command {
#[structopt(short, long, parse(from_os_str))]
target_dir: Option,
},
- /// Compiles the smart contract
+ /// Compiles the contract, generates metadata, bundles both together in a `.contract` file
#[structopt(name = "build")]
+<<<<<<< HEAD
Build {
#[structopt(flatten)]
verbosity: VerbosityFlags,
@@ -190,16 +475,22 @@ enum Command {
#[structopt(flatten)]
unstable_options: UnstableOptions,
},
+=======
+ Build(BuildCommand),
+ /// Check that the code builds as Wasm; does not output any `.contract` artifact to the `target/` directory
+ #[structopt(name = "check")]
+ Check(CheckCommand),
+>>>>>>> 8e86572b4b4ed2442de131c8e3506dee219fb0b7
/// Test the smart contract off-chain
#[structopt(name = "test")]
- Test {},
+ Test(TestCommand),
/// Upload the smart contract code to the chain
#[cfg(feature = "extrinsics")]
#[structopt(name = "deploy")]
Deploy {
#[structopt(flatten)]
extrinsic_opts: ExtrinsicOpts,
- /// Path to wasm contract code, defaults to ./target/-pruned.wasm
+ /// Path to wasm contract code, defaults to `./target/ink/.wasm`
#[structopt(parse(from_os_str))]
wasm_path: Option,
},
@@ -323,33 +614,37 @@ fn main() {
let Opts::Contract(args) = Opts::from_args();
match exec(args.cmd) {
- Ok(msg) => println!("\t{}", msg),
- Err(err) => eprintln!(
- "{} {}",
- "ERROR:".bright_red().bold(),
- format!("{:?}", err).bright_red()
- ),
+ Ok(maybe_msg) => {
+ if let Some(msg) = maybe_msg {
+ println!("\t{}", msg)
+ }
+ }
+ Err(err) => {
+ eprintln!(
+ "{} {}",
+ "ERROR:".bright_red().bold(),
+ format!("{:?}", err).bright_red()
+ );
+ std::process::exit(1);
+ }
}
}
-fn exec(cmd: Command) -> Result {
+fn exec(cmd: Command) -> Result> {
match &cmd {
Command::New { name, target_dir } => cmd::new::execute(name, target_dir.as_ref()),
- Command::Build {
- verbosity,
- unstable_options,
- } => {
- let manifest_path = Default::default();
- let dest_wasm = cmd::build::execute(
- &manifest_path,
- verbosity.try_into()?,
- unstable_options.try_into()?,
- )?;
- Ok(format!(
- "\nYour contract is ready. You can find it here:\n{}",
- dest_wasm.display().to_string().bold()
- ))
+ Command::Build(build) => {
+ let result = build.exec()?;
+
+ if matches!(result.output_type, OutputType::Json) {
+ Ok(Some(result.serialize_json()?))
+ } else if result.verbosity.is_verbose() {
+ Ok(Some(result.display()))
+ } else {
+ Ok(None)
+ }
}
+<<<<<<< HEAD
Command::ComposableBuild {
verbosity,
unstable_options,
@@ -378,15 +673,37 @@ fn exec(cmd: Command) -> Result {
"Your metadata file is ready.\nYou can find it here:\n{}",
metadata_file.display()
))
+=======
+ Command::Check(check) => {
+ let res = check.exec()?;
+ assert!(
+ res.dest_wasm.is_none(),
+ "no dest_wasm must be on the generation result"
+ );
+ if res.verbosity.is_verbose() {
+ Ok(Some(
+ "\nYour contract's code was built successfully.".to_string(),
+ ))
+ } else {
+ Ok(None)
+ }
+ }
+ Command::Test(test) => {
+ let res = test.exec()?;
+ if res.verbosity.is_verbose() {
+ Ok(Some(res.display()?))
+ } else {
+ Ok(None)
+ }
+>>>>>>> 8e86572b4b4ed2442de131c8e3506dee219fb0b7
}
- Command::Test {} => Err(anyhow::anyhow!("Command unimplemented")),
#[cfg(feature = "extrinsics")]
Command::Deploy {
extrinsic_opts,
wasm_path,
} => {
let code_hash = cmd::execute_deploy(extrinsic_opts, wasm_path.as_ref())?;
- Ok(format!("Code hash: {:?}", code_hash))
+ Ok(Some(format!("Code hash: {:?}", code_hash)))
}
#[cfg(feature = "extrinsics")]
Command::ComposableDeploy { suri } => {
@@ -447,7 +764,7 @@ fn exec(cmd: Command) -> Result {
*code_hash,
data.clone(),
)?;
- Ok(format!("Contract account: {:?}", contract_account))
+ Ok(Some(format!("Contract account: {:?}", contract_account)))
}
#[cfg(feature = "extrinsics")]
Command::CallRuntimeGateway {
@@ -541,3 +858,54 @@ fn exec(cmd: Command) -> Result {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn build_result_seralization_sanity_check() {
+ // given
+ let raw_result = r#"{
+ "dest_wasm": "/path/to/contract.wasm",
+ "metadata_result": {
+ "dest_metadata": "/path/to/metadata.json",
+ "dest_bundle": "/path/to/contract.contract"
+ },
+ "target_directory": "/path/to/target",
+ "optimization_result": {
+ "dest_wasm": "/path/to/contract.wasm",
+ "original_size": 64.0,
+ "optimized_size": 32.0
+ },
+ "build_mode": "Debug",
+ "build_artifact": "All",
+ "verbosity": "Quiet"
+}"#;
+
+ let build_result = crate::BuildResult {
+ dest_wasm: Some(PathBuf::from("/path/to/contract.wasm")),
+ metadata_result: Some(crate::cmd::metadata::MetadataResult {
+ dest_metadata: PathBuf::from("/path/to/metadata.json"),
+ dest_bundle: PathBuf::from("/path/to/contract.contract"),
+ }),
+ target_directory: PathBuf::from("/path/to/target"),
+ optimization_result: Some(crate::OptimizationResult {
+ dest_wasm: PathBuf::from("/path/to/contract.wasm"),
+ original_size: 64.0,
+ optimized_size: 32.0,
+ }),
+ build_mode: Default::default(),
+ build_artifact: Default::default(),
+ verbosity: Verbosity::Quiet,
+ output_type: OutputType::Json,
+ };
+
+ // when
+ let serialized_result = build_result.serialize_json();
+
+ // then
+ assert!(serialized_result.is_ok());
+ assert_eq!(serialized_result.unwrap(), raw_result);
+ }
+}
diff --git a/src/util.rs b/src/util.rs
index 84b2b8948..9d6e70211 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -42,14 +42,14 @@ pub(crate) fn invoke_cargo(
command: &str,
args: I,
working_dir: Option,
- verbosity: Option,
+ verbosity: Verbosity,
) -> Result>
where
I: IntoIterator- + std::fmt::Debug,
S: AsRef,
P: AsRef,
{
- let cargo = std::env::var("CARGO").unwrap_or("cargo".to_string());
+ let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
let mut cmd = Command::new(cargo);
if let Some(path) = working_dir {
log::debug!("Setting cargo working dir to '{}'", path.as_ref().display());
@@ -59,12 +59,12 @@ where
cmd.arg(command);
cmd.args(args);
match verbosity {
- Some(Verbosity::Quiet) => cmd.arg("--quiet"),
- Some(Verbosity::Verbose) => cmd.arg("--verbose"),
- None => &mut cmd,
+ Verbosity::Quiet => cmd.arg("--quiet"),
+ Verbosity::Verbose => cmd.arg("--verbose"),
+ Verbosity::Default => &mut cmd,
};
- log::info!("invoking cargo: {:?}", cmd);
+ log::info!("Invoking cargo: {:?}", cmd);
let child = cmd
// capture the stdout to return from this function as bytes
@@ -84,10 +84,32 @@ where
}
}
+/// Returns the base name of the path.
+pub(crate) fn base_name(path: &Path) -> &str {
+ path.file_name()
+ .expect("file name must exist")
+ .to_str()
+ .expect("must be valid utf-8")
+}
+
+/// Prints to stdout if `verbosity.is_verbose()` is `true`.
+#[macro_export]
+macro_rules! maybe_println {
+ ($verbosity:expr, $($msg:tt)*) => {
+ if $verbosity.is_verbose() {
+ println!($($msg)*);
+ }
+ };
+}
+
#[cfg(test)]
pub mod tests {
+ use crate::ManifestPath;
use std::path::Path;
+ use std::sync::atomic::{AtomicU32, Ordering};
+ /// Creates a temporary directory and passes the `tmp_dir` path to `f`.
+ /// Panics if `f` returns an `Err`.
pub fn with_tmp_dir(f: F)
where
F: FnOnce(&Path) -> anyhow::Result<()>,
@@ -98,6 +120,44 @@ pub mod tests {
.expect("temporary directory creation failed");
// catch test panics in order to clean up temp dir which will be very large
- f(tmp_dir.path()).expect("Error executing test with tmp dir")
+ f(&tmp_dir.path().canonicalize().unwrap()).expect("Error executing test with tmp dir")
+ }
+
+ /// Global counter to generate unique contract names in `with_new_contract_project`.
+ ///
+ /// We typically use `with_tmp_dir` to generate temporary folders to build contracts
+ /// in. But for caching purposes our CI uses `CARGO_TARGET_DIR` to overwrite the
+ /// target directory of any contract build -- it is set to a fixed cache directory
+ /// instead.
+ /// This poses a problem since we still want to ensure that each test builds to its
+ /// own, unique target directory -- without interfering with the target directory of
+ /// other tests. In the past this has been a problem when a test tried to create a
+ /// contract with the same contract name as another test -- both were then build
+ /// into the same target directory, sometimes causing test failures for strange reasons.
+ ///
+ /// The fix we decided on is to append a unique number to each contract name which
+ /// is created. This `COUNTER` provides a global counter which is accessed by each test
+ /// (in each thread) to get the current `COUNTER` number and increase it afterwards.
+ ///
+ /// We decided to go for this counter instead of hashing (with e.g. the temp dir) to
+ /// prevent an infinite number of contract artifacts being created in the cache directory.
+ static COUNTER: AtomicU32 = AtomicU32::new(0);
+
+ /// Creates a new contract into a temporary directory. The contract's
+ /// `ManifestPath` is passed into `f`.
+ pub fn with_new_contract_project(f: F)
+ where
+ F: FnOnce(ManifestPath) -> anyhow::Result<()>,
+ {
+ with_tmp_dir(|tmp_dir| {
+ let unique_name = format!("new_project_{}", COUNTER.fetch_add(1, Ordering::SeqCst));
+
+ crate::cmd::new::execute(&unique_name, Some(tmp_dir))
+ .expect("new project creation failed");
+ let working_dir = tmp_dir.join(unique_name);
+ let manifest_path = ManifestPath::new(working_dir.join("Cargo.toml"))?;
+
+ f(manifest_path)
+ })
}
}
diff --git a/src/validate_wasm.rs b/src/validate_wasm.rs
new file mode 100644
index 000000000..daec2eabf
--- /dev/null
+++ b/src/validate_wasm.rs
@@ -0,0 +1,323 @@
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
+// This file is part of cargo-contract.
+//
+// cargo-contract is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// cargo-contract is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with cargo-contract. If not, see .
+
+use anyhow::Result;
+use colored::Colorize;
+use impl_serde::serialize as serde_hex;
+use parity_wasm::elements::Module;
+
+/// Marker inserted by the ink! codegen for an error which can't
+/// be checked at compile time.
+const INK_ENFORCE_ERR: &str = "__ink_enforce_error_";
+
+/// Errors which may occur when forwarding a call is not allowed.
+///
+/// We insert markers for these errors in the generated contract code.
+/// This is necessary since we can't check these errors at compile time
+/// of the contract.
+/// `cargo-contract` checks the contract code for these error markers
+/// when building a contract and fails if it finds markers.
+///
+/// # Important Note
+///
+/// This is a copy of the equivalent type in ink!, which currently resides
+/// [here](https://github.com/paritytech/ink/blob/master/crates/lang/codegen/src/generator/cross_calling.rs).
+/// This type must be compatible with the ink! version in order to decode
+/// the error encoded in the marker.
+#[derive(codec::Encode, codec::Decode)]
+pub enum EnforcedErrors {
+ /// The below error represents calling a `&mut self` message in a context that
+ /// only allows for `&self` messages. This may happen under certain circumstances
+ /// when ink! trait implementations are involved with long-hand calling notation.
+ #[codec(index = 1)]
+ CannotCallTraitMessage {
+ /// The trait that defines the called message.
+ trait_ident: String,
+ /// The name of the called message.
+ message_ident: String,
+ /// The selector of the called message.
+ message_selector: [u8; 4],
+ /// Is `true` if the `self` receiver of the ink! message is `&mut self`.
+ message_mut: bool,
+ },
+ /// The below error represents calling a constructor in a context that does
+ /// not allow calling it. This may happen when the constructor defined in a
+ /// trait is cross-called in another contract.
+ /// This is not allowed since the contract to which a call is forwarded must
+ /// already exist at the point when the call to it is made.
+ #[codec(index = 2)]
+ CannotCallTraitConstructor {
+ /// The trait that defines the called constructor.
+ trait_ident: String,
+ /// The name of the called constructor.
+ constructor_ident: String,
+ /// The selector of the called constructor.
+ constructor_selector: [u8; 4],
+ },
+}
+
+/// Validates the import section in the Wasm.
+///
+/// The checks currently fall into two categories:
+/// - Known bugs for which we want to recommend a solution.
+/// - Markers inserted by the ink! codegen for errors which can't be checked at compile time.
+pub fn validate_import_section(module: &Module) -> Result<()> {
+ let imports = match module.import_section() {
+ Some(section) => section.entries().iter(),
+ None => {
+ // the module does not contain any imports,
+ // hence no further validation is necessary.
+ return Ok(());
+ }
+ };
+ let original_imports_len = imports.len();
+ let mut errs = Vec::new();
+
+ let filtered_imports = imports.filter(|section| {
+ let field = section.field();
+ if field.contains("panic") {
+ errs.push(String::from(
+ "An unexpected panic function import was found in the contract Wasm.\n\
+ This typically goes back to a known bug in the Rust compiler:\n\
+ https://github.com/rust-lang/rust/issues/78744\n\n\
+ As a workaround try to insert `overflow-checks = false` into your `Cargo.toml`.\n\
+ This will disable safe math operations, but unfortunately we are currently not \n\
+ aware of a better workaround until the bug in the compiler is fixed.",
+ ));
+ } else if field.starts_with(INK_ENFORCE_ERR) {
+ errs.push(parse_linker_error(field));
+ }
+
+ match check_import(field) {
+ Ok(_) => true,
+ Err(err) => {
+ errs.push(err);
+ false
+ }
+ }
+ });
+
+ if original_imports_len != filtered_imports.count() {
+ anyhow::bail!(format!(
+ "Validation of the Wasm failed.\n\n\n{}",
+ errs.into_iter()
+ .map(|err| format!("{} {}", "ERROR:".to_string().bold(), err))
+ .collect::>()
+ .join("\n\n\n")
+ ));
+ }
+ Ok(())
+}
+
+/// Returns `true` if the import is allowed.
+fn check_import(field: &str) -> Result<(), String> {
+ let allowed_prefixes = ["seal", "memory"];
+ if allowed_prefixes
+ .iter()
+ .any(|prefix| field.starts_with(prefix))
+ {
+ Ok(())
+ } else {
+ let msg = format!(
+ "An unexpected import function was found in the contract Wasm: {}.\n\
+ The only allowed import functions are those starting with one of the following prefixes:\n\
+ {}", field, allowed_prefixes.join(", ")
+ );
+ Err(msg)
+ }
+}
+
+/// Extracts the ink! linker error marker from the `field`, parses it, and
+/// returns a human readable error message for it.
+fn parse_linker_error(field: &str) -> String {
+ let encoded = field
+ .strip_prefix(INK_ENFORCE_ERR)
+ .expect("error marker must exist as prefix");
+ let hex = serde_hex::from_hex(encoded).expect("decoding hex failed");
+ let decoded = ::decode(&mut &hex[..]).expect(
+ "The `EnforcedError` object could not be decoded. The probable\
+ cause is a mismatch between the ink! definition of the type and the\
+ local `cargo-contract` definition.",
+ );
+
+ match decoded {
+ EnforcedErrors::CannotCallTraitMessage {
+ trait_ident,
+ message_ident,
+ message_selector,
+ message_mut,
+ } => {
+ let receiver = match message_mut {
+ true => "&mut self",
+ false => "&self",
+ };
+ format!(
+ "An error was found while compiling the contract:\n\
+ The ink! message `{}::{}` with the selector `{}` contains an invalid trait call.\n\n\
+ Please check if the receiver of the function to call is consistent\n\
+ with the scope in which it is called. The receiver is `{}`.",
+ trait_ident,
+ message_ident,
+ serde_hex::to_hex(&codec::Encode::encode(&message_selector), false),
+ receiver
+ )
+ }
+ EnforcedErrors::CannotCallTraitConstructor {
+ trait_ident,
+ constructor_ident,
+ constructor_selector,
+ } => {
+ format!(
+ "An error was found while compiling the contract:\n\
+ The ink! constructor `{}::{}` with the selector `{}` contains an invalid trait call.\n\
+ Constructor never need to be forwarded, please check if this is the case.",
+ trait_ident,
+ constructor_ident,
+ serde_hex::to_hex(&codec::Encode::encode(&constructor_selector), false)
+ )
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::validate_import_section;
+ use parity_wasm::elements::Module;
+
+ fn create_module(contract: &str) -> Module {
+ let wasm = wabt::wat2wasm(contract).expect("invalid wabt");
+ parity_wasm::deserialize_buffer(&wasm).expect("deserializing must work")
+ }
+
+ #[test]
+ fn must_catch_panic_import() {
+ // given
+ let contract = r#"
+ (module
+ (type (;0;) (func (param i32 i32 i32)))
+ (import "env" "_ZN4core9panicking5panic17h00e3acdd8048cb7cE" (func (;5;) (type 0)))
+ (func (;5;) (type 0))
+ )"#;
+ let module = create_module(contract);
+
+ // when
+ let res = validate_import_section(&module);
+
+ // then
+ assert!(res.is_err());
+ assert!(res
+ .unwrap_err()
+ .to_string()
+ .contains("An unexpected panic function import was found in the contract Wasm."));
+ }
+
+ #[test]
+ fn must_catch_ink_enforce_error_marker_message() {
+ // given
+ let contract = r#"
+ (module
+ (type (;0;) (func))
+ (import "env" "__ink_enforce_error_0x0110466c697010666c6970aa97cade01" (func $__ink_enforce_error_0x0110466c697010666c6970aa97cade01 (type 0)))
+ )"#;
+ let wasm = wabt::wat2wasm(contract).expect("invalid wabt");
+ let module = parity_wasm::deserialize_buffer(&wasm).expect("deserializing must work");
+
+ // when
+ let res = validate_import_section(&module);
+
+ // then
+ assert!(res.is_err());
+ let err = res.unwrap_err().to_string();
+ assert!(err.contains(
+ "The ink! message `Flip::flip` with the selector `0xaa97cade` contains an invalid trait call."
+ ));
+ assert!(err.contains("The receiver is `&mut self`.",));
+ }
+
+ #[test]
+ fn must_catch_ink_enforce_error_marker_constructor() {
+ // given
+ let contract = r#"
+ (module
+ (type (;0;) (func))
+ (import "env" "__ink_enforce_error_0x0210466c69700c6e657740d75d74" (func $__ink_enforce_error_0x0210466c69700c6e657740d75d74 (type 0)))
+ )"#;
+ let module = create_module(contract);
+
+ // when
+ let res = validate_import_section(&module);
+
+ // then
+ assert!(res.is_err());
+ assert!(res.unwrap_err().to_string().contains(
+ "The ink! constructor `Flip::new` with the selector `0x40d75d74` contains an invalid trait call."
+ ));
+ }
+
+ #[test]
+ fn must_catch_invalid_import() {
+ // given
+ let contract = r#"
+ (module
+ (type (;0;) (func (param i32 i32 i32)))
+ (import "env" "some_fn" (func (;5;) (type 0)))
+ (func (;5;) (type 0))
+ )"#;
+ let module = create_module(contract);
+
+ // when
+ let res = validate_import_section(&module);
+
+ // then
+ assert!(res.is_err());
+ assert!(res
+ .unwrap_err()
+ .to_string()
+ .contains("An unexpected import function was found in the contract Wasm: some_fn."));
+ }
+
+ #[test]
+ fn must_validate_successfully() {
+ // given
+ let contract = r#"
+ (module
+ (type (;0;) (func (param i32 i32 i32)))
+ (import "env" "seal_foo" (func (;5;) (type 0)))
+ (import "env" "memory" (func (;5;) (type 0)))
+ (func (;5;) (type 0))
+ )"#;
+ let module = create_module(contract);
+
+ // when
+ let res = validate_import_section(&module);
+
+ // then
+ assert!(res.is_ok());
+ }
+
+ #[test]
+ fn must_validate_successfully_if_no_import_section_found() {
+ // given
+ let contract = r#"(module)"#;
+ let module = create_module(contract);
+
+ // when
+ let res = validate_import_section(&module);
+
+ // then
+ assert!(res.is_ok());
+ }
+}
diff --git a/src/workspace/manifest.rs b/src/workspace/manifest.rs
index b96a8b67c..24f47c036 100644
--- a/src/workspace/manifest.rs
+++ b/src/workspace/manifest.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -17,9 +17,11 @@
use anyhow::{Context, Result};
use super::{metadata, Profile};
-use std::convert::{TryFrom, TryInto};
+use crate::OptimizationPasses;
+
use std::{
collections::HashSet,
+ convert::TryFrom,
fs,
path::{Path, PathBuf},
};
@@ -66,13 +68,25 @@ impl ManifestPath {
None
}
}
+
+ /// Returns the absolute directory path of the manifest.
+ pub fn absolute_directory(&self) -> Result {
+ let directory = match self.directory() {
+ Some(dir) => dir,
+ None => Path::new("./"),
+ };
+ directory.canonicalize()
+ }
}
-impl TryFrom<&PathBuf> for ManifestPath {
+impl
TryFrom> for ManifestPath
+where
+ P: AsRef,
+{
type Error = anyhow::Error;
- fn try_from(value: &PathBuf) -> Result {
- ManifestPath::new(value)
+ fn try_from(value: Option) -> Result {
+ value.map_or(Ok(Default::default()), ManifestPath::new)
}
}
@@ -88,6 +102,12 @@ impl AsRef for ManifestPath {
}
}
+impl From for PathBuf {
+ fn from(path: ManifestPath) -> Self {
+ path.path
+ }
+}
+
/// Create, amend and save a copy of the specified `Cargo.toml`.
pub struct Manifest {
path: ManifestPath,
@@ -100,11 +120,7 @@ impl Manifest {
/// Create new Manifest for the given manifest path.
///
/// The path *must* be to a `Cargo.toml`.
- pub fn new(path: P) -> Result
- where
- P: TryInto,
- {
- let manifest_path = path.try_into()?;
+ pub fn new(manifest_path: ManifestPath) -> Result {
let toml = fs::read_to_string(&manifest_path).context("Loading Cargo.toml")?;
let toml: value::Table = toml::from_str(&toml)?;
@@ -125,14 +141,14 @@ impl Manifest {
let lib = self
.toml
.get_mut("lib")
- .ok_or(anyhow::anyhow!("lib section not found"))?;
+ .ok_or_else(|| anyhow::anyhow!("lib section not found"))?;
let crate_types = lib
.get_mut("crate-type")
- .ok_or(anyhow::anyhow!("crate-type section not found"))?;
+ .ok_or_else(|| anyhow::anyhow!("crate-type section not found"))?;
crate_types
.as_array_mut()
- .ok_or(anyhow::anyhow!("crate-types should be an Array"))
+ .ok_or_else(|| anyhow::anyhow!("crate-types should be an Array"))
}
/// Add a value to the `[lib] crate-types = []` section.
@@ -146,6 +162,105 @@ impl Manifest {
Ok(self)
}
+ /// Extract `optimization-passes` from `[package.metadata.contract]`
+ pub fn get_profile_optimization_passes(&mut self) -> Option {
+ self.toml
+ .get("package")?
+ .as_table()?
+ .get("metadata")?
+ .as_table()?
+ .get("contract")?
+ .as_table()?
+ .get("optimization-passes")
+ .map(|val| val.to_string())
+ .map(Into::into)
+ }
+
+ /// Set `optimization-passes` in `[package.metadata.contract]`
+ #[cfg(feature = "test-ci-only")]
+ #[cfg(test)]
+ pub fn set_profile_optimization_passes(
+ &mut self,
+ passes: OptimizationPasses,
+ ) -> Result> {
+ Ok(self
+ .toml
+ .entry("package")
+ .or_insert(value::Value::Table(Default::default()))
+ .as_table_mut()
+ .context("package section should be a table")?
+ .entry("metadata")
+ .or_insert(value::Value::Table(Default::default()))
+ .as_table_mut()
+ .context("metadata section should be a table")?
+ .entry("contract")
+ .or_insert(value::Value::Table(Default::default()))
+ .as_table_mut()
+ .context("metadata.contract section should be a table")?
+ .insert(
+ "optimization-passes".to_string(),
+ value::Value::String(passes.to_string()),
+ ))
+ }
+
+ /// Set the dependency version of `package` to `version`.
+ #[cfg(feature = "test-ci-only")]
+ #[cfg(test)]
+ pub fn set_dependency_version(
+ &mut self,
+ dependency: &str,
+ version: &str,
+ ) -> Result> {
+ Ok(self
+ .toml
+ .get_mut("dependencies")
+ .ok_or_else(|| anyhow::anyhow!("[dependencies] section not found"))?
+ .get_mut(dependency)
+ .ok_or_else(|| anyhow::anyhow!("{} dependency not found", dependency))?
+ .as_table_mut()
+ .ok_or_else(|| anyhow::anyhow!("{} dependency should be a table", dependency))?
+ .insert("version".into(), value::Value::String(version.into())))
+ }
+
+ /// Set the `lib` name to `name`.
+ #[cfg(feature = "test-ci-only")]
+ #[cfg(test)]
+ pub fn set_lib_name(&mut self, name: &str) -> Result> {
+ Ok(self
+ .toml
+ .get_mut("lib")
+ .ok_or_else(|| anyhow::anyhow!("[lib] section not found"))?
+ .as_table_mut()
+ .ok_or_else(|| anyhow::anyhow!("[lib] should be a table"))?
+ .insert("name".into(), value::Value::String(name.into())))
+ }
+
+ /// Set the `package` name to `name`.
+ #[cfg(feature = "test-ci-only")]
+ #[cfg(test)]
+ pub fn set_package_name(&mut self, name: &str) -> Result> {
+ Ok(self
+ .toml
+ .get_mut("package")
+ .ok_or_else(|| anyhow::anyhow!("[package] section not found"))?
+ .as_table_mut()
+ .ok_or_else(|| anyhow::anyhow!("[package] should be a table"))?
+ .insert("name".into(), value::Value::String(name.into())))
+ }
+
+ /// Set the `lib` path to `path`.
+ #[cfg(feature = "test-ci-only")]
+ #[cfg(test)]
+ pub fn set_lib_path(&mut self, path: &str) -> Result> {
+ Ok(self
+ .toml
+ .get_mut("lib")
+ .ok_or_else(|| anyhow::anyhow!("[lib] section not found"))?
+ .as_table_mut()
+ .ok_or_else(|| anyhow::anyhow!("[lib] should be a table"))?
+ .insert("path".into(), value::Value::String(path.into())))
+ }
+
/// Set `[profile.release]` lto flag
pub fn with_profile_release_lto(&mut self, enabled: bool) -> Result<&mut Self> {
let lto = self
@@ -176,12 +291,12 @@ impl Manifest {
.or_insert(value::Value::Table(Default::default()));
let release = profile
.as_table_mut()
- .ok_or(anyhow::anyhow!("profile should be a table"))?
+ .ok_or_else(|| anyhow::anyhow!("profile should be a table"))?
.entry("release")
.or_insert(value::Value::Table(Default::default()));
release
.as_table_mut()
- .ok_or(anyhow::anyhow!("release should be a table"))
+ .ok_or_else(|| anyhow::anyhow!("release should be a table"))
}
/// Remove a value from the `[lib] crate-types = []` section
@@ -203,16 +318,16 @@ impl Manifest {
.or_insert(value::Value::Table(Default::default()));
let members = workspace
.as_table_mut()
- .ok_or(anyhow::anyhow!("workspace should be a table"))?
+ .ok_or_else(|| anyhow::anyhow!("workspace should be a table"))?
.entry("members")
.or_insert(value::Value::Array(Default::default()))
.as_array_mut()
- .ok_or(anyhow::anyhow!("members should be an array"))?;
+ .ok_or_else(|| anyhow::anyhow!("members should be an array"))?;
if members.contains(&LEGACY_METADATA_PACKAGE_PATH.into()) {
// warn user if they have legacy metadata generation artifacts
use colored::Colorize;
- println!(
+ eprintln!(
"{} {} {} {}",
"warning:".yellow().bold(),
"please remove".bold(),
@@ -252,7 +367,11 @@ impl Manifest {
let to_absolute = |value_id: String, existing_path: &mut value::Value| -> Result<()> {
let path_str = existing_path
.as_str()
- .ok_or(anyhow::anyhow!("{} should be a string", value_id))?;
+ .ok_or_else(|| anyhow::anyhow!("{} should be a string", value_id))?;
+ #[cfg(windows)]
+ // On Windows path separators are `\`, hence we need to replace the `/` in
+ // e.g. `src/lib.rs`.
+ let path_str = &path_str.replace("/", "\\");
let path = PathBuf::from(path_str);
if path.is_relative() {
let lib_abs = abs_dir.join(path);
@@ -263,10 +382,9 @@ impl Manifest {
};
let rewrite_path = |table_value: &mut value::Value, table_section: &str, default: &str| {
- let table = table_value.as_table_mut().ok_or(anyhow::anyhow!(
- "'[{}]' section should be a table",
- table_section
- ))?;
+ let table = table_value.as_table_mut().ok_or_else(|| {
+ anyhow::anyhow!("'[{}]' section should be a table", table_section)
+ })?;
match table.get_mut("path") {
Some(existing_path) => {
@@ -300,7 +418,7 @@ impl Manifest {
if let Some(bin) = self.toml.get_mut("bin") {
let bins = bin
.as_array_mut()
- .ok_or(anyhow::anyhow!("'[[bin]]' section should be a table array"))?;
+ .ok_or_else(|| anyhow::anyhow!("'[[bin]]' section should be a table array"))?;
// Rewrite `[[bin]] path =` value to an absolute path.
for bin in bins {
@@ -316,7 +434,7 @@ impl Manifest {
.collect::>();
let table = dependencies
.as_table_mut()
- .ok_or(anyhow::anyhow!("dependencies should be a table"))?;
+ .ok_or_else(|| anyhow::anyhow!("dependencies should be a table"))?;
for (name, value) in table {
let package_name = {
let package = value.get("package");
@@ -352,25 +470,25 @@ impl Manifest {
fs::create_dir_all(&dir).context(format!("Creating directory '{}'", dir.display()))?;
- let name = self
+ let contract_package_name = self
.toml
- .get("lib")
- .ok_or(anyhow::anyhow!("lib section not found"))?
+ .get("package")
+ .ok_or_else(|| anyhow::anyhow!("package section not found"))?
.get("name")
- .ok_or(anyhow::anyhow!("[lib] name field not found"))?
+ .ok_or_else(|| anyhow::anyhow!("[package] name field not found"))?
.as_str()
- .ok_or(anyhow::anyhow!("[lib] name should be a string"))?;
+ .ok_or_else(|| anyhow::anyhow!("[package] name should be a string"))?;
let ink_metadata = self
.toml
.get("dependencies")
- .ok_or(anyhow::anyhow!("[dependencies] section not found"))?
+ .ok_or_else(|| anyhow::anyhow!("[dependencies] section not found"))?
.get("ink_metadata")
- .ok_or(anyhow::anyhow!("{} dependency not found", name))?
+ .ok_or_else(|| anyhow::anyhow!("ink_metadata dependency not found"))?
.as_table()
- .ok_or(anyhow::anyhow!("{} dependency should be a table", name))?;
+ .ok_or_else(|| anyhow::anyhow!("ink_metadata dependency should be a table"))?;
- metadata::generate_package(dir, name, ink_metadata.clone())?;
+ metadata::generate_package(dir, contract_package_name, ink_metadata.clone())?;
}
let updated_toml = toml::to_string(&self.toml)?;
@@ -383,8 +501,35 @@ impl Manifest {
}
}
-fn crate_type_exists(crate_type: &str, crate_types: &value::Array) -> bool {
+fn crate_type_exists(crate_type: &str, crate_types: &[value::Value]) -> bool {
crate_types
.iter()
.any(|v| v.as_str().map_or(false, |s| s == crate_type))
}
+
+#[cfg(test)]
+mod test {
+ use super::ManifestPath;
+ use crate::util::tests::with_tmp_dir;
+ use std::fs;
+
+ #[test]
+ fn must_return_absolute_path_from_absolute_path() {
+ with_tmp_dir(|path| {
+ // given
+ let cargo_toml_path = path.join("Cargo.toml");
+ let _ = fs::File::create(&cargo_toml_path).expect("file creation failed");
+ let manifest_path =
+ ManifestPath::new(cargo_toml_path).expect("manifest path creation failed");
+
+ // when
+ let absolute_path = manifest_path
+ .absolute_directory()
+ .expect("absolute path extraction failed");
+
+ // then
+ assert_eq!(absolute_path.as_path(), path);
+ Ok(())
+ })
+ }
+}
diff --git a/src/workspace/metadata.rs b/src/workspace/metadata.rs
index 0f82bf3ad..76d356eca 100644
--- a/src/workspace/metadata.rs
+++ b/src/workspace/metadata.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
diff --git a/src/workspace/mod.rs b/src/workspace/mod.rs
index 6489a126e..733e8700f 100644
--- a/src/workspace/mod.rs
+++ b/src/workspace/mod.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -52,11 +52,14 @@ impl Workspace {
.packages
.iter()
.find(|p| p.id == *package_id)
- .expect(&format!(
- "Package '{}' is a member and should be in the packages list",
- package_id
- ));
- let manifest = Manifest::new(&package.manifest_path)?;
+ .unwrap_or_else(|| {
+ panic!(
+ "Package '{}' is a member and should be in the packages list",
+ package_id
+ )
+ });
+ let manifest_path = ManifestPath::new(&package.manifest_path)?;
+ let manifest = Manifest::new(manifest_path)?;
Ok((package_id.clone(), (package.clone(), manifest)))
};
@@ -71,7 +74,7 @@ impl Workspace {
}
Ok(Workspace {
- workspace_root: metadata.workspace_root.clone(),
+ workspace_root: metadata.workspace_root.clone().into(),
root_package: root_package.clone(),
members,
})
@@ -96,32 +99,43 @@ impl Workspace {
Ok(self)
}
- /// Amend the workspace manifest using the supplied function.
- pub fn with_workspace_manifest(&mut self, f: F) -> Result<&mut Self>
+ /// Amend the manifest of the package at `package_path` using the supplied function.
+ pub fn with_contract_manifest(&mut self, package_path: &Path, f: F) -> Result<&mut Self>
where
F: FnOnce(&mut Manifest) -> Result<()>,
{
- let workspace_root = self.workspace_root.clone();
- let workspace_manifest = self
+ let manifest = self
.members
.iter_mut()
.find_map(|(_, (_, manifest))| {
- if manifest.path().directory() == Some(&workspace_root) {
+ // `package_path` is always absolute and canonicalized. Thus we need to
+ // canonicalize the manifest's directory path as well in order to compare
+ // both of them.
+ let manifest_path = manifest.path().directory()?;
+ let manifest_path = manifest_path
+ .canonicalize()
+ .unwrap_or_else(|_| panic!("Cannot canonicalize {}", manifest_path.display()));
+ if manifest_path == package_path {
Some(manifest)
} else {
None
}
})
- .ok_or(anyhow::anyhow!(
- "The workspace root package should be a workspace member"
- ))?;
- f(workspace_manifest)?;
+ .ok_or_else(|| {
+ anyhow::anyhow!(
+ "Cannot find package with package path {} in workspace members",
+ package_path.display(),
+ )
+ })?;
+ f(manifest)?;
Ok(self)
}
- /// Generates a package to invoke for generating contract metadata
- pub(super) fn with_metadata_gen_package(&mut self) -> Result<&mut Self> {
- self.with_workspace_manifest(|manifest| {
+ /// Generates a package to invoke for generating contract metadata.
+ ///
+ /// The contract metadata will be generated for the package found at `package_path`.
+ pub(super) fn with_metadata_gen_package(&mut self, package_path: PathBuf) -> Result<&mut Self> {
+ self.with_contract_manifest(&package_path, |manifest| {
manifest.with_metadata_package()?;
Ok(())
})
diff --git a/src/workspace/profile.rs b/src/workspace/profile.rs
index cf44fa099..df40e5268 100644
--- a/src/workspace/profile.rs
+++ b/src/workspace/profile.rs
@@ -1,4 +1,4 @@
-// Copyright 2018-2020 Parity Technologies (UK) Ltd.
+// Copyright 2018-2021 Parity Technologies (UK) Ltd.
// This file is part of cargo-contract.
//
// cargo-contract is free software: you can redistribute it and/or modify
@@ -72,7 +72,7 @@ pub enum OptLevel {
}
impl OptLevel {
- fn to_toml_value(&self) -> value::Value {
+ fn to_toml_value(self) -> value::Value {
match self {
OptLevel::NoOptimizations => 0.into(),
OptLevel::O1 => 1.into(),
@@ -99,7 +99,7 @@ pub enum Lto {
}
impl Lto {
- fn to_toml_value(&self) -> value::Value {
+ fn to_toml_value(self) -> value::Value {
match self {
Lto::ThinLocal => false.into(),
Lto::Fat => "fat".into(),
@@ -118,7 +118,7 @@ pub enum PanicStrategy {
}
impl PanicStrategy {
- fn to_toml_value(&self) -> value::Value {
+ fn to_toml_value(self) -> value::Value {
match self {
PanicStrategy::Unwind => "unwind".into(),
PanicStrategy::Abort => "abort".into(),
diff --git a/templates/new/_Cargo.toml b/templates/new/_Cargo.toml
index df71d79d9..341303636 100644
--- a/templates/new/_Cargo.toml
+++ b/templates/new/_Cargo.toml
@@ -3,15 +3,17 @@ name = "{{name}}"
version = "0.1.0"
authors = ["[your_name] <[your_email]>"]
edition = "2018"
+resolver = "2"
[dependencies]
-ink_metadata = { git = "https://github.com/paritytech/ink", branch = "master", package = "ink_metadata", default-features = false, features = ["derive"], optional = true }
-ink_primitives = { git = "https://github.com/paritytech/ink", branch = "master", default-features = false }
-ink_core = { git = "https://github.com/paritytech/ink", branch = "master", package = "ink_core", default-features = false }
-ink_lang = { git = "https://github.com/paritytech/ink", branch = "master", package = "ink_lang", default-features = false }
+ink_primitives = { version = "3.0.0-rc5", default-features = false }
+ink_metadata = { version = "3.0.0-rc5", default-features = false, features = ["derive"], optional = true }
+ink_env = { version = "3.0.0-rc5", default-features = false }
+ink_storage = { version = "3.0.0-rc5", default-features = false }
+ink_lang = { version = "3.0.0-rc5", default-features = false }
-scale = { package = "parity-scale-codec", version = "1.3", default-features = false, features = ["derive"] }
-scale-info = { version = "0.3", default-features = false, features = ["derive"], optional = true }
+scale = { package = "parity-scale-codec", version = "2.1", default-features = false, features = ["derive"] }
+scale-info = { version = "0.6.0", default-features = false, features = ["derive"], optional = true }
[lib]
name = "{{name}}"
@@ -25,7 +27,8 @@ crate-type = [
default = ["std"]
std = [
"ink_metadata/std",
- "ink_core/std",
+ "ink_env/std",
+ "ink_storage/std",
"ink_primitives/std",
"scale/std",
"scale-info/std",
diff --git a/templates/new/lib.rs b/templates/new/lib.rs
index 6c850eab9..45c4c5edd 100644
--- a/templates/new/lib.rs
+++ b/templates/new/lib.rs
@@ -2,14 +2,14 @@
use ink_lang as ink;
-#[ink::contract(version = "0.1.0")]
+#[ink::contract]
mod {{name}} {
/// Defines the storage of your contract.
/// Add new fields to the below struct in order
/// to add new static storage fields to your contract.
#[ink(storage)]
- struct {{camel_name}} {
+ pub struct {{camel_name}} {
/// Stores a single `bool` value on the storage.
value: bool,
}
@@ -17,7 +17,7 @@ mod {{name}} {
impl {{camel_name}} {
/// Constructor that initializes the `bool` value to the given `init_value`.
#[ink(constructor)]
- fn new(init_value: bool) -> Self {
+ pub fn new(init_value: bool) -> Self {
Self { value: init_value }
}
@@ -25,7 +25,7 @@ mod {{name}} {
///
/// Constructors can delegate to other constructors.
#[ink(constructor)]
- fn default() -> Self {
+ pub fn default() -> Self {
Self::new(Default::default())
}
@@ -33,13 +33,13 @@ mod {{name}} {
/// This one flips the value of the stored `bool` from `true`
/// to `false` and vice versa.
#[ink(message)]
- fn flip(&mut self) {
+ pub fn flip(&mut self) {
self.value = !self.value;
}
/// Simply returns the current value of our `bool`.
#[ink(message)]
- fn get(&self) -> bool {
+ pub fn get(&self) -> bool {
self.value
}
}
@@ -52,15 +52,18 @@ mod {{name}} {
/// Imports all the definitions from the outer scope so we can use them here.
use super::*;
+ /// Imports `ink_lang` so we can use `#[ink::test]`.
+ use ink_lang as ink;
+
/// We test if the default constructor does its job.
- #[test]
+ #[ink::test]
fn default_works() {
let {{name}} = {{camel_name}}::default();
assert_eq!({{name}}.get(), false);
}
/// We test a simple use case of our contract.
- #[test]
+ #[ink::test]
fn it_works() {
let mut {{name}} = {{camel_name}}::new(false);
assert_eq!({{name}}.get(), false);
+>>>>>>> 8e86572b4b4ed2442de131c8e3506dee219fb0b7
-[](LICENSE)
-[](https://gitlab.parity.io/parity/cargo-contract/pipelines)
-[](https://crates.io/crates/cargo-contract)
+[![CI Status][a1]][a2]
+[![Matrix Chat][b1]][b2]
+[![Discord Chat][c1]][c2]
+[![Latest Release][d1]][d2]
+[a1]: https://gitlab.parity.io/parity/cargo-contract/badges/master/pipeline.svg
+[a2]: https://gitlab.parity.io/parity/cargo-contract/pipelines
+[b1]: https://img.shields.io/badge/matrix-chat-brightgreen.svg?style=flat
+[b2]: https://riot.im/app/#/room/#ink:matrix.parity.io
+[c1]: https://img.shields.io/discord/722223075629727774?style=flat-square&label=discord
+[c2]: https://discord.gg/ztCASQE
+[d1]: https://img.shields.io/crates/v/cargo-contract.svg
+[d2]: https://crates.io/crates/cargo-contract
+
+
`cargo-contract` is a CLI tool which helps you develop smart contracts in Parity's ink!.