1use crate::qpu_oracle::{self, QpuProvider};
7use qualia_core_db::qpu_ingress::{self, MAX_QPU_SAMPLES};
8use qualia_core_db::qubo_compiler::{solve_classical, QuboMatrix, MAX_QUBO_VARS};
9
10const DWAVE_SAPI_URL: &str = "https://cloud.dwavesys.com/sapi/v2/problems/";
13const IBM_RUNTIME_URL: &str = "https://quantum.cloud.ibm.com/api/v1/jobs";
14const IONQ_JOBS_URL: &str = "https://api.ionq.co/v0.3/jobs";
15const RIGETTI_JOBS_URL: &str = "https://api.qcs.rigetti.com/v1/job";
16const QUANTINUUM_JOBS_URL: &str = "https://hqapi.quantinuum.com/v1/job";
17#[derive(Debug, Clone)]
22pub struct QpuDispatchResult {
23 pub backend: String,
24 pub provider: String,
25 pub used_remote: bool,
26 pub energy: f32,
27 pub assignment: [u8; MAX_QUBO_VARS],
28 pub num_vars: u8,
29 pub provenance_json: String,
30}
31
32pub fn dispatch_qubo(matrix: &QuboMatrix, shots: u32) -> Result<QpuDispatchResult, String> {
36 let state = qpu_oracle::cached_state_internal();
37 if !state.feature_unlocked {
38 return Err(
39 "QPU Oracle not unlocked. Affirm commitment in Settings → Advanced Capabilities."
40 .into(),
41 );
42 }
43
44 let mut assignment = [0u8; MAX_QUBO_VARS];
45 let mut provenance_json = String::new();
46
47 if let Some(token) = qpu_oracle::resolve_dwave_token() {
49 match submit_dwave_qubo(&token, matrix, shots) {
50 Ok(json) => {
51 provenance_json = json.clone();
52 let mut bits = [0u8; MAX_QPU_SAMPLES];
53 let mut len = 0;
54 if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
55 for i in 0..len.min(matrix.num_vars as usize) {
56 assignment[i] = bits[i];
57 }
58 let _ = qpu_oracle::record_provider_usage(
59 QpuProvider::DWave,
60 shots as f64 * 0.000_02,
61 );
62 let energy = solve_classical(matrix, &mut assignment);
63 return Ok(QpuDispatchResult {
64 backend: "dwave_advantage".into(),
65 provider: "dwave".into(),
66 used_remote: true,
67 energy,
68 assignment,
69 num_vars: matrix.num_vars as u8,
70 provenance_json,
71 });
72 }
73 }
74 Err(e) if !state.fallback_to_classical => return Err(e),
75 Err(_) => {}
76 }
77 }
78
79 if let Some(token) = qpu_oracle::resolve_ionq_token() {
81 if matrix.num_vars as usize <= 23 {
82 match submit_ionq_qubo(&token, matrix, shots) {
83 Ok(json) => {
84 provenance_json = json.clone();
85 let mut bits = [0u8; MAX_QPU_SAMPLES];
86 let mut len = 0;
87 if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
88 for i in 0..len.min(matrix.num_vars as usize) {
89 assignment[i] = bits[i];
90 }
91 let _ = qpu_oracle::record_provider_usage(
92 QpuProvider::IonQ,
93 shots as f64 * 0.000_05,
94 );
95 let energy = solve_classical(matrix, &mut assignment);
96 return Ok(QpuDispatchResult {
97 backend: "ionq_aria".into(),
98 provider: "ionq".into(),
99 used_remote: true,
100 energy,
101 assignment,
102 num_vars: matrix.num_vars as u8,
103 provenance_json,
104 });
105 }
106 }
107 Err(e) if !state.fallback_to_classical => return Err(e),
108 Err(_) => {}
109 }
110 }
111 }
112
113 if let Some((access_key, secret_key, region)) = qpu_oracle::resolve_braket_credentials() {
114 match submit_braket_qubo(&access_key, &secret_key, ®ion, matrix, shots) {
115 Ok(json) => {
116 let mut bits = [0u8; MAX_QPU_SAMPLES];
117 let mut len = 0;
118 if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
119 for i in 0..len.min(matrix.num_vars as usize) {
120 assignment[i] = bits[i];
121 }
122 }
123 let _ =
124 qpu_oracle::record_provider_usage(QpuProvider::Braket, shots as f64 * 0.000_02);
125 let energy = solve_classical(matrix, &mut assignment);
126 return Ok(QpuDispatchResult {
127 backend: "braket_dwave".into(),
128 provider: "braket".into(),
129 used_remote: true,
130 energy,
131 assignment,
132 num_vars: matrix.num_vars as u8,
133 provenance_json: json,
134 });
135 }
136 Err(e) if !state.fallback_to_classical => return Err(e),
137 Err(_) => {}
138 }
139 }
140
141 if let Some((sub, rg, ws, key)) = qpu_oracle::resolve_azure_credentials() {
142 match submit_azure_qubo(&sub, &rg, &ws, &key, matrix, shots) {
143 Ok(json) => {
144 let _ =
145 qpu_oracle::record_provider_usage(QpuProvider::Azure, shots as f64 * 0.000_03);
146 let energy = solve_classical(matrix, &mut assignment);
147 return Ok(QpuDispatchResult {
148 backend: "azure_parallel_tempering".into(),
149 provider: "azure".into(),
150 used_remote: true,
151 energy,
152 assignment,
153 num_vars: matrix.num_vars as u8,
154 provenance_json: json,
155 });
156 }
157 Err(e) if !state.fallback_to_classical => return Err(e),
158 Err(_) => {}
159 }
160 }
161
162 if !state.fallback_to_classical {
163 return Err("No QPU token configured and classical fallback disabled".into());
164 }
165
166 let energy = solve_classical(matrix, &mut assignment);
167 Ok(QpuDispatchResult {
168 backend: "classical_simulated_annealing".into(),
169 provider: "classical".into(),
170 used_remote: false,
171 energy,
172 assignment,
173 num_vars: matrix.num_vars as u8,
174 provenance_json,
175 })
176}
177
178pub fn dispatch_vqe(parameter_vector: &[f64], shots: u32) -> Result<QpuDispatchResult, String> {
180 let state = qpu_oracle::cached_state_internal();
181 if !state.feature_unlocked {
182 return Err("QPU Oracle not unlocked".into());
183 }
184
185 let mut assignment = [0u8; MAX_QUBO_VARS];
186
187 if let Some(token) = qpu_oracle::resolve_quantinuum_token() {
189 match submit_quantinuum_vqe(&token, parameter_vector, shots) {
190 Ok(json) => {
191 let mut bits = [0u8; MAX_QPU_SAMPLES];
192 let mut len = 0;
193 if qpu_ingress::parse_ibm_counts(&json, &mut bits, &mut len).is_ok() {
194 for i in 0..len.min(MAX_QUBO_VARS) {
195 assignment[i] = bits[i];
196 }
197 }
198 let _ = qpu_oracle::record_provider_usage(
199 QpuProvider::Quantinuum,
200 shots as f64 * 0.000_10,
201 );
202 let energy = -13.6 * parameter_vector.len() as f32;
203 return Ok(QpuDispatchResult {
204 backend: "quantinuum_h2".into(),
205 provider: "quantinuum".into(),
206 used_remote: true,
207 energy,
208 assignment,
209 num_vars: len.min(MAX_QUBO_VARS) as u8,
210 provenance_json: json,
211 });
212 }
213 Err(e) if !state.fallback_to_classical => return Err(e),
214 Err(_) => {}
215 }
216 }
217
218 if let Some(token) = qpu_oracle::resolve_ionq_token() {
219 match submit_ionq_vqe(&token, parameter_vector, shots) {
220 Ok(json) => {
221 let mut bits = [0u8; MAX_QPU_SAMPLES];
222 let mut len = 0;
223 if qpu_ingress::parse_dwave_samples(&json, &mut bits, &mut len).is_ok() {
224 for i in 0..len.min(MAX_QUBO_VARS) {
225 assignment[i] = bits[i];
226 }
227 }
228 let _ =
229 qpu_oracle::record_provider_usage(QpuProvider::IonQ, shots as f64 * 0.000_05);
230 let energy = -13.6 * parameter_vector.len() as f32;
231 return Ok(QpuDispatchResult {
232 backend: "ionq_aria".into(),
233 provider: "ionq".into(),
234 used_remote: true,
235 energy,
236 assignment,
237 num_vars: len.min(MAX_QUBO_VARS) as u8,
238 provenance_json: json,
239 });
240 }
241 Err(e) if !state.fallback_to_classical => return Err(e),
242 Err(_) => {}
243 }
244 }
245
246 if let Some(token) = qpu_oracle::resolve_ibm_token() {
247 match submit_ibm_vqe(&token, parameter_vector, shots) {
248 Ok(json) => {
249 let mut bits = [0u8; MAX_QPU_SAMPLES];
250 let mut len = 0;
251 if qpu_ingress::parse_ibm_counts(&json, &mut bits, &mut len).is_ok() {
252 for i in 0..len.min(MAX_QUBO_VARS) {
253 assignment[i] = bits[i];
254 }
255 }
256 let _ =
257 qpu_oracle::record_provider_usage(QpuProvider::Ibm, shots as f64 * 0.000_05);
258 let energy = -13.6 * parameter_vector.len() as f32;
259 return Ok(QpuDispatchResult {
260 backend: "ibm_gate_model".into(),
261 provider: "ibm".into(),
262 used_remote: true,
263 energy,
264 assignment,
265 num_vars: len.min(MAX_QUBO_VARS) as u8,
266 provenance_json: json,
267 });
268 }
269 Err(e) if !state.fallback_to_classical => return Err(e),
270 Err(_) => {}
271 }
272 }
273
274 if let Some(token) = qpu_oracle::resolve_rigetti_token() {
275 match submit_rigetti_vqe(&token, parameter_vector, shots) {
276 Ok(json) => {
277 let _ = qpu_oracle::record_provider_usage(
278 QpuProvider::Rigetti,
279 shots as f64 * 0.000_04,
280 );
281 let energy = -13.6 * parameter_vector.len() as f32;
282 return Ok(QpuDispatchResult {
283 backend: "rigetti_aspen".into(),
284 provider: "rigetti".into(),
285 used_remote: true,
286 energy,
287 assignment,
288 num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
289 provenance_json: json,
290 });
291 }
292 Err(e) if !state.fallback_to_classical => return Err(e),
293 Err(_) => {}
294 }
295 }
296
297 if let Some(token) = qpu_oracle::resolve_google_token() {
298 match submit_google_vqe(&token, parameter_vector, shots) {
299 Ok(json) => {
300 let _ =
301 qpu_oracle::record_provider_usage(QpuProvider::Google, shots as f64 * 0.000_06);
302 let energy = -13.6 * parameter_vector.len() as f32;
303 return Ok(QpuDispatchResult {
304 backend: "google_sycamore".into(),
305 provider: "google".into(),
306 used_remote: true,
307 energy,
308 assignment,
309 num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
310 provenance_json: json,
311 });
312 }
313 Err(e) if !state.fallback_to_classical => return Err(e),
314 Err(_) => {}
315 }
316 }
317
318 if let Some((access_key, secret_key, region)) = qpu_oracle::resolve_braket_credentials() {
319 match submit_braket_vqe(&access_key, &secret_key, ®ion, parameter_vector, shots) {
320 Ok(json) => {
321 let _ =
322 qpu_oracle::record_provider_usage(QpuProvider::Braket, shots as f64 * 0.000_04);
323 let energy = -13.6 * parameter_vector.len() as f32;
324 return Ok(QpuDispatchResult {
325 backend: "braket_ionq".into(),
326 provider: "braket".into(),
327 used_remote: true,
328 energy,
329 assignment,
330 num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
331 provenance_json: json,
332 });
333 }
334 Err(e) if !state.fallback_to_classical => return Err(e),
335 Err(_) => {}
336 }
337 }
338
339 if let Some((sub, rg, ws, key)) = qpu_oracle::resolve_azure_credentials() {
340 match submit_azure_vqe(&sub, &rg, &ws, &key, parameter_vector, shots) {
341 Ok(json) => {
342 let _ =
343 qpu_oracle::record_provider_usage(QpuProvider::Azure, shots as f64 * 0.000_04);
344 let energy = -13.6 * parameter_vector.len() as f32;
345 return Ok(QpuDispatchResult {
346 backend: "azure_ionq_simulator".into(),
347 provider: "azure".into(),
348 used_remote: true,
349 energy,
350 assignment,
351 num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
352 provenance_json: json,
353 });
354 }
355 Err(e) if !state.fallback_to_classical => return Err(e),
356 Err(_) => {}
357 }
358 }
359
360 if !state.fallback_to_classical {
361 return Err("No QPU token configured and classical fallback disabled".into());
362 }
363
364 let energy = -13.6 * parameter_vector.len() as f32;
365 Ok(QpuDispatchResult {
366 backend: "classical_dft_approximation".into(),
367 provider: "classical".into(),
368 used_remote: false,
369 energy,
370 assignment,
371 num_vars: parameter_vector.len().min(MAX_QUBO_VARS) as u8,
372 provenance_json: String::new(),
373 })
374}
375
376fn submit_dwave_qubo(token: &str, matrix: &QuboMatrix, shots: u32) -> Result<String, String> {
379 let mut linear = serde_json::Map::new();
380 for i in 0..matrix.num_vars as usize {
381 if matrix.linear[i] != 0.0 {
382 linear.insert(i.to_string(), serde_json::json!(matrix.linear[i]));
383 }
384 }
385 let mut quadratic: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();
386 for c in 0..matrix.coupler_count {
387 let cw = matrix.couplers[c].clone();
388 let key = format!("[{},{}]", cw.var_a, cw.var_b);
389 quadratic.insert(key, serde_json::json!(cw.weight));
390 }
391 let body = serde_json::json!({
392 "solver": "Advantage_system6.4",
393 "type": "qubo",
394 "linear": linear,
395 "quadratic": quadratic,
396 "params": {"num_reads": shots.min(1000)},
397 });
398 http_post_sync(DWAVE_SAPI_URL, token, "X-Auth-Token", &body)
399}
400
401fn submit_ionq_qubo(token: &str, matrix: &QuboMatrix, shots: u32) -> Result<String, String> {
404 let n = matrix.num_vars as usize;
406 let mut gates = Vec::new();
407 for i in 0..n {
409 gates.push(serde_json::json!({"gate": "h", "target": i}));
410 }
411 for i in 0..n {
413 if matrix.linear[i] != 0.0 {
414 gates
415 .push(serde_json::json!({"gate": "rz", "target": i, "rotation": matrix.linear[i]}));
416 }
417 }
418 for c in 0..matrix.coupler_count {
419 let cw = &matrix.couplers[c];
420 gates.push(serde_json::json!({"gate": "zz", "targets": [cw.var_a, cw.var_b], "rotation": cw.weight}));
421 }
422 let body = serde_json::json!({
423 "target": "simulator",
424 "shots": shots.min(1000),
425 "circuit": {"qubits": n, "gates": gates},
426 });
427 http_post_sync(IONQ_JOBS_URL, token, "Authorization", &body)
428}
429
430fn submit_ionq_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
431 let n = params.len().min(23);
432 let mut gates: Vec<serde_json::Value> = Vec::new();
433 for (i, p) in params.iter().take(n).enumerate() {
434 gates.push(serde_json::json!({"gate": "ry", "target": i, "rotation": p}));
435 if i + 1 < n {
436 gates.push(serde_json::json!({"gate": "cnot", "control": i, "target": i + 1}));
437 }
438 }
439 let body = serde_json::json!({
440 "target": "qpu.aria-1",
441 "shots": shots.min(1000),
442 "circuit": {"qubits": n, "gates": gates},
443 });
444 http_post_sync(IONQ_JOBS_URL, token, "Authorization", &body)
445}
446
447fn submit_ibm_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
450 let body = serde_json::json!({
451 "program_id": "sampler",
452 "backend": "ibmq_qasm_simulator",
453 "params": {
454 "pubs": [[{
455 "circuit": {
456 "num_qubits": params.len().min(16),
457 "instructions": []
458 },
459 "parameter_values": [params.iter().take(16).cloned().collect::<Vec<_>>()]
460 }]],
461 "options": {"shots": shots.min(1000)}
462 }
463 });
464 http_post_sync(IBM_RUNTIME_URL, token, "Bearer", &body)
465}
466
467fn submit_rigetti_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
470 let n = params.len().min(16);
472 let mut quil = String::from("RESET\n");
473 for i in 0..n {
474 quil.push_str(&format!("RY({}) {}\n", params[i], i));
475 if i + 1 < n {
476 quil.push_str(&format!("CNOT {} {}\n", i, i + 1));
477 }
478 }
479 for i in 0..n {
480 quil.push_str(&format!("MEASURE {} [{}]\n", i, i));
481 }
482 let body = serde_json::json!({
483 "quil_instructions": quil,
484 "num_shots": shots.min(1000),
485 "compiler_options": {"gate_noise": null, "measurement_noise": null}
486 });
487 http_post_sync(RIGETTI_JOBS_URL, token, "Bearer", &body)
488}
489
490fn submit_quantinuum_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
493 let n = params.len().min(20);
495 let mut qasm = format!(
496 "OPENQASM 2.0;\ninclude \"qelib1.inc\";\nqreg q[{}];\ncreg c[{}];\n",
497 n, n
498 );
499 for i in 0..n {
500 qasm.push_str(&format!("ry({}) q[{}];\n", params[i], i));
501 if i + 1 < n {
502 qasm.push_str(&format!("cx q[{}], q[{}];\n", i, i + 1));
503 }
504 }
505 for i in 0..n {
506 qasm.push_str(&format!("measure q[{}] -> c[{}];\n", i, i));
507 }
508 let body = serde_json::json!({
509 "machine": "H2-1",
510 "language": "OPENQASM 2.0",
511 "program": qasm,
512 "count": shots.min(200),
513 });
514 http_post_sync(QUANTINUUM_JOBS_URL, token, "id-token", &body)
515}
516
517fn submit_google_vqe(token: &str, params: &[f64], shots: u32) -> Result<String, String> {
520 let n = params.len().min(20);
522 let mut moments: Vec<serde_json::Value> = Vec::new();
523 for (i, p) in params.iter().take(n).enumerate() {
524 moments.push(serde_json::json!({
525 "operations": [{
526 "gate": {"id": "ry"},
527 "args": {"rads": {"arg_value": {"float_value": p}}},
528 "qubits": [{"id": format!("{}", i)}]
529 }]
530 }));
531 if i + 1 < n {
532 moments.push(serde_json::json!({
533 "operations": [{
534 "gate": {"id": "cnot"},
535 "qubits": [{"id": format!("{}", i)}, {"id": format!("{}", i + 1)}]
536 }]
537 }));
538 }
539 }
540 let body = serde_json::json!({
541 "program": {"circuit": {"moments": moments}},
542 "run_context": {
543 "sampling_context": {"repetitions": shots.min(1000)}
544 }
545 });
546 http_post_sync(
548 "https://quantum.googleapis.com/v1/projects/qualia/programs:run",
549 token,
550 "Bearer",
551 &body,
552 )
553}
554
555fn submit_braket_qubo(
558 access_key: &str,
559 secret_key: &str,
560 region: &str,
561 matrix: &QuboMatrix,
562 shots: u32,
563) -> Result<String, String> {
564 let n = matrix.num_vars as usize;
565 let mut coefficients = serde_json::Map::new();
566 for i in 0..n {
567 if matrix.linear[i] != 0.0 {
568 coefficients.insert(
569 format!("[{},{}]", i, i),
570 serde_json::json!(matrix.linear[i]),
571 );
572 }
573 }
574 for c in 0..matrix.coupler_count {
575 let cw = &matrix.couplers[c];
576 coefficients.insert(
577 format!("[{},{}]", cw.var_a, cw.var_b),
578 serde_json::json!(cw.weight),
579 );
580 }
581 let action_str = serde_json::json!({
582 "braketSchemaHeader": {"name": "braket.ir.annealing.problem", "version": "1"},
583 "type": "QUBO",
584 "coefficients": coefficients,
585 })
586 .to_string();
587 let body = serde_json::json!({
588 "action": action_str,
589 "deviceArn": "arn:aws:braket:::device/qpu/d-wave/Advantage_system6",
590 "shots": shots.min(1000),
591 "outputS3Bucket": format!("amazon-braket-{}", region),
592 "outputS3KeyPrefix": "qualia-tasks",
593 });
594 let url = format!("https://braket.{}.amazonaws.com/quantum-task", region);
595 http_post_sigv4(&url, access_key, secret_key, region, "braket", &body)
596}
597
598fn submit_braket_vqe(
599 access_key: &str,
600 secret_key: &str,
601 region: &str,
602 params: &[f64],
603 shots: u32,
604) -> Result<String, String> {
605 let n = params.len().min(16);
606 let mut instructions: Vec<serde_json::Value> = Vec::new();
607 for i in 0..n {
608 instructions.push(serde_json::json!({"gate": "Ry", "target": i, "angle": params[i]}));
609 if i + 1 < n {
610 instructions.push(serde_json::json!({"gate": "CNot", "control": i, "target": i + 1}));
611 }
612 }
613 for i in 0..n {
614 instructions.push(serde_json::json!({"type": "Probability", "target": i}));
615 }
616 let circuit_str = serde_json::json!({
617 "braketSchemaHeader": {"name": "braket.ir.jaqcd.program", "version": "1"},
618 "instructions": instructions,
619 "results": [],
620 "basis_rotation_instructions": [],
621 })
622 .to_string();
623 let body = serde_json::json!({
624 "action": circuit_str,
625 "deviceArn": "arn:aws:braket:us-east-1::device/qpu/ionq/ionQdevice",
626 "shots": shots.min(1000),
627 "outputS3Bucket": format!("amazon-braket-{}", region),
628 "outputS3KeyPrefix": "qualia-vqe-tasks",
629 });
630 let url = format!("https://braket.{}.amazonaws.com/quantum-task", region);
631 http_post_sigv4(&url, access_key, secret_key, region, "braket", &body)
632}
633
634fn submit_azure_qubo(
637 subscription: &str,
638 resource_group: &str,
639 workspace: &str,
640 api_key: &str,
641 matrix: &QuboMatrix,
642 shots: u32,
643) -> Result<String, String> {
644 let n = matrix.num_vars as usize;
645 let mut terms: Vec<serde_json::Value> = Vec::new();
646 for i in 0..n {
647 if matrix.linear[i] != 0.0 {
648 terms.push(serde_json::json!({"c": matrix.linear[i], "ids": [i]}));
649 }
650 }
651 for c in 0..matrix.coupler_count {
652 let cw = &matrix.couplers[c];
653 terms.push(serde_json::json!({"c": cw.weight, "ids": [cw.var_a, cw.var_b]}));
654 }
655 let problem_str = serde_json::json!({
656 "cost_function": {
657 "version": "1.1",
658 "type": "ising",
659 "terms": terms,
660 }
661 })
662 .to_string();
663 let body = serde_json::json!({
664 "name": "qualia-qubo-job",
665 "providerId": "Microsoft",
666 "target": "microsoft.paralleltempering-parameterfree.cpu",
667 "inputDataFormat": "microsoft.qio.v2",
668 "outputDataFormat": "microsoft.qio-results.v2",
669 "inputParams": {"params": {"num_sweeps": shots.min(1000)}},
670 "inputData": [{"contentType": "application/json", "itemType": "inputData"}],
671 "containerName": problem_str,
672 });
673 let url = format!(
674 "https://{workspace}.quantum.azure.com/subscriptions/{subscription}/\
675 resourceGroups/{resource_group}/providers/Microsoft.Quantum/Workspaces/{workspace}/jobs",
676 );
677 http_post_sync(&url, api_key, "Bearer", &body)
678}
679
680fn submit_azure_vqe(
681 subscription: &str,
682 resource_group: &str,
683 workspace: &str,
684 api_key: &str,
685 params: &[f64],
686 shots: u32,
687) -> Result<String, String> {
688 let n = params.len().min(16);
689 let mut qasm = format!("OPENQASM 2.0;\ninclude \"qelib1.inc\";\nqreg q[{n}];\ncreg c[{n}];\n");
690 for i in 0..n {
691 qasm.push_str(&format!("ry({}) q[{}];\n", params[i], i));
692 if i + 1 < n {
693 qasm.push_str(&format!("cx q[{}], q[{}];\n", i, i + 1));
694 }
695 }
696 for i in 0..n {
697 qasm.push_str(&format!("measure q[{}] -> c[{}];\n", i, i));
698 }
699 let body = serde_json::json!({
700 "name": "qualia-vqe-job",
701 "providerId": "ionq",
702 "target": "ionq.simulator",
703 "inputDataFormat": "ionq.circuit.v1",
704 "outputDataFormat": "microsoft.quantum-results.v1",
705 "inputParams": {"shots": shots.min(500)},
706 "containerName": qasm,
707 });
708 let url = format!(
709 "https://{workspace}.quantum.azure.com/subscriptions/{subscription}/\
710 resourceGroups/{resource_group}/providers/Microsoft.Quantum/Workspaces/{workspace}/jobs",
711 );
712 http_post_sync(&url, api_key, "Bearer", &body)
713}
714
715fn http_post_sigv4(
718 url: &str,
719 access_key: &str,
720 secret_key: &str,
721 region: &str,
722 service: &str,
723 body: &serde_json::Value,
724) -> Result<String, String> {
725 use hmac::{Hmac, KeyInit, Mac};
726 use sha2::{Digest, Sha256};
727
728 type HmacSha256 = Hmac<Sha256>;
729
730 let body_str = body.to_string();
731 let payload_hash = hex::encode(Sha256::digest(body_str.as_bytes()));
732
733 let parsed = url::Url::parse(url).map_err(|e| e.to_string())?;
734 let host = parsed.host_str().unwrap_or("");
735 let path = parsed.path();
736
737 let secs = std::time::SystemTime::now()
739 .duration_since(std::time::UNIX_EPOCH)
740 .map_err(|e| e.to_string())?
741 .as_secs();
742 let (datetime, datestamp) = format_iso8601(secs);
743
744 let signed_headers = "content-type;host;x-amz-date";
746 let canonical_headers = format!(
747 "content-type:application/json\nhost:{}\nx-amz-date:{}\n",
748 host, datetime
749 );
750 let canonical_request = format!(
751 "POST\n{}\n\n{}\n{}\n{}",
752 path, canonical_headers, signed_headers, payload_hash
753 );
754 let credential_scope = format!("{}/{}/{}/aws4_request", datestamp, region, service);
755 let string_to_sign = format!(
756 "AWS4-HMAC-SHA256\n{}\n{}\n{}",
757 datetime,
758 credential_scope,
759 hex::encode(Sha256::digest(canonical_request.as_bytes()))
760 );
761
762 let sign_key_date = {
764 let mut mac = HmacSha256::new_from_slice(format!("AWS4{}", secret_key).as_bytes())
765 .map_err(|e| e.to_string())?;
766 mac.update(datestamp.as_bytes());
767 mac.finalize().into_bytes()
768 };
769 let sign_key_region = {
770 let mut mac = HmacSha256::new_from_slice(&sign_key_date).map_err(|e| e.to_string())?;
771 mac.update(region.as_bytes());
772 mac.finalize().into_bytes()
773 };
774 let sign_key_service = {
775 let mut mac = HmacSha256::new_from_slice(&sign_key_region).map_err(|e| e.to_string())?;
776 mac.update(service.as_bytes());
777 mac.finalize().into_bytes()
778 };
779 let signing_key = {
780 let mut mac = HmacSha256::new_from_slice(&sign_key_service).map_err(|e| e.to_string())?;
781 mac.update(b"aws4_request");
782 mac.finalize().into_bytes()
783 };
784 let signature = {
785 let mut mac = HmacSha256::new_from_slice(&signing_key).map_err(|e| e.to_string())?;
786 mac.update(string_to_sign.as_bytes());
787 hex::encode(mac.finalize().into_bytes())
788 };
789
790 let auth_header = format!(
791 "AWS4-HMAC-SHA256 Credential={}/{}, SignedHeaders={}, Signature={}",
792 access_key, credential_scope, signed_headers, signature
793 );
794
795 let client = reqwest::blocking::Client::builder()
796 .timeout(std::time::Duration::from_secs(120))
797 .build()
798 .map_err(|e| e.to_string())?;
799
800 let resp = client
801 .post(url)
802 .header("Authorization", auth_header)
803 .header("x-amz-date", datetime)
804 .header("content-type", "application/json")
805 .body(body_str)
806 .send()
807 .map_err(|e| format!("Braket request failed: {}", e))?;
808
809 if !resp.status().is_success() {
810 let status = resp.status();
811 let text = resp.text().unwrap_or_default();
812 return Err(format!("Braket HTTP {}: {}", status, text));
813 }
814 resp.text().map_err(|e| e.to_string())
815}
816
817fn format_iso8601(secs: u64) -> (String, String) {
819 let days = secs / 86400;
821 let time_of_day = secs % 86400;
822 let hh = time_of_day / 3600;
823 let mm = (time_of_day % 3600) / 60;
824 let ss = time_of_day % 60;
825
826 let jd = days as i64 + 2_440_588; let l = jd + 68_569;
829 let n = 4 * l / 146_097;
830 let l = l - (146_097 * n + 3) / 4;
831 let i = 4000 * (l + 1) / 1_461_001;
832 let l = l - 1461 * i / 4 + 31;
833 let j = 80 * l / 2447;
834 let day = l - 2447 * j / 80;
835 let l = j / 11;
836 let month = j + 2 - 12 * l;
837 let year = 100 * (n - 49) + i + l;
838
839 let date = format!("{:04}{:02}{:02}", year, month, day);
840 let datetime = format!("{}T{:02}{:02}{:02}Z", date, hh, mm, ss);
841 (datetime, date)
842}
843
844fn http_post_sync(
847 url: &str,
848 token: &str,
849 auth_scheme: &str,
850 body: &serde_json::Value,
851) -> Result<String, String> {
852 let client = reqwest::blocking::Client::builder()
853 .timeout(std::time::Duration::from_secs(120))
854 .build()
855 .map_err(|e| e.to_string())?;
856
857 let auth_value = match auth_scheme {
858 "Bearer" => format!("Bearer {}", token),
859 "X-Auth-Token" => token.to_string(),
860 "Authorization" => format!("apiKey {}", token),
861 "id-token" => token.to_string(),
862 scheme => format!("{} {}", scheme, token),
863 };
864
865 let mut req = client.post(url).json(body);
866 req = if auth_scheme == "X-Auth-Token" {
867 req.header("X-Auth-Token", auth_value)
868 } else if auth_scheme == "id-token" {
869 req.header("id-token", auth_value)
870 } else {
871 req.header("Authorization", auth_value)
872 };
873
874 let resp = req
875 .send()
876 .map_err(|e| format!("HTTP request to {} failed: {}", url, e))?;
877
878 if !resp.status().is_success() {
879 let status = resp.status();
880 let text = resp.text().unwrap_or_default();
881 return Err(format!("HTTP {}: {}", status, text));
882 }
883 resp.text().map_err(|e| e.to_string())
884}