plugin: forc-call

forc-plugins/forc-client/Cargo.toml

@@ -17,6 +17,7 @@ chrono = { workspace = true, features = ["std"] }
 clap = { workspace = true, features = ["derive", "env"] }
 devault.workspace = true
 dialoguer.workspace = true
+either.workspace = true
 forc.workspace = true
 forc-pkg.workspace = true
 forc-tracing.workspace = true
@@ -36,26 +37,32 @@ futures.workspace = true
 hex.workspace = true
 k256.workspace = true
 rand.workspace = true
+regex.workspace = true
+reqwest = { workspace = true }
 rpassword.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+sway-ast.workspace = true
 sway-core.workspace = true
 sway-features.workspace = true
+sway-parse.workspace = true
 sway-types.workspace = true
 sway-utils.workspace = true
+swayfmt.workspace = true
+tempfile.workspace = true
 tokio = { workspace = true, features = [
     "macros",
     "process",
     "rt-multi-thread",
 ] }
 toml_edit.workspace = true
 tracing.workspace = true
+url.workspace = true
 
 [dev-dependencies]
 portpicker = "0.1.1"
 pretty_assertions = "1.4.1"
 rexpect = "0.5"
-tempfile = "3"
 
 [build-dependencies]
 regex = "1.5.4"
@@ -72,5 +79,9 @@ path = "src/bin/run.rs"
 name = "forc-submit"
 path = "src/bin/submit.rs"
 
+[[bin]]
+name = "forc-call"
+path = "src/bin/call.rs"
+
 [lib]
 path = "src/lib.rs"

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

@@ -0,0 +1,12 @@
+use clap::Parser;
+use forc_tracing::{init_tracing_subscriber, println_error};
+
+#[tokio::main]
+async fn main() {
+    init_tracing_subscriber(Default::default());
+    let command = forc_client::cmd::Call::parse();
+    if let Err(err) = forc_client::op::call(command).await {
+        println_error(&format!("{}", err));
+        std::process::exit(1);
+    }
+}

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

@@ -0,0 +1,198 @@
+use crate::NodeTarget;
+use clap::Parser;
+use either::Either;
+use fuel_crypto::SecretKey;
+use fuels::programs::calls::CallParameters;
+use fuels_core::types::{AssetId, ContractId};
+use std::{path::PathBuf, str::FromStr};
+use url::Url;
+
+pub use forc::cli::shared::{BuildOutput, BuildProfile, Minify, Pkg, Print};
+pub use forc_tx::{Gas, Maturity};
+
+forc_util::cli_examples! {
+    super::Command {
+        [ Call a contract with function parameters => "forc call <CONTRACT_ID> <FUNCTION_SIGNATURE> <ARGS>" ]
+        [ Call a contract without function parameters => "forc call <CONTRACT_ID> <FUNCTION_SIGNATURE>" ]
+        [ Call a contract given an ABI file with function parameters => "forc call <CONTRACT_ID> --abi <ABI_FILE> <FUNCTION_SELECTOR> <ARGS>" ]
+        [ Call a contract that makes external contract calls => "forc call <CONTRACT_ID> --abi <ABI_FILE> <FUNCTION_SELECTOR> <ARGS> --contracts <CONTRACT_ADDRESS_1> <CONTRACT_ADDRESS_2>..." ]
+        [ Call a contract in simulation mode => "forc call <CONTRACT_ID> <FUNCTION_SIGNATURE> --simulate" ]
+        [ Call a contract in live mode which performs state changes => "forc call <CONTRACT_ID> <FUNCTION_SIGNATURE> --live" ]
+        [ Call a contract payable function which transfers value of native asset => "forc call <CONTRACT_ID> <FUNCTION_SIGNATURE> --live --amount <VALUE>" ]
+        [ Call a contract payable function which transfers value of custom asset => "forc call <CONTRACT_ID> <FUNCTION_SIGNATURE> --live --amount <VALUE> --asset-id <ASSET_ID>" ]
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum FuncType {
+    Signature(String),
+    Selector(String),
+}
+
+impl Default for FuncType {
+    fn default() -> Self {
+        FuncType::Signature(String::new())
+    }
+}
+
+impl FromStr for FuncType {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let s = s.trim().replace(' ', "");
+        if s.is_empty() {
+            return Err("Function signature cannot be empty".to_string());
+        }
+        // Check if function signature is a valid selector (alphanumeric and underscore support)
+        let selector_pattern = regex::Regex::new(r"^[a-zA-Z][a-zA-Z0-9_]*$").unwrap();
+        if !selector_pattern.is_match(&s) {
+            return Ok(FuncType::Signature(s.to_string()));
+        }
+        Ok(FuncType::Selector(s.to_string()))
+    }
+}
+
+/// Flags for specifying the caller.
+#[derive(Debug, Default, Clone, Parser, serde::Deserialize, serde::Serialize)]
+pub struct Caller {
+    /// Derive an account from a secret key to make the call
+    #[clap(long, env = "SIGNING_KEY")]
+    pub signing_key: Option<SecretKey>,
+
+    /// Use forc-wallet to make the call
+    #[clap(long, default_value = "false")]
+    pub wallet: bool,
+}
+
+#[derive(Debug, Default, Clone, Parser)]
+pub struct CallParametersOpts {
+    /// Amount of native assets to forward with the call
+    #[clap(long, default_value = "0", alias = "value")]
+    pub amount: u64,
+
+    /// Asset ID to forward with the call
+    #[clap(long)]
+    pub asset_id: Option<AssetId>,
+
+    /// Amount of gas to forward with the call
+    #[clap(long)]
+    pub gas_forwarded: Option<u64>,
+}
+
+impl From<CallParametersOpts> for CallParameters {
+    fn from(opts: CallParametersOpts) -> Self {
+        let mut params = CallParameters::default();
+        if opts.amount != 0 {
+            params = params.with_amount(opts.amount);
+        }
+        if let Some(asset_id) = opts.asset_id {
+            params = params.with_asset_id(asset_id);
+        }
+        if let Some(gas) = opts.gas_forwarded {
+            params = params.with_gas_forwarded(gas);
+        }
+        params
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub enum ExecutionMode {
+    /// Execute a dry run - no state changes, no gas fees, wallet is not used or validated
+    #[default]
+    DryRun,
+    /// Execute in simulation mode - no state changes, estimates gas, wallet is used but not validated
+    /// State changes are not applied
+    Simulate,
+    /// Execute live on chain - state changes, gas fees apply, wallet is used and validated
+    /// State changes are applied
+    Live,
+}
+
+impl FromStr for ExecutionMode {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "dry-run" => Ok(ExecutionMode::DryRun),
+            "simulate" => Ok(ExecutionMode::Simulate),
+            "live" => Ok(ExecutionMode::Live),
+            _ => Err(format!("Invalid execution mode: {}", s)),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Default)]
+pub enum OutputFormat {
+    #[default]
+    Default,
+    Raw,
+}
+
+impl FromStr for OutputFormat {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "default" => Ok(OutputFormat::Default),
+            "raw" => Ok(OutputFormat::Raw),
+            _ => Err(format!("Invalid output format: {}", s)),
+        }
+    }
+}
+
+/// Call a contract function.
+#[derive(Debug, Default, Parser, Clone)]
+#[clap(bin_name = "forc call", version)]
+pub struct Command {
+    /// The contract ID to call.
+    pub contract_id: ContractId,
+
+    /// Optional path or URI to a JSON ABI file.
+    #[clap(long, value_parser = parse_abi_path)]
+    pub abi: Option<Either<PathBuf, Url>>,
+
+    /// The function signature to call.
+    /// When ABI is provided, this should be a selector (e.g. "transfer")
+    /// When no ABI is provided, this should be the full function signature (e.g. "transfer(address,u64)")
+    pub function: FuncType,
+
+    /// Arguments to pass into main function with forc run.
+    pub args: Vec<String>,
+
+    #[clap(flatten)]
+    pub node: NodeTarget,
+
+    /// Select the caller to use for the call
+    #[clap(flatten)]
+    pub caller: Caller,
+
+    /// Call parameters to use for the call
+    #[clap(flatten)]
+    pub call_parameters: CallParametersOpts,
+
+    /// The execution mode to use for the call; defaults to dry-run; possible values: dry-run, simulate, live
+    #[clap(long, default_value = "dry-run")]
+    pub mode: ExecutionMode,
+
+    /// The gas price to use for the call; defaults to 0
+    #[clap(flatten)]
+    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")]
+    pub external_contracts: Option<Vec<ContractId>>,
+
+    /// The output format to use; possible values: default, raw
+    #[clap(long, default_value = "default")]
+    pub output: OutputFormat,
+}
+
+fn parse_abi_path(s: &str) -> Result<Either<PathBuf, Url>, String> {
+    if let Ok(url) = Url::parse(s) {
+        match url.scheme() {
+            "http" | "https" | "ipfs" => Ok(Either::Right(url)),
+            _ => Err(format!("Unsupported URL scheme: {}", url.scheme())),
+        }
+    } else {
+        Ok(Either::Left(PathBuf::from(s)))
+    }
+}

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

@@ -1,7 +1,9 @@
+pub mod call;
 pub mod deploy;
 pub mod run;
 pub mod submit;
 
+pub use call::Command as Call;
 pub use deploy::Command as Deploy;
 pub use run::Command as Run;
 pub use submit::Command as Submit;

forc-plugins/forc-client/src/constants.rs

@@ -1,12 +1,15 @@
 /// Default to localhost to favour the common case of testing.
 pub const NODE_URL: &str = sway_utils::constants::DEFAULT_NODE_URL;
-pub const TESTNET_ENDPOINT_URL: &str = "https://testnet.fuel.network";
+
 pub const MAINNET_ENDPOINT_URL: &str = "https://mainnet.fuel.network";
+pub const TESTNET_ENDPOINT_URL: &str = "https://testnet.fuel.network";
+pub const DEVNET_ENDPOINT_URL: &str = "https://devnet.fuel.network";
 
 pub const TESTNET_FAUCET_URL: &str = "https://faucet-testnet.fuel.network";
+pub const DEVNET_FAUCET_URL: &str = "https://faucet-devnet.fuel.network";
 
-pub const TESTNET_EXPLORER_URL: &str = "https://app-testnet.fuel.network";
 pub const MAINNET_EXPLORER_URL: &str = "https://app.fuel.network";
+pub const TESTNET_EXPLORER_URL: &str = "https://app-testnet.fuel.network";
 
 /// Default PrivateKey to sign transactions submitted to local node.
 pub const DEFAULT_PRIVATE_KEY: &str =