Merge #2669 (swayfmt replacement PR) with master including newline formatting fixes

examples/break_and_continue/src/main.sw

@@ -1,6 +1,5 @@
 script;
 
-
 // ANCHOR: break_example
 fn break_example() -> u64 {
     let mut counter = 1;

examples/enums/src/basic_enum.sw

@@ -1,6 +1,5 @@
 library basic_enum;
 
-
 // Declare the enum
 enum Color {
     Blue: (),

examples/match_statements/src/main.sw

@@ -4,6 +4,7 @@ fn foo() {}
     // do something
 fn bar() {}
 
+
     // do something
 enum SomeEnum {
     A: u64,

examples/storage_map/src/main.sw

@@ -1,6 +1,5 @@
 contract;
 
-
 // ANCHOR: storage_map_import
 use std::storage::StorageMap;
 // ANCHOR_END: storage_map_import

examples/storage_variables/src/main.sw

@@ -1,6 +1,5 @@
 contract;
 
-
 // ANCHOR: storage_declaration
 struct Type1 {
     x: u64,

examples/storage_vec/src/main.sw

@@ -1,12 +1,10 @@
 contract;
 
-
 // ANCHOR: storage_vec_import
 use std::storage::StorageVec;
 // ANCHOR_END: storage_vec_import
 use std::{logging::log, option::Option, revert::revert};
 
-
 // ANCHOR: storage_vec_multiple_types_enum
 enum TableCell {
     Int: u64,

examples/structs/src/data_structures.sw

@@ -1,13 +1,11 @@
 library data_structures;
 
-
 // Declare a struct type
 pub struct Foo {
     bar: u64,
     baz: bool,
 }
 
-
 // Struct types for destructuring
 pub struct Point {
     x: u64,

examples/vec/src/main.sw

@@ -1,6 +1,5 @@
 script;
 
-
 // ANCHOR: vec_import
 use std::vec::Vec;
 // ANCHOR_END: vec_import

forc-plugins/forc-client/Cargo.toml

@@ -13,12 +13,16 @@ anyhow = "1"
 clap = { version = "3", features = ["derive", "env"] }
 forc-pkg = { version = "0.22.1", path = "../../forc-pkg" }
 forc-util = { version = "0.22.1", path = "../../forc-util" }
+fuel-crypto = "0.6"
 fuel-gql-client = { version = "0.10", default-features = false }
 fuel-tx = "0.18"
 fuel-vm = "0.15"
+fuels-core = "0.21" 
+fuels-signers = "0.21"
+fuels-types = "0.21"
 futures = "0.3"
 hex = "0.4.3"
-serde = { version = "1.0" }
+serde = "1.0"
 serde_json = "1.0.73"
 sway-core = { version = "0.22.1", path = "../../sway-core" }
 sway-types = { version = "0.22.1", path = "../../sway-types" }

forc-plugins/forc-client/src/ops/deploy/cmd.rs

@@ -69,4 +69,13 @@ pub struct DeployCommand {
     /// Output the time elapsed over each part of the compilation process.
     #[clap(long)]
     pub time_phases: bool,
+    /// Do not sign the transaction
+    #[clap(long)]
+    pub unsigned: bool,
+    /// Set the transaction gas limit. Defaults to the maximum gas limit.
+    #[clap(long)]
+    pub gas_limit: Option<u64>,
+    /// Set the transaction gas price. Defaults to 0.
+    #[clap(long)]
+    pub gas_price: Option<u64>,
 }

forc-plugins/forc-client/src/ops/deploy/op.rs

@@ -1,14 +1,18 @@
 use anyhow::{bail, Result};
-use forc_pkg::{BuildOptions, ManifestFile};
+use forc_pkg::{BuildOptions, Compiled, ManifestFile};
+use fuel_crypto::Signature;
 use fuel_gql_client::client::FuelClient;
 use fuel_tx::{Output, Salt, StorageSlot, Transaction};
 use fuel_vm::prelude::*;
-use std::path::PathBuf;
+use fuels_core::constants::{BASE_ASSET_ID, DEFAULT_SPENDABLE_COIN_AMOUNT};
+use fuels_signers::{provider::Provider, wallet::Wallet};
+use fuels_types::bech32::Bech32Address;
+use std::{io::Write, path::PathBuf, str::FromStr};
 use sway_core::TreeType;
 use sway_utils::constants::DEFAULT_NODE_URL;
 use tracing::info;
 
-use super::cmd::DeployCommand;
+use crate::ops::{deploy::cmd::DeployCommand, parameters::TxParameters};
 
 pub async fn deploy(command: DeployCommand) -> Result<fuel_tx::ContractId> {
     let curr_dir = if let Some(ref path) = command.path {
@@ -37,6 +41,9 @@ pub async fn deploy(command: DeployCommand) -> Result<fuel_tx::ContractId> {
         build_profile,
         release,
         time_phases,
+        unsigned,
+        gas_limit,
+        gas_price,
     } = command;
 
     let build_options = BuildOptions {
@@ -59,12 +66,6 @@ pub async fn deploy(command: DeployCommand) -> Result<fuel_tx::ContractId> {
     };
 
     let compiled = forc_pkg::build_with_options(build_options)?;
-    let (tx, contract_id) = create_contract_tx(
-        compiled.bytecode,
-        Vec::<fuel_tx::Input>::new(),
-        Vec::<fuel_tx::Output>::new(),
-        compiled.storage_slots,
-    );
 
     let node_url = match &manifest.network {
         Some(network) => &network.url,
@@ -75,6 +76,47 @@ pub async fn deploy(command: DeployCommand) -> Result<fuel_tx::ContractId> {
 
     let client = FuelClient::new(node_url)?;
 
+    let (mut tx, contract_id) = if unsigned {
+        create_contract_tx(
+            compiled.bytecode,
+            Vec::<fuel_tx::Input>::new(),
+            Vec::<fuel_tx::Output>::new(),
+            compiled.storage_slots,
+        )
+    } else {
+        let mut wallet_address = String::new();
+        print!(
+            "Please provide the address of the wallet you are going to sign this transaction with:"
+        );
+        std::io::stdout().flush()?;
+        std::io::stdin().read_line(&mut wallet_address)?;
+        let address = Bech32Address::from_str(wallet_address.trim())?;
+        let locked_wallet = Wallet::from_address(address, Some(Provider::new(client.clone())));
+        let tx_parameters = TxParameters::new(gas_limit, gas_price);
+        create_signed_contract_tx(compiled, locked_wallet, tx_parameters).await?
+    };
+
+    if !unsigned {
+        // Ask for the signature and add it as a witness
+        let mut signature = String::new();
+        print!("Please provide the signature for this transaction:");
+        std::io::stdout().flush()?;
+        std::io::stdin().read_line(&mut signature)?;
+
+        let signature = Signature::from_str(signature.trim())?;
+        let witness = vec![Witness::from(signature.as_ref())];
+
+        let mut witnesses: Vec<Witness> = tx.witnesses().to_vec();
+
+        match witnesses.len() {
+            0 => tx.set_witnesses(witness),
+            _ => {
+                witnesses.extend(witness);
+                tx.set_witnesses(witnesses)
+            }
+        }
+    }
+
     match client.submit(&tx).await {
         Ok(logs) => {
             info!("Logs:\n{:?}", logs);
@@ -84,6 +126,58 @@ pub async fn deploy(command: DeployCommand) -> Result<fuel_tx::ContractId> {
     }
 }
 
+async fn create_signed_contract_tx(
+    compiled_contract: Compiled,
+    signer_wallet: Wallet,
+    tx_parameters: TxParameters,
+) -> Result<(Transaction, fuel_tx::ContractId)> {
+    let maturity = 0;
+    let bytecode_witness_index = 0;
+    let witnesses = vec![compiled_contract.bytecode.clone().into()];
+
+    let salt = Salt::new([0; 32]);
+
+    let contract = Contract::from(compiled_contract.bytecode);
+    let root = contract.root();
+
+    let mut storage_slots = compiled_contract.storage_slots;
+    storage_slots.sort();
+    let state_root = Contract::initial_state_root(storage_slots.iter());
+    let contract_id = contract.id(&salt, &root, &state_root);
+    info!("Contract id: 0x{}", hex::encode(contract_id));
+
+    let outputs: Vec<Output> = vec![
+        Output::contract_created(contract_id, state_root),
+        // Note that the change will be computed by the node.
+        // Here we only have to tell the node who will own the change and its asset ID.
+        // For now we use the BASE_ASSET_ID constant
+        Output::change(signer_wallet.address().into(), 0, BASE_ASSET_ID),
+    ];
+    let coin_witness_index = 1;
+
+    let inputs = signer_wallet
+        .get_asset_inputs_for_amount(
+            AssetId::default(),
+            DEFAULT_SPENDABLE_COIN_AMOUNT,
+            coin_witness_index,
+        )
+        .await?;
+    let tx = Transaction::create(
+        tx_parameters.gas_price,
+        tx_parameters.gas_limit,
+        maturity,
+        bytecode_witness_index,
+        salt,
+        storage_slots,
+        inputs,
+        outputs,
+        witnesses,
+    );
+
+    println!("Tx id to sign {}", tx.id());
+    Ok((tx, contract_id))
+}
+
 fn create_contract_tx(
     compiled_contract: Vec<u8>,
     inputs: Vec<Input>,

forc-plugins/forc-client/src/ops/mod.rs

@@ -1,2 +1,3 @@
 pub mod deploy;
+pub mod parameters;
 pub mod run;

forc-plugins/forc-client/src/ops/run/cmd.rs

@@ -91,10 +91,6 @@ pub struct RunCommand {
     #[clap(long)]
     pub minify_json_storage_slots: bool,
 
-    /// Set the transaction byte price. Defaults to 0.
-    #[clap(long)]
-    pub byte_price: Option<u64>,
-
     /// Set the transaction gas limit. Defaults to the maximum gas limit.
     #[clap(long)]
     pub gas_limit: Option<u64>,

forc-plugins/forc-client/src/ops/run/mod.rs

@@ -1,3 +1,2 @@
 pub mod cmd;
 pub mod op;
-mod parameters;

forc-plugins/forc-client/src/ops/run/op.rs

@@ -7,7 +7,7 @@ use std::{path::PathBuf, str::FromStr};
 use sway_core::TreeType;
 use tracing::info;
 
-use super::{cmd::RunCommand, parameters::TxParameters};
+use crate::ops::{parameters::TxParameters, run::cmd::RunCommand};
 
 pub const NODE_URL: &str = "http://127.0.0.1:4000";
 

sway-core/src/declaration_engine/declaration_id.rs

@@ -2,6 +2,8 @@ use std::fmt;
 
 use sway_types::{Span, Spanned};
 
+use crate::type_system::{CopyTypes, TypeMapping};
+
 use super::declaration_engine::de_look_up_decl_id;
 
 /// An ID used to refer to an item in the [DeclarationEngine](super::declaration_engine::DeclarationEngine)
@@ -49,6 +51,12 @@ impl Spanned for DeclarationId {
     }
 }
 
+impl CopyTypes for DeclarationId {
+    fn copy_types(&mut self, type_mapping: &TypeMapping) {
+        de_look_up_decl_id(self.clone()).copy_types(type_mapping)
+    }
+}
+
 impl DeclarationId {
     pub(super) fn new(index: usize, span: Span) -> DeclarationId {
         DeclarationId(index, span)

sway-core/src/declaration_engine/declaration_wrapper.rs

@@ -7,6 +7,7 @@ use crate::{
         TypedImplTrait, TypedStorageDeclaration, TypedStructDeclaration, TypedTraitDeclaration,
         TypedTraitFn,
     },
+    type_system::{CopyTypes, TypeMapping},
     CompileError, TypedFunctionDeclaration,
 };
 
@@ -54,6 +55,20 @@ impl fmt::Display for DeclarationWrapper {
     }
 }
 
+impl CopyTypes for DeclarationWrapper {
+    fn copy_types(&mut self, type_mapping: &TypeMapping) {
+        match self {
+            DeclarationWrapper::Unknown => {}
+            DeclarationWrapper::Function(decl) => decl.copy_types(type_mapping),
+            DeclarationWrapper::Trait(decl) => decl.copy_types(type_mapping),
+            DeclarationWrapper::TraitFn(decl) => decl.copy_types(type_mapping),
+            DeclarationWrapper::TraitImpl(decl) => decl.copy_types(type_mapping),
+            DeclarationWrapper::Struct(decl) => decl.copy_types(type_mapping),
+            DeclarationWrapper::Storage(_) => {}
+        }
+    }
+}
+
 impl DeclarationWrapper {
     /// friendly name string used for error reporting.
     fn friendly_name(&self) -> &'static str {