feat: create and deploy a reference proxy contract for contracts with…

… `[proxy]` enabled (#6069)

## Description
Part of #6068. 

This PR adds couple of things:

1. A default proxy contract implementation taken from [sway
standards](https://github.com/FuelLabs/sway-standards/blob/master/standards/src/src14.sw).
2. Infra for creating, building and deploying the reference
implementation for proxy contracts.
3. Deployment procedure such that proxy contract is deployed while
working on a contract which enables the `[proxy]` in its forc.toml. In a
way that it is owned by the deployer and the target initially points to
implementation contract.
4. Infra for making a contract call into the already deployed proxy
contracts to update their targets.
5. Adds a `Building` text to the all forc build invocations to better
inform the user about what forc is doing behind the scenes.
6. Removes duplicate forc-wallet password prompts which was very
frustrating for the users. Now forc-wallet deployment path only asks for
password once.
7. Refactors around how secret_key is selected based on user input
8. Updated docs around forc-client
9. Docs around how to use the proxy feature

## How this works
If the user does not have a proxy table in their forc.toml, nothing
changes, same old deployment procedure is followed. Only difference is
that this PR improves the ux by removing the need of providing the
password multiple times.

If the user has a contract with a proxy table but without an address
like:

```TOML
[project]
authors = ["kaya"]
entry = "main.sw"
license = "Apache-2.0"
name = "impl-contract"

[dependencies]

[proxy]
enabled = true
```
Forc automatically creates a proxy contract based on the reference
implementation at
[SRC14](https://github.com/FuelLabs/sway-standard-implementations/tree/61fd4ad8f69d21cec0d5cd8135bdc4495e0c125c). Sets its
target to the implementation contract, whichever contract enabled the
proxy and the owner to the deployer (signing account of the
transaction).

If the user has a contract with a proxy table and an address specified
like:

```TOML
[project]
authors = ["kaya"]
entry = "main.sw"
license = "Apache-2.0"
name = "impl-contract"

[dependencies]

[proxy]
enabled = true
address = "........."
```
Forc automatically makes a set target conract call to update the proxy
contract's target. Pointing it to the newly deployed impl contract which
defines the proxy table.

Generated proxy contract abi and bins are stored at
`~/.forc/.generated_proxy_contracts/project_name` for housekeeping.

Cargo.toml

@@ -47,6 +47,7 @@ fuel-vm = "0.55.0"
 # Dependencies from the `fuels-rs` repository:
 fuels-core = "0.65.1"
 fuels-accounts = "0.65.1"
+fuels = "0.65.1"
 
 # Dependencies from the `forc-wallet` repository:
 forc-wallet = "0.8.2"

docs/book/src/forc/plugins/forc_client/index.md

@@ -1,26 +1,62 @@
 # `forc-client`
 
-Forc plugin for interacting with a Fuel node.
+Forc plugin for interacting with a Fuel node. Since transactions are going to require some gas, you need to sign them with an account that has enough tokens to pay for them.
 
-## Initializing the wallet and adding accounts
+We offer multiple ways to sign the transaction:
 
-If you don't have an initialized wallet or any account for your wallet you won't be able to sign transactions.
+  1. Sign the transaction via your local wallet using `forc-client` which integrates with our CLI wallet, `forc-wallet`.
+  2. Use the default signer to deploy to a local node
+  3. Use `forc-wallet` to manually sign transactions, and copy the signed transaction back to `forc-client`.
 
-To create a wallet you can use `forc wallet new`. It will ask you to choose a password to encrypt your wallet. After the initialization is done you will have your mnemonic phrase.
+The easiest and recommended way to interact with deployed networks such as our testnets is option 1, using `forc-client` to sign your transactions which reads your default `forc-wallet` vault. For interacting with local node, we recommend using the second option, which leads `forc-client` to sign transactions with the a private key that comes pre-funded in local environments.
 
-After you have created a wallet, you can derive a new account by running `forc wallet account new`. It will ask your password to decrypt the wallet before deriving an account.
+## Option 1: Sign transactions via forc-client using your local forc-wallet vault
 
-## Signing transactions using `forc-wallet` CLI
+If you've used `forc-wallet` before, you'll already have a secure, password-protected vault holding your private key written to your file-system. `forc-client` is compatible with `forc-wallet` such that it can read that vault by asking you your password and use your account to sign transactions.
 
-To submit the transactions created by `forc deploy` or `forc run`, you need to sign them first (unless you are using a client without UTXO validation). To sign a transaction you can use `forc-wallet` CLI. This section is going to walk you through the whole signing process.
+Example:
 
-By default `fuel-core` runs without UTXO validation, this allows you to send invalid inputs to emulate different conditions.
+```console
+> forc deploy
 
-If you want to run `fuel-core` with UTXO validation, you can pass `--utxo-validation` to `fuel-core run`.
+    Building /Users/yourname/test-projects/test-contract
+    Finished release [optimized + fuel] target(s) in 11.39s
+  Confirming transactions [deploy impl-contract]
+             Network: https://testnet.fuel.network
+             Wallet: /Users/yourname/.fuel/wallets/.wallet
+✔ Wallet password · ********
+? Wallet account ›
+❯ [0] fuel12pls73y9hnqdqthvduy2x44x48zt8s50pkerf32kq26f2afeqdwq6rj9ar - 0.002197245 ETH
+  [1] fuel1vzrm6kw9s3tv85gl25lpptsxrdguyzfhq6c8rk07tr6ft5g45nwqqh0uty - 0.001963631 ETH
+? Do you agree to sign 1 transaction? (y/n) › yes
+     Finished deploying impl-contract https://app.fuel.network/contract/0x94b712901f04332682d14c998a5fc5a078ed15321438f46d58d0383200cde43d
+     Deployed in block https://app.fuel.network/block/5958351
+```
+
+As it can be seen from the example, `forc-client` asks for your password to decrypt the `forc-wallet` vault, and list your accounts so that you can select the one you want to fund the transaction with.
+
+## Option 2: Using default signer
 
-To install `forc-wallet` please refer to `forc-wallet`'s [GitHub repo](https://github.com/FuelLabs/forc-wallet#forc-wallet).
+If you are not interacting with a deployed network, such as testnets, your local `fuel-core` environment can be structured such that it funds an account by default. Using `--default-signer` flag with `forc-client` binaries (run, deploy) will instruct `forc-client` to sign transactions with this pre-funded account. Which makes it a useful command while working against a local node.
 
-1. Construct the transaction by using either `forc deploy` or `forc run`. To do so simply run `forc deploy` or `forc run` with your desired parameters. For a list of parameters please refer to the [forc-deploy](./forc_deploy.md) or [forc-run](./forc_run.md) section of the book. Once you run either command you will be asked the address of the wallet you are going to be signing with. After the address is given the transaction will be generated and you will be given a transaction ID. At this point CLI will actively wait for you to insert the signature.
+Example:
+
+```console
+> forc deploy --default-signer
+
+    Building /Users/test/test-projects/test-contract
+    Finished release [optimized + fuel] target(s) in 11.40s
+  Confirming transactions [deploy impl-contract]
+             Network: http://127.0.0.1:4000
+    Finished deploying impl-contract 0xf9fb08ef18ce226954270d6d4f67677d484b8782a5892b3d436572b405407544
+    Deployed in block 00000001
+```
+
+## Option 3: Manually signing through forc-wallet (Deprecated)
+
+This option is for creating the transaction first, signing it manually and supplying the signed transaction back to forc-client. Since it requires multiple steps, it is more error-prone and not recommended for general use case. Also this will be deprecated soon.
+
+1. Construct the transaction by using either `forc deploy` or `forc run`. To do so simply run `forc deploy --manual-sign` or `forc run --manual-sign` with your desired parameters. For a list of parameters please refer to the [forc-deploy](./forc_deploy.md) or [forc-run](./forc_run.md) section of the book. Once you run either command you will be asked the address of the wallet you are going to be signing with. After the address is given the transaction will be generated and you will be given a transaction ID. At this point CLI will actively wait for you to insert the signature.
 2. Take the transaction ID generated in the first step and sign it with `forc wallet sign --account <account_index> tx-id <transaction_id>`. This will generate a signature.
 3. Take the signature generated in the second step and provide it to `forc-deploy` (or `forc-run`). Once the signature is provided, the signed transaction will be submitted.
 
@@ -56,7 +92,7 @@ By default `--default-signer` flag would sign your transactions with the followi
 
 ## Interacting with the testnet
 
-To interact with the latest testnet, use the `--testnet` flag. When this flag is passed, transactions created by `forc-deploy` will be sent to the `beta-4` testnet.
+To interact with the latest testnet, use the `--testnet` flag. When this flag is passed, transactions created by `forc-deploy` will be sent to the latest `testnet`.
 
 ```sh
 forc-deploy --testnet
@@ -68,10 +104,10 @@ It is also possible to pass the exact node URL while using `forc-deploy` or `for
 forc-deploy --node-url https://beta-3.fuel.network
 ```
 
-Another alternative is the `--target` option, which provides useful aliases to all targets. For example if you want to deploy to `beta-3` you can use:
+Another alternative is the `--target` option, which provides useful aliases to all targets. For example if you want to deploy to `beta-5` you can use:
 
 ```sh
-forc-deploy --target beta-3
+forc-deploy --target beta-5
 ```
 
 Since deploying and running projects on the testnet cost gas, you will need coins to pay for them. You can get some using the [testnet faucet](https://faucet-testnet.fuel.network/).
@@ -91,3 +127,40 @@ forc-deploy saves the details of each deployment in the `out/deployments` folder
   "deployed_block_id": "0x915c6f372252be6bc54bd70df6362dae9bf750ba652bf5582d9b31c7023ca6cf"
 }
 ```
+
+## Proxy Contracts
+
+`forc-deploy` supports deploying proxy contracts automatically if it is enabled in the `Forc.toml` of the contract.
+
+```TOML
+[project]
+name = "test_contract"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[proxy]
+enabled = true
+```
+
+If there is no `address` field present under the proxy table, like the example above, `forc` will automatically create a proxy contract based on the [SRC-14](https://github.com/FuelLabs/sway-standards/blob/master/docs/src/src-14-simple-upgradeable-proxies.md) implementation from [sway-standards](https://github.com/FuelLabs/sway-standards). After generating and deploying the proxy contract, the target is set to the current contract, and owner of the proxy is set to the account that is signing the transaction for deployment.
+
+This means that if you simply enable proxy in the `Forc.toml`, forc will automatically deploy a proxy contract for you and you do not need to do anything manually aside from signing the deployment transactions for the proxy contract. After deploying the proxy contract, the its address is added into the `address` field of the proxy table.
+
+If you want to update the target of an [SRC-14](https://github.com/FuelLabs/sway-standards/blob/master/docs/src/src-14-simple-upgradeable-proxies.md) compliant proxy contract rather than deploying a new one, simply add its `address` in the `address` field, like the following example:
+
+```TOML
+[project]
+name = "test_contract"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+implicit-std = false
+
+[proxy]
+enabled = true
+address = "0xd8c4b07a0d1be57b228f4c18ba7bca0c8655eb6e9d695f14080f2cf4fc7cd946" # example proxy contract address
+```
+
+If an `address` is present, `forc` calls into that contract to update its `target` instead of deploying a new contract. Since a new proxy deployment adds its own `address` into the `Forc.toml` automatically, you can simply enable the proxy once and after the initial deployment, `forc` will keep updating the target accordingly for each new deployment of the same contract.

forc-pkg/src/manifest/mod.rs

@@ -186,6 +186,7 @@ pub struct PackageManifest {
     pub build_target: Option<BTreeMap<String, BuildTarget>>,
     build_profile: Option<BTreeMap<String, BuildProfile>>,
     pub contract_dependencies: Option<BTreeMap<String, ContractDependency>>,
+    pub proxy: Option<Proxy>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -273,6 +274,17 @@ pub struct DependencyDetails {
     pub(crate) ipfs: Option<String>,
 }
 
+/// Describes the details around proxy contract.
+#[derive(Serialize, Deserialize, Clone, Debug, Default, PartialEq, Eq)]
+#[serde(rename_all = "kebab-case")]
+pub struct Proxy {
+    pub enabled: bool,
+    /// Points to the proxy contract to be updated with the new contract id.
+    /// If there is a value for this field, forc will try to update the proxy contract's storage
+    /// field such that it points to current contract's deployed instance.
+    pub address: Option<String>,
+}
+
 impl DependencyDetails {
     /// Checks if dependency details reserved for a specific dependency type used without the main
     /// detail for that type.
@@ -650,6 +662,11 @@ impl PackageManifest {
             .and_then(|patches| patches.get(patch_name))
     }
 
+    /// Retrieve the proxy table for the package.
+    pub fn proxy(&self) -> Option<&Proxy> {
+        self.proxy.as_ref()
+    }
+
     /// Check for the `core` and `std` packages under `[dependencies]`. If both are missing, add
     /// `std` implicitly.
     ///

forc-pkg/src/pkg.rs

@@ -285,7 +285,7 @@ pub struct MinifyOpts {
 type ContractIdConst = String;
 
 /// The set of options provided to the `build` functions.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct BuildOpts {
     pub pkg: PkgOpts,
     pub print: PrintOpts,
@@ -318,6 +318,7 @@ pub struct BuildOpts {
 }
 
 /// The set of options to filter type of projects to build in a workspace.
+#[derive(Clone)]
 pub struct MemberFilter {
     pub build_contracts: bool,
     pub build_scripts: bool,
@@ -2153,6 +2154,8 @@ pub fn build_with_options(build_options: &BuildOpts) -> Result<Built> {
         .as_ref()
         .map_or_else(|| current_dir, PathBuf::from);
 
+    println_action_green("Building", &path.display().to_string());
+
     let build_plan = BuildPlan::from_pkg_opts(&build_options.pkg)?;
     let graph = build_plan.graph();
     let manifest_map = build_plan.manifest_map();

forc-plugins/forc-client/Cargo.toml

@@ -27,6 +27,7 @@ fuel-core-types = { workspace = true }
 fuel-crypto = { workspace = true }
 fuel-tx = { workspace = true, features = ["test-helpers"] }
 fuel-vm = { workspace = true }
+fuels = { workspace = true }
 fuels-accounts = { workspace = true }
 fuels-core = { workspace = true }
 futures = "0.3"
@@ -39,6 +40,7 @@ sway-core = { version = "0.62.0", path = "../../sway-core" }
 sway-types = { version = "0.62.0", path = "../../sway-types" }
 sway-utils = { version = "0.62.0", path = "../../sway-utils" }
 tokio = { version = "1.8", features = ["macros", "rt-multi-thread", "process"] }
+toml_edit = "0.21.1"
 tracing = "0.1"
 
 [dev-dependencies]

forc-plugins/forc-client/proxy_abi/README.md

@@ -0,0 +1,8 @@
+# Proxy Contract
+
+This folder contains pre-built version of the owned proxy contract, its abi and `storage-slots.json` file.
+
+*contract url*: [sway-standard-implementation/src-14/owned_proxy](https://github.com/FuelLabs/sway-standard-implementations/tree/61fd4ad8f69d21cec0d5cd8135bdc4495e0c125c).
+*commit hash*: `61fd4ad8f69d21cec0d5cd8135bdc4495e0c125c`
+*forc version*: `v0.62.0`
+*build command*: `forc build --release`