Merge branch 'master' into xunilrj/array-iterator

Author: IGI-111

.github/workflows/gh-pages.yml

@@ -55,12 +55,20 @@ jobs:
       - name: Build Sway std library
         run: forc doc --path ./sway-lib-std
 
+      - name: Move assets into std directory  
+        run: |
+          mv ./sway-lib-std/out/doc/static.files ./sway-lib-std/out/doc/std/
+          mv ./sway-lib-std/out/doc/search.js ./sway-lib-std/out/doc/std/
+          # Fix relative paths in HTML files
+          find ./sway-lib-std/out/doc/std -name "*.html" -type f -exec sed -i 's|../static\.files/|static.files/|g' {} \;
+          find ./sway-lib-std/out/doc/std -name "*.html" -type f -exec sed -i 's|../search\.js|search.js|g' {} \;
+
       - name: Deploy master std
         uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: ./sway-lib-std/out/doc/std
-          destination_dir: master
+          destination_dir: master/std
         if: github.ref == 'refs/heads/master'
 
       - name: Deploy master book
@@ -125,7 +133,7 @@ jobs:
         uses: peaceiris/actions-gh-pages@v3
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./sway-lib-std/out/doc/std
+          publish_dir: ./sway-lib-std/out/doc
           destination_dir: ${{ steps.branch_name.outputs.BRANCH_NAME }}/std
         if: startsWith(github.ref, 'refs/tags')
 

README.md

@@ -50,6 +50,35 @@ Confirm the Sway toolchain built successfully:
 cargo run --bin forc -- --help
 ```
 
+## All other scripts/commands
+
+For all other scripts and commands use https://github.com/casey/just:
+
+```
+> just --list
+Available recipes:
+    [automation]
+    update-contract-ids
+    update-fuel-dependencies
+
+    [benchmark]
+    benchmark
+    benchmark-tests
+    collect-gas-usage
+
+    [build]
+    build-highlightjs
+    build-prism
+    generate-sway-lib-std
+
+    [ci]
+    ci-check
+    install-ci-check
+
+    [test]
+    test-forc-fmt-check-panic
+```
+
 ## Contributing to Sway
 
 We welcome contributions to Sway!

docs/book/spell-check-custom-words.txt

@@ -90,6 +90,7 @@ http
 https
 halfword
 js
+kB
 localhost
 mainnet
 mempool

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

@@ -148,7 +148,11 @@ forc-deploy saves the details of each deployment in the `out/deployments` folder
 
 ## Proxy Contracts
 
-`forc-deploy` supports deploying proxy contracts automatically if it is enabled in the `Forc.toml` of the contract.
+`forc-deploy` supports deploying proxy contracts automatically if it is enabled in the `Forc.toml` of the contract. This feature enables upgradeable contracts by deploying a proxy that forwards calls to an implementation contract, allowing you to upgrade the implementation without changing the proxy address.
+
+### Configuration
+
+To enable proxy deployment, add a `[proxy]` table to your `Forc.toml`:
 
 ```TOML
 [project]
@@ -162,11 +166,41 @@ implicit-std = false
 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 the owner of the proxy is set to the account that is signing the transaction for deployment.
+The proxy configuration supports two fields:
+
+- `enabled` (boolean, required): Whether to deploy a proxy contract
+- `address` (string, optional): Address of an existing proxy contract to update
+
+### Fresh Proxy Deployment
+
+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). The deployment process:
+
+1. **Deploy Implementation Contract**: Your contract is deployed as the implementation
+2. **Generate Proxy Contract**: A standard SRC-14 proxy contract is generated
+3. **Deploy Proxy Contract**: The proxy is deployed with your implementation as the target
+4. **Initialize Proxy**: The proxy is initialized with the deploying account as the owner
+5. **Update Manifest**: The proxy address is automatically added to your `Forc.toml`
+
+After deployment, you'll see output similar to:
+
+```console
+Deploying contract test_contract chunks
+Finished deploying test_contract 0x440b...925
+Finished deploying proxy contract for test_contract 0x19d4...f7
+Initialized proxy contract for test_contract
+```
+
+The `Forc.toml` will be automatically updated with the proxy address:
+
+```TOML
+[proxy]
+enabled = true
+address = "0x19d465200575ebd085300242002efcda38db99e22449a5c1346588efe9ced7f7"
+```
 
-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 address is added into the `address` field of the proxy table.
+### Updating Existing Proxy
 
-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:
+If you want to update the target of an existing [SRC-14](https://github.com/FuelLabs/sway-standards/blob/master/docs/src/src-14-simple-upgradeable-proxies.md) compliant proxy contract, specify its address in the `address` field:
 
 ```TOML
 [project]
@@ -181,11 +215,40 @@ 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.
+When an `address` is present, `forc` will:
+
+1. Deploy the new implementation contract
+2. Call the existing proxy's `set_proxy_target` method to update the target
+3. The proxy address remains the same, providing seamless upgrades
+
+### Transaction Details
+
+When deploying with proxy enabled, you'll see multiple transactions in the confirmation:
+
+- One transaction to deploy the implementation contract
+- One additional transaction to deploy the proxy (for fresh deployments) or update the target (for existing proxies)
+
+Example output:
+
+```console
+Confirming transactions [deploy test_contract + deploy proxy]
+Network: https://testnet.fuel.network
+```
+
+### Storage Slots
+
+The proxy contract includes both its own storage slots and preserves the storage slots from your implementation contract, ensuring that contract state is properly maintained across upgrades.
+
+### Important Notes
+
+- The proxy owner (initially set to the deploying account) has exclusive rights to update the proxy target
+- Once a proxy is deployed, the address in your `Forc.toml` allows for automatic target updates on subsequent deployments
+- Proxy contracts work with both regular and [chunked contracts](#large-contracts) (contracts over 100<!-- markdownlint-disable-line MD032 -->kB)
+- The implementation uses the SRC-14 standard for maximum compatibility with the Fuel ecosystem
 
 ## Large Contracts
 
-For contracts over the maximum contract size limit (currently `100kB`) defined by the network, `forc-deploy` will split the contract into chunks and deploy the contract with multiple transactions using the Rust SDK's [loader contract](https://github.com/FuelLabs/fuels-rs/blob/master/docs/src/deploying/large_contracts.md) functionality. Chunks that have already been deployed will be reused on subsequent deployments.
+For contracts over the maximum contract size limit (currently `100<!-- markdownlint-disable-line -->kB`) defined by the network, `forc-deploy` will split the contract into chunks and deploy the contract with multiple transactions using the Rust SDK's [loader contract](https://github.com/FuelLabs/fuels-rs/blob/master/docs/src/deploying/large_contracts.md) functionality. Chunks that have already been deployed will be reused on subsequent deployments.
 
 ## Deploying Scripts and Predicates
 
@@ -206,4 +269,4 @@ The loader files contain the bytecode necessary to load and execute your script
 
 This new deployment method allows for more efficient storage and execution of scripts and predicates on the Fuel network.
 
-Note: Contracts are still deployed directly, not as blobs given that the contract size is under the maximum contract size limit defined by network (currently `100kB`).
+Note: Contracts are still deployed directly, not as blobs given that the contract size is under the maximum contract size limit defined by network (currently `100<!-- markdownlint-disable-line -->kB`).

forc-plugins/forc-client/src/cmd/call.rs

@@ -403,10 +403,17 @@ pub struct Command {
     pub gas: Option<Gas>,
 
     /// The external contract addresses to use for the call
-    /// If none are provided, the call will automatically populate external contracts by making a dry-run calls
-    /// to the node, and extract the contract addresses based on the revert reason
-    #[clap(long, alias = "contracts", help_heading = "CONTRACT")]
-    pub external_contracts: Option<Vec<ContractId>>,
+    /// If none are provided, the call will automatically populate external contracts by making dry-run calls
+    /// to the node, and extract the contract addresses based on the revert reason.
+    /// Use an empty string '' to explicitly specify no external contracts.
+    /// Multiple contract IDs can be provided separated by commas.
+    #[clap(
+        long,
+        alias = "contracts",
+        value_delimiter = ',',
+        help_heading = "CONTRACT"
+    )]
+    pub external_contracts: Option<Vec<String>>,
 
     /// Output format for the call result
     #[clap(long, short = 'o', default_value = "default", help_heading = "OUTPUT")]

forc-plugins/forc-client/src/op/call/call_function.rs

@@ -31,7 +31,7 @@ use fuels_core::{
         ContractId,
     },
 };
-use std::collections::HashMap;
+use std::{collections::HashMap, str::FromStr};
 
 /// Calls a contract function with the given parameters
 pub async fn call_function(
@@ -115,9 +115,23 @@ pub async fn call_function(
 
     // Get external contracts (either provided or auto-detected)
     let external_contracts = match external_contracts {
-        Some(external_contracts) => external_contracts,
+        Some(contracts) if contracts.first().is_some_and(|s| s.is_empty()) => vec![],
+        Some(contracts) => {
+            // Parse each contract ID
+            contracts
+                .into_iter()
+                .filter(|s| !s.is_empty())
+                .map(|s| {
+                    ContractId::from_str(s.strip_prefix("0x").unwrap_or(&s))
+                        .map_err(|e| anyhow!("Invalid contract ID '{}': {}", s, e))
+                })
+                .collect::<Result<Vec<_>>>()?
+        }
         None => {
             // Automatically retrieve missing contract addresses from the call
+            forc_tracing::println_warning(
+                "Automatically retrieving missing contract addresses for the call",
+            );
             let external_contracts = determine_missing_contracts(
                 &call,
                 wallet.provider(),

justfile

@@ -0,0 +1,48 @@
+[group('ci')]
+[confirm("Do you want to install cargo-sort, cargo-generate and cargo-udeps from crates.io?")]
+install-ci-check:
+    cargo install cargo-sort
+    cargo install cargo-generate
+    cargo install cargo-udeps
+
+[group('ci')]
+ci-check:
+    bash ./ci_checks.sh
+
+[group('automation')]
+[confirm("Do you want to bump all fuel maintained dependencies?")]
+update-fuel-dependencies:
+    bash ./update_fuel_dependencies.sh
+
+[group('automation')]
+[confirm("Do you want to automatically update contractIds in this repo?")]
+update-contract-ids:
+    bash ./test/update-contract-ids.sh
+
+[group('benchmark')]
+benchmark:
+    bash ./benchmark.sh
+
+[group('benchmark')]
+benchmark-tests:
+    bash ./test/bench.sh
+
+[group('benchmark')]
+collect-gas-usage:
+    cargo r -p test --release -- --verbose --forc-test-only | ./scripts/compare-gas-usage/extract-gas-usage.sh
+
+[group('build')]
+build-prism:
+    cd ./scripts/prism && ./build.sh
+
+[group('build')]
+build-highlightjs:
+    cd ./scripts/highlightjs && ./build.sh
+
+[group('build')]
+generate-sway-lib-std:
+    cd ./sway-lib-std && ./generate.sh
+
+[group('test')]
+test-forc-fmt-check-panic:
+    cd ./scripts/formatter && ./forc-fmt-check-panic.sh

scripts/bisect-forc/README.md

@@ -0,0 +1,17 @@
+`bisect-forc.sh` will automatically run `forc bisect` searching for a different behaviour between two commits.
+
+The script accepts three arguments:
+
+```
+bisect-forc.sh sway_project test 30s
+```
+1 - First argument is the sway project that will be compiled over and over until a different behavior is found;
+2 - The second argument is which forc subcommand will be used. It defaults to `build`.
+
+So, `forc` will be run as:
+
+```
+> forc <SECONDARGUMENT> --path <FIRSTARGUMENT>
+```
+
+3 - The third argument is a sleep that is taken between compilations to avoid notebooks enter into thermal throttle mode, or that weaker machines become unusable. Default to zero.