1use std::path::PathBuf;
24
25use alloy_primitives::{Address, Bytes};
26use clap::Parser;
27use serde_json::json;
28
29use super::wallet_args::{decode_0x_bytes, resolve_proxy_rpc_url, sign_and_send_submission_fee};
30use super::{validate_override_rpc_url, CmdError, CmdResult, Ctx};
31use crate::envelope::Envelope;
32
33use taskfast_client::api::types::{
34 CompletionCriterionInput, TaskDraftPrepareRequest, TaskDraftPrepareRequestAssignmentType,
35 TaskDraftPrepareRequestPickupDeadlineHours, TaskDraftSubmitRequest,
36 TaskDraftSubmitRequestSignature,
37};
38use taskfast_client::map_api_error;
39
40#[derive(Debug, Parser)]
41pub struct Args {
42 #[arg(long)]
44 pub title: String,
45
46 #[arg(long)]
49 pub description: String,
50
51 #[arg(long)]
54 pub budget: Option<String>,
55
56 #[arg(long, value_delimiter = ',')]
58 pub capabilities: Vec<String>,
59
60 #[arg(long = "criterion")]
66 pub criteria: Vec<String>,
67
68 #[arg(long)]
73 pub criteria_file: Option<PathBuf>,
74
75 #[arg(long)]
79 pub pickup_deadline_hours: i64,
80
81 #[arg(long)]
83 pub execution_deadline: Option<String>,
84
85 #[arg(long)]
90 pub venue: Option<String>,
91
92 #[arg(long, env = "TEMPO_WALLET_ADDRESS")]
95 pub wallet_address: Option<String>,
96
97 #[arg(long, env = "TEMPO_KEY_SOURCE")]
101 pub keystore: Option<String>,
102
103 #[arg(long, env = "TASKFAST_WALLET_PASSWORD_FILE")]
107 pub wallet_password_file: Option<PathBuf>,
108
109 #[arg(long, env = "TEMPO_RPC_URL")]
112 pub rpc_url: Option<String>,
113
114 #[arg(long)]
119 pub yes: bool,
120}
121
122fn pickup_hours_to_wire(
127 hours: i64,
128) -> Result<TaskDraftPrepareRequestPickupDeadlineHours, CmdError> {
129 TaskDraftPrepareRequestPickupDeadlineHours::try_from(hours).map_err(|_| CmdError::Validation {
130 code: "pickup_deadline_invalid".into(),
131 message: format!(
132 "pickup window of {hours}h is not an allowed bidding window per the \
133 API contract; the server owns the valid set (422 pickup_deadline_required)"
134 ),
135 })
136}
137
138pub async fn run(ctx: &Ctx, args: Args) -> CmdResult {
139 let pre = preflight(ctx, &args)?;
143
144 let prep_body = TaskDraftPrepareRequest {
145 assignment_type: TaskDraftPrepareRequestAssignmentType::default(),
146 budget_max: args.budget.clone(),
147 completion_criteria: pre.completion_criteria,
148 description: args.description.clone(),
149 direct_agent_id: None,
150 execution_deadline: pre.execution_deadline,
151 pickup_deadline_hours: pre.pickup_hours,
152 poster_wallet_address: pre
153 .wallet_address
154 .parse()
155 .map_err(|e| CmdError::Usage(format!("--wallet-address rejected by schema: {e}")))?,
156 required_capabilities: args.capabilities.clone(),
157 settlement_venue: args.venue.clone(),
158 title: args.title.clone(),
159 };
160
161 if ctx.dry_run {
164 let rpc_url = match pre.rpc_url_override {
165 Some(override_url) => override_url,
166 None => format!(
167 "{}/rpc/{}",
168 ctx.base_url().trim_end_matches('/'),
169 ctx.environment.network().as_str()
170 ),
171 };
172 return Ok(Envelope::success(
173 ctx.environment,
174 ctx.dry_run,
175 json!({
176 "action": "would_post",
177 "draft_id": serde_json::Value::Null,
178 "title": args.title,
179 "budget_max": args.budget,
180 "settlement_venue": args.venue,
181 "required_capabilities": args.capabilities,
182 "completion_criteria_count": prep_body.completion_criteria.len(),
183 "rpc_url": rpc_url,
184 "wallet_address": pre.wallet_address,
185 }),
186 ));
187 }
188
189 let client = ctx.client()?;
190
191 let rpc_url = match pre.rpc_url_override {
196 Some(override_url) => override_url,
197 None => resolve_proxy_rpc_url(&client, ctx).await?,
198 };
199
200 let prep = match client.inner().prepare_task_draft(&prep_body).await {
202 Ok(r) => r.into_inner(),
203 Err(e) => return Err(map_api_error(e).await.into()),
204 };
205
206 let calldata = decode_0x_bytes(&prep.payload_to_sign)
207 .map_err(|e| CmdError::Server(format!("server returned invalid payload_to_sign: {e}")))?;
208
209 let keystore_path = super::wallet_args::resolve_keystore_path(
212 args.keystore.as_deref(),
213 ctx.keystore_path.as_deref(),
214 );
215 let signer = super::wallet_args::load_signer_and_validate(
216 keystore_path.as_deref(),
217 args.wallet_password_file.as_deref(),
218 Some(&pre.wallet_address),
219 "submission fee",
220 )?;
221
222 let tx_hash = sign_and_send_submission_fee(
223 ctx,
224 &client,
225 &rpc_url,
226 keystore_path,
227 signer,
228 &prep.token_address,
229 Bytes::from(calldata),
230 )
231 .await?;
232 let tx_hash_hex = format!("{tx_hash:#x}");
233
234 let signature: TaskDraftSubmitRequestSignature = tx_hash_hex
237 .parse()
238 .map_err(|e| CmdError::Server(format!("tx hash rejected by schema pattern: {e}")))?;
239 let submit_body = TaskDraftSubmitRequest { signature };
240 let submitted = match client
241 .inner()
242 .submit_task_draft(&prep.draft_id, &submit_body)
243 .await
244 {
245 Ok(r) => r.into_inner(),
246 Err(e) => return Err(map_api_error(e).await.into()),
247 };
248
249 let blocked = submitted.status == "blocked_on_submission_fee_debt";
257 if blocked {
258 eprintln!(
261 "taskfast: task {} parked at blocked_on_submission_fee_debt — \
262 submission-fee transfer confirming on-chain; it opens automatically \
263 once confirmed. Poll `taskfast task get {}`.",
264 submitted.id, submitted.id
265 );
266 }
267 let message = blocked.then(|| {
268 "Task created. Submission fee transaction is pending on-chain \
269 confirmation before the task becomes actionable."
270 .to_string()
271 });
272
273 Ok(Envelope::success(
274 ctx.environment,
275 ctx.dry_run,
276 json!({
277 "task_id": submitted.id,
278 "draft_id": prep.draft_id,
279 "submission_fee_tx_hash": tx_hash_hex,
280 "status": submitted.status,
281 "submission_fee_status": submitted.submission_fee_status,
282 "message": message,
283 }),
284 ))
285}
286
287struct Preflight {
290 wallet_address: String,
291 execution_deadline: Option<jiff::Timestamp>,
292 completion_criteria: Vec<CompletionCriterionInput>,
293 pickup_hours: TaskDraftPrepareRequestPickupDeadlineHours,
294 rpc_url_override: Option<String>,
297}
298
299fn problem_text(e: &CmdError) -> String {
303 match e {
304 CmdError::Usage(m) => m.clone(),
305 CmdError::Validation { message, .. } => message.clone(),
306 other => other.to_string(),
307 }
308}
309
310fn preflight(ctx: &Ctx, args: &Args) -> Result<Preflight, CmdError> {
321 let mut problems: Vec<String> = Vec::new();
322 if args.description.trim().is_empty() {
327 problems.push(
328 "--description must not be empty (server requires a non-blank description)".into(),
329 );
330 }
331
332 if let Err(e) = ctx.enforce_budget_gate(args.budget.as_deref(), args.yes, "post a task") {
333 problems.push(problem_text(&e));
334 }
335
336 let wallet_address = match args
337 .wallet_address
338 .as_deref()
339 .or(ctx.wallet_address.as_deref())
340 {
341 Some(w) => match w.parse::<Address>() {
342 Ok(_) => Some(w.to_string()),
343 Err(e) => {
344 problems.push(format!("--wallet-address is not a valid EVM address: {e}"));
345 None
346 }
347 },
348 None => {
349 problems.push(
350 "--wallet-address (or TEMPO_WALLET_ADDRESS, or wallet_address in config) required to post a task".into(),
351 );
352 None
353 }
354 };
355
356 let execution_deadline =
357 match parse_iso_opt(args.execution_deadline.as_deref(), "--execution-deadline") {
358 Ok(v) => Some(v),
359 Err(e) => {
360 problems.push(problem_text(&e));
361 None
362 }
363 };
364
365 let completion_criteria = match resolve_criteria(args.criteria_file.as_deref(), &args.criteria)
366 {
367 Ok(v) => Some(v),
368 Err(e) => {
369 problems.push(problem_text(&e));
370 None
371 }
372 };
373
374 let pickup_hours = match pickup_hours_to_wire(args.pickup_deadline_hours) {
375 Ok(w) => Some(w),
376 Err(e) => {
377 problems.push(problem_text(&e));
378 None
379 }
380 };
381
382 let rpc_url_override = match args.rpc_url.as_deref() {
383 Some(u) => match validate_override_rpc_url(
384 u,
385 ctx.environment.network(),
386 ctx.allow_custom_endpoints,
387 ) {
388 Ok(u) => Some(Some(u.to_string())),
389 Err(e) => {
390 problems.push(problem_text(&e));
391 None
392 }
393 },
394 None => Some(None),
395 };
396
397 if !problems.is_empty() {
398 let n = problems.len();
399 let list = problems
400 .iter()
401 .enumerate()
402 .map(|(i, p)| format!(" {}. {p}", i + 1))
403 .collect::<Vec<_>>()
404 .join("\n");
405 return Err(CmdError::Usage(format!(
406 "post preflight found {n} problem{}:\n{list}",
407 if n == 1 { "" } else { "s" }
408 )));
409 }
410
411 Ok(Preflight {
412 wallet_address: wallet_address.expect("no problems ⇒ wallet present"),
413 execution_deadline: execution_deadline.expect("no problems ⇒ deadline resolved"),
414 completion_criteria: completion_criteria.expect("no problems ⇒ criteria resolved"),
415 pickup_hours: pickup_hours.expect("no problems ⇒ pickup hours valid"),
416 rpc_url_override: rpc_url_override.expect("no problems ⇒ rpc override resolved"),
417 })
418}
419
420fn resolve_criteria(
427 file: Option<&std::path::Path>,
428 inline: &[String],
429) -> Result<Vec<CompletionCriterionInput>, CmdError> {
430 let mut out = Vec::with_capacity(inline.len());
431 if let Some(path) = file {
432 let raw = std::fs::read_to_string(path).map_err(|e| {
433 CmdError::Usage(format!("read --criteria-file {}: {e}", path.display()))
434 })?;
435 let parsed: Vec<CompletionCriterionInput> = serde_json::from_str(&raw).map_err(|e| {
436 CmdError::Usage(format!(
437 "--criteria-file {} is not a JSON array of CompletionCriterionInput: {e}",
438 path.display()
439 ))
440 })?;
441 out.extend(parsed);
442 }
443 for (i, raw) in inline.iter().enumerate() {
444 let one: CompletionCriterionInput = serde_json::from_str(raw)
445 .map_err(|e| CmdError::Usage(format!("--criterion[{i}] not valid JSON: {e}")))?;
446 out.push(one);
447 }
448 Ok(out)
449}
450
451fn parse_iso_opt(s: Option<&str>, flag: &str) -> Result<Option<jiff::Timestamp>, CmdError> {
452 match s {
453 None => Ok(None),
454 Some(raw) => raw
455 .parse::<jiff::Timestamp>()
456 .map(Some)
457 .map_err(|e| CmdError::Usage(format!("{flag} not a valid RFC3339 timestamp: {e}"))),
458 }
459}
460
461#[cfg(test)]
462mod tests {
463 use super::*;
464 use crate::Network;
465
466 #[test]
467 fn validate_override_rejects_without_opt_in() {
468 let err = validate_override_rpc_url("https://mallory.example", Network::Mainnet, false)
469 .expect_err("override without opt-in must be refused");
470 match err {
471 CmdError::Usage(msg) => {
472 assert!(msg.contains("--allow-custom-endpoints"), "msg: {msg}");
473 }
474 other => panic!("expected Usage, got {other:?}"),
475 }
476 }
477
478 #[test]
479 fn validate_override_accepts_with_opt_in() {
480 validate_override_rpc_url("https://my-node.example", Network::Testnet, true)
481 .expect("opt-in bypasses the guard");
482 }
483
484 #[test]
485 fn validate_override_rejects_plain_http_on_mainnet() {
486 let err = validate_override_rpc_url("http://my-node.example", Network::Mainnet, true)
487 .expect_err("plain-http on mainnet is always refused (except loopback)");
488 assert!(matches!(err, CmdError::Usage(msg) if msg.contains("plain-HTTP")));
489 }
490
491 #[test]
492 fn validate_override_allows_plain_http_loopback_on_mainnet() {
493 validate_override_rpc_url("http://127.0.0.1:8545", Network::Mainnet, true)
494 .expect("loopback bypasses mainnet-HTTPS check");
495 validate_override_rpc_url("http://localhost:8545", Network::Mainnet, true)
496 .expect("loopback bypasses mainnet-HTTPS check");
497 }
498
499 #[test]
500 fn validate_override_allows_plain_http_on_testnet() {
501 validate_override_rpc_url("http://my-testnet.example", Network::Testnet, true)
502 .expect("testnet does not enforce HTTPS");
503 }
504
505 #[test]
506 fn parse_iso_accepts_rfc3339_deadline() {
507 let got = parse_iso_opt(Some("2026-03-01T12:00:00Z"), "--execution-deadline").unwrap();
508 assert_eq!(
509 got.map(|d| d.to_string()),
510 Some("2026-03-01T12:00:00Z".into())
511 );
512 }
513
514 #[test]
515 fn parse_iso_rejects_non_rfc3339_and_passes_none_through() {
516 assert!(parse_iso_opt(Some("tomorrow"), "--execution-deadline").is_err());
517 assert!(parse_iso_opt(None, "--execution-deadline")
518 .unwrap()
519 .is_none());
520 }
521
522 #[test]
523 fn pickup_hours_conversion_follows_api_contract() {
524 let err = pickup_hours_to_wire(3).expect_err("3 is outside the contract set");
528 assert!(matches!(err, CmdError::Validation { .. }));
529 let wire = pickup_hours_to_wire(24).expect("24 is contract-valid");
531 assert_eq!(i64::from(wire), 24);
532 }
533
534 #[test]
535 fn network_name_matches_config_map_keys() {
536 assert_eq!(Network::Mainnet.as_str(), "mainnet");
539 assert_eq!(Network::Testnet.as_str(), "testnet");
540 }
541}