release: 2.0.0 (#66)

* chore: initial migration to rust2018 edition

* test: initial test to green, rust 2018 adjustment

* chore: remove fixes (v2) works with this

* tests(node): refactor node endpoint tests for v26

* ref: introduce common.rs

* ref(test): further split models into struct files

* test: block transactions test

* fix: add request error heuristic

* ref: split models in files

* fix: uses and tests

* test: blocks test new fixtures running

* ref: organized asserts and mockito

* test(delegates): updated models and fixtures

* tests: peer tests operational for v2.6

* tests: transaction test fixtures, adjusting to v2.6

* test: votes updates of fixtures

* test(wallet): test_all operational

* tests: wallet fixtures and tests

* style: cargo fmt run

* ref: style

* style: fmt

* chore: clippy lint

* style: clippy doctest

* ref: better naming of custom deser methog

* ref: remove redundand .clone()

* feat(node): implement `node/fees` endpoint

* style: clippy lint fixes

* chore: changelog info

* fix: remove duplicate struct

* ref: cleanup tests

* ref: add meta tests for blocks

* fix: remove redundand clone()

* test: implement locks and new fixtures

* test: implement wallets/search

* test: unconfirmed transactions `transactions/unconfirmed/**`

* chore: handle status error response from transaction/post

* feat: adjust to different fee api return changes

* style: format json fixtures

* test: asset support and new fixtures added

* style: clippy happy

* test: bridgechain update and resignation assets

* test: fee statistics all values

* ref: split large assert files into separate ones

* ref(tests): reduced fixture data size

* feat: aip103 - initial magistrate implementation

* feat: remove POST payload as Option. Changed post method

* feat(test): added configurable test option for live peer test

* docs: typo in comments

* fix: locks search endpoint

* style: clippy

* test: added random_seed for manual live test option

* test: added node test with optional live peer (serdes)

* fix(test): handle live peer test no network locks scenario

* style: clippy

* feat: updated to latest reqwest and move to async/await as from rust 1.39

* ref: removed api prefixes from client (to handle pagination with res.meta)

* ref: made generic methods public -> for pagination calls

* ref: revert api prefix commit: 28f7bc7

* test: updated business fixtures

* test: businesses endpoints

* test: bridgechains

* test: locks

* test: wallets adjusting to new changes with attributes

* test: fixed voters mock

* chore: removing deprecated trait impl

* chore: change log info

* docs: changelog info added

Co-authored-by: supaiku <1311798+supaiku0@users.noreply.github.com>

Author: Kristjan Kosic

.gitignore

@@ -1,3 +1,5 @@
 /target
 **/*.rs.bk
 Cargo.lock
+/.idea
+

CHANGELOG.md

@@ -5,7 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## Unreleased
+## 2.0.0 - 2020-02-11
+
+### Added
+- Async implementation of API calls 
+- Core 2.6 model update
+- New 2.6 endpoints support
+- Full mock support
+
+### Changed
+- Updated dependencies
+- Refactor/Restructure of internals
 
 ## 1.0.0 - 2018-12-19
 - Initial Release

Cargo.toml

@@ -1,21 +1,26 @@
 [package]
 name = "arkecosystem-client"
-version = "1.0.0"
-authors = ["Joshua Noack <joshua@ark.io>, Juan A. Martín <juan@ark.io>"]
+version = "2.0.0"
+authors = ["Joshua Noack <joshua@ark.io>, Kristjan Kosic <kristjan@ark.io>"]
 description = "A simple Rust API client for the ARK Blockchain."
 license = "MIT"
+edition = "2018"
 
 [lib]
 name = "arkecosystem_client"
 path = "src/lib.rs"
 doctest = false
 
 [dependencies]
-reqwest = "0.9.22"
-serde = "1.0.102"
-serde_derive = "1.0.102"
-serde_json = "1.0.41"
+reqwest = { version = "0.10", features = ["json"] }
+tokio = { version = "0.2", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+serde_derive = "1.0"
+rand = "*"
 
 [dev-dependencies]
-mockito = "0.21.0"
-assert_float_eq = "1.1.3"
+mockito = "0.22.0"
+
+[features]
+network_test = []

src/api/blocks.rs

@@ -1,8 +1,10 @@
-use http::client::Client;
+use crate::http::client::Client;
 use std::borrow::Borrow;
 
-use api::models::{Block, Transaction};
-use api::Result;
+use crate::api::models::block::Block;
+use crate::api::models::transaction::Transaction;
+
+use crate::api::Result;
 
 pub struct Blocks {
     client: Client,
@@ -13,48 +15,55 @@ impl Blocks {
         Blocks { client }
     }
 
-    pub fn all(&self) -> Result<Vec<Block>> {
-        self.all_params(Vec::<(String, String)>::new())
+    pub async fn all(&mut self) -> Result<Vec<Block>> {
+        self.all_params(Vec::<(String, String)>::new()).await
     }
 
-    pub fn all_params<I, K, V>(&self, parameters: I) -> Result<Vec<Block>>
+    pub async fn all_params<I, K, V>(&mut self, parameters: I) -> Result<Vec<Block>>
     where
         I: IntoIterator,
         I::Item: Borrow<(K, V)>,
         K: AsRef<str>,
         V: AsRef<str>,
     {
-        self.client.get_with_params("blocks", parameters)
+        self.client.get_with_params("blocks", parameters).await
     }
 
-    pub fn show(&self, id: &str) -> Result<Block> {
+    pub async fn show(&mut self, id: &str) -> Result<Block> {
         let endpoint = format!("blocks/{}", id);
 
-        self.client.get(&endpoint)
+        self.client.get(&endpoint).await
     }
 
-    pub fn transactions(&self, id: &str) -> Result<Vec<Transaction>> {
+    pub async fn transactions(&mut self, id: &str) -> Result<Vec<Transaction>> {
         self.transactions_params(id, Vec::<(String, String)>::new())
+            .await
     }
 
-    pub fn transactions_params<I, K, V>(&self, id: &str, parameters: I) -> Result<Vec<Transaction>>
+    pub async fn transactions_params<I, K, V>(
+        &mut self,
+        id: &str,
+        parameters: I,
+    ) -> Result<Vec<Transaction>>
     where
         I: IntoIterator,
         I::Item: Borrow<(K, V)>,
         K: AsRef<str>,
         V: AsRef<str>,
     {
         let endpoint = format!("blocks/{}/transactions", id);
-        self.client.get_with_params(&endpoint, parameters)
+        self.client.get_with_params(&endpoint, parameters).await
     }
 
-    pub fn search<I, K, V>(&self, parameters: I) -> Result<Vec<Block>>
+    pub async fn search<I, K, V>(&mut self, parameters: I) -> Result<Vec<Block>>
     where
         I: IntoIterator,
         I::Item: Borrow<(K, V)>,
         K: AsRef<str>,
         V: AsRef<str>,
     {
-        self.client.get_with_params("blocks/search", parameters)
+        self.client
+            .get_with_params("blocks/search", parameters)
+            .await
     }
 }

src/api/bridgechains.rs

@@ -0,0 +1,52 @@
+use crate::api::models::bridgechain::Bridgechain;
+use crate::api::Result;
+use crate::http::client::Client;
+use std::borrow::Borrow;
+use std::collections::HashMap;
+
+pub struct Bridgechains {
+    client: Client,
+}
+
+impl Bridgechains {
+    pub fn new(client: Client) -> Bridgechains {
+        Bridgechains { client }
+    }
+
+    pub async fn all(&mut self) -> Result<Vec<Bridgechain>> {
+        self.all_params(Vec::<(String, String)>::new()).await
+    }
+
+    pub async fn all_params<I, K, V>(&mut self, parameters: I) -> Result<Vec<Bridgechain>>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        self.client
+            .get_with_params("bridgechains", parameters)
+            .await
+    }
+
+    pub async fn show(&mut self, genesis_hash: &str) -> Result<Bridgechain> {
+        let endpoint = format!("bridgechains/{}", genesis_hash);
+        self.client.get(&endpoint).await
+    }
+
+    pub async fn search<I, K, V>(
+        &mut self,
+        payload: HashMap<&str, &str>,
+        parameters: I,
+    ) -> Result<Vec<Bridgechain>>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        self.client
+            .post_with_params("bridgechains/search", payload, parameters)
+            .await
+    }
+}

src/api/businesses.rs

@@ -0,0 +1,71 @@
+use crate::api::models::bridgechain::Bridgechain;
+use crate::api::models::business::Business;
+use crate::api::Result;
+use crate::http::client::Client;
+use std::borrow::Borrow;
+use std::collections::HashMap;
+
+pub struct Businesses {
+    client: Client,
+}
+
+impl Businesses {
+    pub fn new(client: Client) -> Businesses {
+        Businesses { client }
+    }
+
+    pub async fn all(&mut self) -> Result<Vec<Business>> {
+        self.all_params(Vec::<(String, String)>::new()).await
+    }
+
+    pub async fn all_params<I, K, V>(&mut self, parameters: I) -> Result<Vec<Business>>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        self.client.get_with_params("businesses", parameters).await
+    }
+
+    pub async fn show(&mut self, ip_addr: &str) -> Result<Business> {
+        let endpoint = format!("businesses/{}", ip_addr);
+        self.client.get(&endpoint).await
+    }
+
+    pub async fn search<I, K, V>(
+        &mut self,
+        payload: HashMap<&str, &str>,
+        parameters: I,
+    ) -> Result<Vec<Business>>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        self.client
+            .post_with_params("businesses/search", payload, parameters)
+            .await
+    }
+
+    pub async fn bridgechains(&mut self, id: &str) -> Result<Vec<Bridgechain>> {
+        self.bridgechains_params(id, Vec::<(String, String)>::new())
+            .await
+    }
+
+    pub async fn bridgechains_params<I, K, V>(
+        &mut self,
+        id: &str,
+        parameters: I,
+    ) -> Result<Vec<Bridgechain>>
+    where
+        I: IntoIterator,
+        I::Item: Borrow<(K, V)>,
+        K: AsRef<str>,
+        V: AsRef<str>,
+    {
+        let endpoint = format!("businesses/{}/bridgechains", id);
+        self.client.get_with_params(&endpoint, parameters).await
+    }
+}