use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use alloy_primitives::Address;
use alloy_signer_local::PrivateKeySigner;
use zeroize::Zeroizing;
use taskfast_agent::keystore::{self, KeySource};
use super::CmdError;
static PWD_WARNING_EMITTED: AtomicBool = AtomicBool::new(false);
pub fn resolve_keystore_path(
cli_keystore: Option<&str>,
ctx_keystore: Option<&Path>,
) -> Option<PathBuf> {
let raw = cli_keystore
.map(str::to_string)
.or_else(|| ctx_keystore.and_then(|p| p.to_str().map(str::to_string)))?;
let path_str = raw.strip_prefix("file:").unwrap_or(&raw);
Some(PathBuf::from(path_str))
}
pub fn validate_signer_address(
signer_address: Address,
expected_address: Option<&str>,
) -> Result<(), CmdError> {
if let Some(expected) = expected_address {
let expected_addr: Address = expected.parse().map_err(|e| {
CmdError::Usage(format!("--wallet-address is not a valid EVM address: {e}"))
})?;
if signer_address != expected_addr {
return Err(CmdError::Usage(format!(
"keystore address {:#x} does not match --wallet-address {}",
signer_address, expected
)));
}
}
Ok(())
}
pub fn load_signer_and_validate(
keystore_path: Option<&Path>,
password_file: Option<&Path>,
expected_address: Option<&str>,
purpose: &str,
) -> Result<PrivateKeySigner, CmdError> {
let signer = load_signer(keystore_path, password_file, purpose)?;
validate_signer_address(signer.address(), expected_address)?;
Ok(signer)
}
pub fn load_signer(
keystore_path: Option<&Path>,
password_file: Option<&Path>,
purpose: &str,
) -> Result<PrivateKeySigner, CmdError> {
let path = keystore_path.ok_or_else(|| {
CmdError::Usage(format!(
"--keystore (or TEMPO_KEY_SOURCE) is required to sign the {purpose}"
))
})?;
let password = resolve_password(password_file)?;
keystore::load(
&KeySource::File {
path: path.to_path_buf(),
},
&password,
)
.map_err(CmdError::from)
}
pub fn resolve_password_with_inline(
inline_password: Option<&str>,
password_file: Option<&Path>,
) -> Result<Zeroizing<String>, CmdError> {
resolve_password_with_inline_and_missing_hint(
inline_password,
password_file,
"TASKFAST_WALLET_PASSWORD or --wallet-password-file required to unlock keystore",
)
}
pub fn resolve_password_with_inline_and_missing_hint(
inline_password: Option<&str>,
password_file: Option<&Path>,
missing_msg: &str,
) -> Result<Zeroizing<String>, CmdError> {
if let Some(pw) = inline_password {
let trimmed = pw.trim_end_matches(['\n', '\r']);
if !trimmed.is_empty() {
if trimmed.contains('\n') || trimmed.contains('\r') {
return Err(CmdError::Usage(
"inline wallet password must contain a single line (found an interior newline)"
.into(),
));
}
return Ok(Zeroizing::new(trimmed.to_string()));
}
}
if let Ok(pw) = std::env::var("TASKFAST_WALLET_PASSWORD") {
if !pw.is_empty() {
warn_pwd_env_once();
return Ok(Zeroizing::new(pw));
}
}
let path = password_file.ok_or_else(|| CmdError::Usage(missing_msg.into()))?;
let raw = Zeroizing::new(std::fs::read_to_string(path).map_err(|e| {
CmdError::Usage(format!(
"cannot read wallet password file {}: {e}",
path.display()
))
})?);
let trimmed = raw.trim_end_matches(['\n', '\r']);
if trimmed.is_empty() {
return Err(CmdError::Usage(format!(
"wallet password file {} is empty",
path.display()
)));
}
if trimmed.contains('\n') || trimmed.contains('\r') {
return Err(CmdError::Usage(format!(
"wallet password file {} must contain a single line (found an interior newline)",
path.display()
)));
}
Ok(Zeroizing::new(trimmed.to_string()))
}
pub fn resolve_password(password_file: Option<&Path>) -> Result<Zeroizing<String>, CmdError> {
resolve_password_with_inline(None, password_file)
}
fn warn_pwd_env_once() {
if std::env::var("TASKFAST_SUPPRESS_PWD_WARNING").is_ok_and(|v| v == "1") {
return;
}
if PWD_WARNING_EMITTED.swap(true, Ordering::Relaxed) {
return;
}
eprintln!(
"warning: TASKFAST_WALLET_PASSWORD is readable via /proc/<pid>/environ; \
prefer --wallet-password-file (TASKFAST_WALLET_PASSWORD_FILE) or set \
TASKFAST_SUPPRESS_PWD_WARNING=1 to silence."
);
}
pub fn decode_0x_bytes(s: &str) -> Result<Vec<u8>, String> {
let stripped = s.strip_prefix("0x").unwrap_or(s);
hex::decode(stripped).map_err(|e| e.to_string())
}
pub async fn resolve_proxy_rpc_url(
client: &taskfast_client::TaskFastClient,
ctx: &super::Ctx,
) -> Result<String, CmdError> {
let cfg = client.fetch_network_config().await.map_err(|e| match e {
taskfast_client::Error::Auth(_) | taskfast_client::Error::Validation { .. } => {
CmdError::Server(format!("fetch network config from {}: {e}", ctx.base_url()))
}
other => CmdError::from(other),
})?;
let name = ctx.environment.network().as_str();
if !ctx.allow_custom_endpoints
&& ctx.environment != crate::Environment::Local
&& cfg.networks.len() != 1
{
let advertised: Vec<&str> = cfg.networks.keys().map(String::as_str).collect();
let strict = std::env::var("TASKFAST_STRICT_ENV_NETWORK")
.is_ok_and(|v| v == "1" || v.eq_ignore_ascii_case("true"));
if strict {
return Err(CmdError::Server(format!(
"deployment at {} advertises networks {advertised:?}; env {} requires \
exactly [{name}]. Server-side fix tracked in issue #62. Unset \
TASKFAST_STRICT_ENV_NETWORK or pass --allow-custom-endpoints to bypass.",
ctx.base_url(),
ctx.environment.as_str(),
)));
}
tracing::warn!(
api_base = %ctx.base_url(),
env = ctx.environment.as_str(),
expected = name,
advertised = ?advertised,
"deployment advertises additional networks; server-side fix tracked in #62. \
Set TASKFAST_STRICT_ENV_NETWORK=1 to fail-closed."
);
}
let entry = cfg.entry(name).map_err(|e| {
CmdError::Server(format!(
"deployment at {} does not advertise network `{name}`: {e}",
ctx.base_url()
))
})?;
if !super::is_proxy_rpc_url(&entry.rpc_url, ctx.base_url()) {
return Err(CmdError::Server(format!(
"deployment at {} returned rpc_url {:?} for network `{name}`, \
which is not on the same host. Refusing to route RPC traffic \
off-host.",
ctx.base_url(),
entry.rpc_url,
)));
}
Ok(entry.rpc_url.clone())
}
pub async fn sign_and_send_submission_fee(
ctx: &super::Ctx,
client: &taskfast_client::TaskFastClient,
rpc_url: &str,
keystore_path: Option<PathBuf>,
signer: PrivateKeySigner,
token_address_str: &str,
calldata: alloy_primitives::Bytes,
) -> Result<alloy_primitives::B256, CmdError> {
let token_address: Address = token_address_str.parse().map_err(|e| {
CmdError::Server(format!(
"server returned invalid token_address `{token_address_str}`: {e}"
))
})?;
let http = ctx.rpc_http_client(client, rpc_url);
let rpc = taskfast_agent::tempo_rpc::TempoRpcClient::new(http, rpc_url.to_string());
let chain_id = rpc
.chain_id()
.await
.map_err(|e| CmdError::Server(format!("tempo rpc eth_chainId: {e}")))?;
if !ctx.allow_custom_endpoints && !taskfast_chains::tempo::is_known_network(chain_id) {
return Err(CmdError::Validation {
code: "unknown_chain".into(),
message: format!(
"RPC reports chain_id={chain_id} which is not a known Tempo or \
local-dev network; refusing to sign. Pass --allow-custom-endpoints \
to override."
),
});
}
if !taskfast_chains::tempo::is_allowed_fee_token(chain_id, token_address_str) {
return Err(CmdError::Validation {
code: "fee_token_not_allowed".into(),
message: format!(
"server returned token_address {token_address_str} which is not on the PathUSD \
allowlist for chain_id={chain_id}. Refusing to sign — this would \
redirect your fee transfer to an arbitrary ERC-20 contract."
),
});
}
eprintln!(
"taskfast: signing submission-fee transfer — token={} chain_id={} rpc={}",
token_address_str, chain_id, rpc_url
);
let session = crate::tempo_session::TempoSession::new(
signer,
keystore_path,
rpc,
std::time::Duration::from_mins(1),
);
let tx_hash = session.send_transaction(token_address, calldata).await?;
Ok(tx_hash)
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::Write;
fn write_temp(contents: &str) -> tempfile::NamedTempFile {
let mut f = tempfile::NamedTempFile::new().expect("tempfile");
f.write_all(contents.as_bytes()).unwrap();
f
}
static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
#[test]
fn password_env_wins_over_file() {
let _g = ENV_LOCK.lock().unwrap();
let f = write_temp("from-file\n");
std::env::set_var("TASKFAST_WALLET_PASSWORD", "from-env");
let pw = resolve_password(Some(f.path())).expect("ok");
assert_eq!(pw.as_str(), "from-env");
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
}
#[test]
fn password_file_trimmed_when_env_absent() {
let _g = ENV_LOCK.lock().unwrap();
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
let f = write_temp("secret\r\n");
let pw = resolve_password(Some(f.path())).expect("ok");
assert_eq!(pw.as_str(), "secret");
}
#[test]
fn password_rejects_interior_newline() {
let _g = ENV_LOCK.lock().unwrap();
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
let f = write_temp("first-line\nsecond-line\n");
let err = resolve_password(Some(f.path())).expect_err("multi-line must fail");
match err {
CmdError::Usage(m) => assert!(
m.contains("single line"),
"message must name the constraint: {m}"
),
other => panic!("expected Usage, got {other:?}"),
}
}
#[test]
fn password_rejects_interior_carriage_return() {
let _g = ENV_LOCK.lock().unwrap();
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
let f = write_temp("annotation\r\nsecret\n");
let err = resolve_password(Some(f.path())).expect_err("must fail");
assert!(matches!(err, CmdError::Usage(_)), "got {err:?}");
}
#[test]
fn password_is_zeroizing_wrapped() {
let _g = ENV_LOCK.lock().unwrap();
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
let f = write_temp("scrubme\n");
let pw = resolve_password(Some(f.path())).expect("ok");
let name = std::any::type_name_of_val(&pw);
assert!(
name.contains("Zeroizing"),
"password must be Zeroizing: {name}"
);
}
#[test]
fn password_rejects_empty_file() {
let _g = ENV_LOCK.lock().unwrap();
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
let f = write_temp("\n\n");
let err = resolve_password(Some(f.path())).expect_err("empty must fail");
assert!(matches!(err, CmdError::Usage(_)), "got {err:?}");
}
#[test]
fn password_requires_file_when_env_absent() {
let _g = ENV_LOCK.lock().unwrap();
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
let err = resolve_password(None).expect_err("no source → Usage");
assert!(matches!(err, CmdError::Usage(_)), "got {err:?}");
}
#[test]
fn load_signer_missing_keystore_surfaces_purpose() {
let err = load_signer(None, None, "escrow approval").expect_err("no keystore → Usage");
match err {
CmdError::Usage(m) => {
assert!(m.contains("escrow approval"), "purpose must appear: {m}")
}
other => panic!("expected Usage, got {other:?}"),
}
}
#[test]
fn inline_password_wins_and_rejects_interior_newlines() {
let _g = ENV_LOCK.lock().unwrap();
std::env::set_var("TASKFAST_WALLET_PASSWORD", "from-env");
let pw = resolve_password_with_inline(Some("inline-secret\n"), None).expect("ok");
assert_eq!(pw.as_str(), "inline-secret");
let err = resolve_password_with_inline(Some("first\nsecond"), None)
.expect_err("interior newline must fail");
assert!(matches!(err, CmdError::Usage(m) if m.contains("single line")));
std::env::remove_var("TASKFAST_WALLET_PASSWORD");
}
#[test]
fn resolve_keystore_helpers() {
assert_eq!(
resolve_keystore_path(Some("file:/tmp/key.json"), None),
Some(PathBuf::from("/tmp/key.json"))
);
assert_eq!(
resolve_keystore_path(Some("/tmp/key.json"), None),
Some(PathBuf::from("/tmp/key.json"))
);
assert_eq!(
resolve_keystore_path(None, Some(Path::new("/etc/key.json"))),
Some(PathBuf::from("/etc/key.json"))
);
}
#[test]
fn validate_signer_address_checks() {
let addr = Address::repeat_byte(0x11);
validate_signer_address(addr, None).expect("no expected address passes");
validate_signer_address(addr, Some(&format!("{addr:#x}")))
.expect("matching address passes");
let err = validate_signer_address(addr, Some("not-hex")).expect_err("invalid address");
assert!(matches!(err, CmdError::Usage(m) if m.contains("not a valid EVM address")));
let mismatch = Address::repeat_byte(0x22);
let err = validate_signer_address(addr, Some(&format!("{mismatch:#x}")))
.expect_err("mismatch must fail");
assert!(matches!(err, CmdError::Usage(m) if m.contains("does not match --wallet-address")));
}
}