Rebase master

Author: xgreenx

.github/workflows/ci.yml

@@ -19,6 +19,20 @@ env:
   REGISTRY: ghcr.io
 
 jobs:
+  rustfmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install latest nightly
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: nightly
+          override: true
+          components: rustfmt
+
+      - name: Rustfmt check
+        run: cargo +nightly fmt --all -- --check
+
   lint-toml-files:
     runs-on: ubuntu-latest
     steps:
@@ -75,8 +89,6 @@ jobs:
     strategy:
       matrix:
         include:
-          - command: fmt
-            args: --all --verbose -- --check
           - command: clippy
             args: --all-targets --all-features
           - command: check

.rustfmt.toml

@@ -0,0 +1,64 @@
+max_width = 90 # changed
+hard_tabs = false
+tab_spaces = 4
+newline_style = "Auto"
+use_small_heuristics = "Default"
+indent_style = "Block"
+wrap_comments = false
+format_code_in_doc_comments = false
+comment_width = 80
+normalize_comments = true # changed
+normalize_doc_attributes = false
+format_strings = false
+format_macro_matchers = false
+format_macro_bodies = true
+empty_item_single_line = true
+struct_lit_single_line = true
+fn_single_line = false
+where_single_line = false
+imports_indent = "Block"
+imports_layout = "Vertical" # changed
+imports_granularity = "Crate" # changed
+reorder_imports = true
+reorder_modules = true
+reorder_impl_items = false
+type_punctuation_density = "Wide"
+space_before_colon = false
+space_after_colon = true
+spaces_around_ranges = false
+binop_separator = "Front"
+remove_nested_parens = true
+combine_control_expr = false # changed
+overflow_delimited_expr = false
+struct_field_align_threshold = 0
+enum_discrim_align_threshold = 0
+match_arm_blocks = true
+force_multiline_blocks = true # changed
+fn_args_layout = "Tall"
+brace_style = "SameLineWhere"
+control_brace_style = "AlwaysSameLine"
+trailing_semicolon = false # changed
+trailing_comma = "Vertical"
+match_block_trailing_comma = false
+blank_lines_upper_bound = 1
+blank_lines_lower_bound = 0
+edition = "2021" # changed
+version = "One"
+merge_derives = true
+use_try_shorthand = true # changed
+use_field_init_shorthand = true # changed
+force_explicit_abi = true
+condense_wildcard_suffixes = false
+color = "Auto"
+unstable_features = false
+disable_all_formatting = false
+skip_children = false
+hide_parse_errors = false
+error_on_line_overflow = false
+error_on_unformatted = false
+ignore = []
+
+# Below are `rustfmt` internal settings
+#
+# emit_mode = "Files"
+# make_backup = false

fuel-block-importer/src/service.rs

@@ -1,8 +1,14 @@
 use crate::Config;
-use fuel_core_interfaces::block_importer::{ImportBlockBroadcast, ImportBlockMpsc};
+use fuel_core_interfaces::block_importer::{
+    ImportBlockBroadcast,
+    ImportBlockMpsc,
+};
 use parking_lot::Mutex;
 use tokio::{
-    sync::{broadcast, mpsc},
+    sync::{
+        broadcast,
+        mpsc,
+    },
     task::JoinHandle,
 };
 

fuel-block-producer/src/service.rs

@@ -1,7 +1,13 @@
 use crate::Config;
-use fuel_core_interfaces::{block_producer::BlockProducerMpsc, txpool};
+use fuel_core_interfaces::{
+    block_producer::BlockProducerMpsc,
+    txpool,
+};
 use parking_lot::Mutex;
-use tokio::{sync::mpsc, task::JoinHandle};
+use tokio::{
+    sync::mpsc,
+    task::JoinHandle,
+};
 
 pub struct Service {
     join: Mutex<Option<JoinHandle<()>>>,

fuel-client/build.rs

@@ -1,8 +1,16 @@
-use schemafy_lib::{Expander, Schema};
-use std::env;
-use std::fs::{self, File};
-use std::io::prelude::*;
-use std::path::PathBuf;
+use schemafy_lib::{
+    Expander,
+    Schema,
+};
+use std::{
+    env,
+    fs::{
+        self,
+        File,
+    },
+    io::prelude::*,
+    path::PathBuf,
+};
 
 fn main() {
     println!("cargo:rerun-if-changed=./assets/debugAdapterProtocol.json");
@@ -13,7 +21,8 @@ fn main() {
         .expect("Failed to fetch JSON schema");
 
     let json = fs::read_to_string(&path).expect("Failed to parse JSON from schema");
-    let schema: Schema = serde_json::from_str(&json).expect("Failed to parse Schema from JSON");
+    let schema: Schema =
+        serde_json::from_str(&json).expect("Failed to parse Schema from JSON");
     let root_name = schema.title.clone().unwrap_or_else(|| "Root".to_owned());
 
     let path = path.into_os_string();

fuel-client/src/client.rs

@@ -1,28 +1,71 @@
 use crate::client::schema::contract::ContractBalanceQueryArgs;
 use anyhow::Context;
-use cynic::{http::SurfExt, Id, MutationBuilder, Operation, QueryBuilder};
+use cynic::{
+    http::SurfExt,
+    Id,
+    MutationBuilder,
+    Operation,
+    QueryBuilder,
+};
 use fuel_vm::prelude::*;
 use itertools::Itertools;
 use schema::{
     balance::BalanceArgs,
     block::BlockByIdArgs,
-    coin::{Coin, CoinByIdArgs, SpendQueryElementInput},
-    contract::{Contract, ContractByIdArgs},
-    tx::{TxArg, TxIdArgs},
-    Bytes, ContinueTx, ContinueTxArgs, ConversionError, HexString, IdArg, MemoryArgs, RegisterArgs,
-    RunResult, SetBreakpoint, SetBreakpointArgs, SetSingleStepping, SetSingleSteppingArgs, StartTx,
-    StartTxArgs, TransactionId, U64,
+    coin::{
+        Coin,
+        CoinByIdArgs,
+        SpendQueryElementInput,
+    },
+    contract::{
+        Contract,
+        ContractByIdArgs,
+    },
+    tx::{
+        TxArg,
+        TxIdArgs,
+    },
+    Bytes,
+    ContinueTx,
+    ContinueTxArgs,
+    ConversionError,
+    HexString,
+    IdArg,
+    MemoryArgs,
+    RegisterArgs,
+    RunResult,
+    SetBreakpoint,
+    SetBreakpointArgs,
+    SetSingleStepping,
+    SetSingleSteppingArgs,
+    StartTx,
+    StartTxArgs,
+    TransactionId,
+    U64,
 };
 use std::{
     convert::TryInto,
-    io::{self, ErrorKind},
+    io::{
+        self,
+        ErrorKind,
+    },
     net,
-    str::{self, FromStr},
+    str::{
+        self,
+        FromStr,
+    },
+};
+use types::{
+    TransactionResponse,
+    TransactionStatus,
 };
-use types::{TransactionResponse, TransactionStatus};
 
 use crate::client::schema::tx::DryRunArg;
-pub use schema::{PageDirection, PaginatedResult, PaginationRequest};
+pub use schema::{
+    PageDirection,
+    PaginatedResult,
+    PaginationRequest,
+};
 
 use self::schema::block::ProduceBlockArgs;
 
@@ -175,7 +218,12 @@ impl FuelClient {
         Ok(self.query(query).await?.register.0 as Word)
     }
 
-    pub async fn memory(&self, id: &str, start: usize, size: usize) -> io::Result<Vec<u8>> {
+    pub async fn memory(
+        &self,
+        id: &str,
+        start: usize,
+        size: usize,
+    ) -> io::Result<Vec<u8>> {
         let query = schema::Memory::build(&MemoryArgs {
             id: id.into(),
             start: start.into(),
@@ -209,7 +257,11 @@ impl FuelClient {
         Ok(())
     }
 
-    pub async fn set_single_stepping(&self, session_id: &str, enable: bool) -> io::Result<()> {
+    pub async fn set_single_stepping(
+        &self,
+        session_id: &str,
+        enable: bool,
+    ) -> io::Result<()> {
         let operation = SetSingleStepping::build(SetSingleSteppingArgs {
             id: Id::new(session_id),
             enable,
@@ -218,7 +270,11 @@ impl FuelClient {
         Ok(())
     }
 
-    pub async fn start_tx(&self, session_id: &str, tx: &Transaction) -> io::Result<RunResult> {
+    pub async fn start_tx(
+        &self,
+        session_id: &str,
+        tx: &Transaction,
+    ) -> io::Result<RunResult> {
         let operation = StartTx::build(StartTxArgs {
             id: Id::new(session_id),
             tx: serde_json::to_string(tx).expect("Couldn't serialize tx to json"),
@@ -314,7 +370,8 @@ impl FuelClient {
     }
 
     pub async fn block(&self, id: &str) -> io::Result<Option<schema::block::Block>> {
-        let query = schema::block::BlockByIdQuery::build(&BlockByIdArgs { id: id.parse()? });
+        let query =
+            schema::block::BlockByIdQuery::build(&BlockByIdArgs { id: id.parse()? });
 
         let block = self.query(query).await?.block;
 
@@ -389,22 +446,28 @@ impl FuelClient {
     }
 
     pub async fn contract(&self, id: &str) -> io::Result<Option<Contract>> {
-        let query =
-            schema::contract::ContractByIdQuery::build(ContractByIdArgs { id: id.parse()? });
+        let query = schema::contract::ContractByIdQuery::build(ContractByIdArgs {
+            id: id.parse()?,
+        });
         let contract = self.query(query).await?.contract;
         Ok(contract)
     }
 
-    pub async fn contract_balance(&self, id: &str, asset: Option<&str>) -> io::Result<u64> {
+    pub async fn contract_balance(
+        &self,
+        id: &str,
+        asset: Option<&str>,
+    ) -> io::Result<u64> {
         let asset_id: schema::AssetId = match asset {
             Some(asset) => asset.parse()?,
             None => schema::AssetId::default(),
         };
 
-        let query = schema::contract::ContractBalanceQuery::build(ContractBalanceQueryArgs {
-            id: id.parse()?,
-            asset: asset_id,
-        });
+        let query =
+            schema::contract::ContractBalanceQuery::build(ContractBalanceQueryArgs {
+                id: id.parse()?,
+                asset: asset_id,
+            });
 
         let balance = self.query(query).await.unwrap().contract_balance.amount;
         Ok(balance.into())
@@ -440,7 +503,9 @@ impl FuelClient {
         request: PaginationRequest<String>,
     ) -> io::Result<PaginatedResult<schema::contract::ContractBalance, String>> {
         let contract_id: schema::ContractId = contract.parse()?;
-        let query = schema::contract::ContractBalancesQuery::build(&(contract_id, request).into());
+        let query = schema::contract::ContractBalancesQuery::build(
+            &(contract_id, request).into(),
+        );
 
         let balances = self.query(query).await?.contract_balances.into();
 
@@ -452,7 +517,8 @@ impl FuelClient {
         owner: Option<&str>,
         request: PaginationRequest<String>,
     ) -> io::Result<PaginatedResult<schema::message::Message, String>> {
-        let owner: Option<schema::Address> = owner.map(|owner| owner.parse()).transpose()?;
+        let owner: Option<schema::Address> =
+            owner.map(|owner| owner.parse()).transpose()?;
         let query = schema::message::OwnedMessageQuery::build(&(owner, request).into());
 
         let messages = self.query(query).await?.messages.into();