use std::path::PathBuf;
use std::str::FromStr;
use alloy_primitives::{Address, B256, U256};
use clap::Parser;
use serde_json::json;
use uuid::Uuid;
use super::{CmdError, CmdResult, Ctx};
use crate::envelope::Envelope;
use taskfast_agent::bootstrap;
use taskfast_chains::tempo::{sign_distribution, DistributionDomain};
use taskfast_client::api::types::SettleTaskBody;
use taskfast_client::map_api_error;
#[derive(Debug, Parser)]
pub struct Args {
pub task_id: String,
#[arg(long)]
pub deadline_unix: Option<u64>,
#[arg(long, env = "TEMPO_KEY_SOURCE")]
pub keystore: Option<String>,
#[arg(long, env = "TASKFAST_WALLET_PASSWORD_FILE")]
pub wallet_password_file: Option<PathBuf>,
#[arg(long, env = "TEMPO_WALLET_ADDRESS")]
pub wallet_address: Option<String>,
#[arg(long)]
pub yes: bool,
}
pub async fn run(ctx: &Ctx, args: Args) -> CmdResult {
let task_id = Uuid::parse_str(&args.task_id)
.map_err(|e| CmdError::Usage(format!("task id must be a UUID: {e}")))?;
let client = ctx.client()?;
let task = match client.inner().get_task(&task_id).await {
Ok(v) => v.into_inner(),
Err(e) => return Err(map_api_error(e).await.into()),
};
ctx.enforce_budget_gate(task.budget_max.as_deref(), args.yes, "settle this task")?;
let escrow_id_hex: String = match task.escrow_id.as_ref().map(|e| e.to_string()) {
Some(e) => e,
None => {
if let Some(note) = task.status.as_deref().and_then(settlement_note) {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"task_id": task_id.to_string(),
"status": task.status,
"note": note,
}),
));
}
return Err(CmdError::Usage(
"task has no escrow_id; settle requires an initialized escrow \
(task must be in :complete or :disbursement_pending)"
.into(),
));
}
};
let deadline_unix: u64 = match args.deadline_unix {
Some(n) => n,
None => {
let dt = task.settlement_deadline.ok_or_else(|| {
CmdError::Usage(
"task has no settlement_deadline; either wait for escrow \
creation or pass --deadline-unix explicitly"
.into(),
)
})?;
u64::try_from(dt.timestamp()).map_err(|_| {
CmdError::Decode(format!(
"task settlement_deadline is before epoch: {}",
dt.to_rfc3339()
))
})?
}
};
let (raw_chain_id, verifying_contract_str): (i64, String) =
match task.settlement_domain.as_ref() {
Some(d) => (d.chain_id, d.verifying_contract.to_string()),
None => {
let readiness = bootstrap::get_readiness(&client)
.await
.map_err(CmdError::from)?;
let d = readiness.settlement_domain;
(d.chain_id, d.verifying_contract.to_string())
}
};
let verifying_contract: Address = verifying_contract_str.parse().map_err(|e| {
CmdError::Decode(format!(
"settlement domain has invalid verifying_contract `{verifying_contract_str}`: {e}"
))
})?;
let chain_id: u64 = u64::try_from(raw_chain_id).map_err(|_| {
CmdError::Decode(format!(
"settlement domain has negative chain_id: {raw_chain_id}"
))
})?;
let domain = DistributionDomain::new(chain_id, verifying_contract);
let escrow_id: B256 = B256::from_str(&escrow_id_hex).map_err(|e| {
CmdError::Decode(format!(
"server returned invalid escrow_id `{escrow_id_hex}`: {e}"
))
})?;
let deadline = U256::from(deadline_unix);
let keystore_path = super::wallet_args::resolve_keystore_path(
args.keystore.as_deref(),
ctx.keystore_path.as_deref(),
);
let signer = super::wallet_args::load_signer_and_validate(
keystore_path.as_deref(),
args.wallet_password_file.as_deref(),
args.wallet_address
.as_deref()
.or(ctx.wallet_address.as_deref()),
"settlement approval",
)?;
let signature_hex = sign_distribution(&signer, &domain, escrow_id, deadline)?;
if ctx.dry_run {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"action": "would_settle",
"task_id": task_id.to_string(),
"escrow_id": escrow_id_hex,
"deadline": deadline_unix,
"domain": {
"chain_id": chain_id,
"verifying_contract": verifying_contract_str,
},
"signature": signature_hex,
}),
));
}
let body = SettleTaskBody {
signature: signature_hex,
};
let resp = match client.inner().settle_task(&task_id, &body).await {
Ok(v) => v.into_inner(),
Err(e) => {
let err = map_api_error(e).await;
if matches!(&err, taskfast_client::Error::Validation { code, .. }
if matches!(code.as_str(), "task_not_eligible" | "escrow_not_ready"))
{
if let Ok(advanced) = client.inner().get_task(&task_id).await {
let advanced = advanced.into_inner();
if let Some(note) = advanced.status.as_deref().and_then(settlement_note) {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"task_id": task_id.to_string(),
"status": advanced.status,
"note": note,
}),
));
}
}
}
return Err(err.into());
}
};
Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"task_id": resp.task_id,
"status": resp.status,
}),
))
}
fn settlement_note(status: &str) -> Option<&'static str> {
match status {
"settled" => Some("already settled"),
"disbursement_pending" => Some("settlement underway"),
_ => None,
}
}