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