pub fn decode_jwt_without_validation(jwt: &str) -> Result<AuthContent, String>Examples found in repository?
examples/user_start_protocol_operator.rs (line 10)
5async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
6 let args = env::args().skip(1).collect::<Vec<_>>();
7 let addr = &args[0];
8 let jwt = &args[1];
9 let protocol_name = &args[2];
10 let user_id = decode_jwt_without_validation(jwt).unwrap().user_id;
11 let cl = CoLink::new(addr, jwt);
12 let instance_id = cl
13 .start_protocol_operator(protocol_name, &user_id, false)
14 .await?;
15 println!("Instance id: {}", instance_id);
16
17 Ok(())
18}More examples
examples/user_run_local_task.rs (line 10)
5async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
6 let args = env::args().skip(1).collect::<Vec<_>>();
7 let addr = &args[0];
8 let jwt_a = &args[1];
9 let msg = if args.len() > 2 { &args[2] } else { "hello" };
10 let user_id_a = decode_jwt_without_validation(jwt_a).unwrap().user_id;
11
12 let participants = vec![Participant {
13 user_id: user_id_a.to_string(),
14 role: "initiator".to_string(),
15 }];
16 let cl = CoLink::new(addr, jwt_a);
17 let task_id = cl
18 .run_task("greetings", msg.as_bytes(), &participants, false)
19 .await?;
20 println!(
21 "Local task {} has been created, it will remain in started status until the protocol starts.",
22 task_id
23 );
24
25 Ok(())
26}examples/user_wait_task.rs (line 13)
8async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
9 let args = env::args().skip(1).collect::<Vec<_>>();
10 let addr = &args[0];
11 let jwt = &args[1];
12 let target_user = &args[2];
13 let user_id = decode_jwt_without_validation(jwt).unwrap().user_id;
14
15 let user = UserRecord {
16 user_id: target_user.to_string(),
17 ..Default::default()
18 };
19 let mut payload = vec![];
20 user.encode(&mut payload).unwrap();
21 let cl = CoLink::new(addr, jwt);
22 let participants = vec![Participant {
23 user_id: user_id.to_string(),
24 role: "query_from_registries".to_string(),
25 }];
26 let task_id = cl
27 .run_task("registry", &payload, &participants, false)
28 .await?;
29 println!(
30 "Task {} has been created, waiting for it to finish...",
31 task_id
32 );
33 cl.wait_task(&task_id).await?;
34 println!("Task {} finished", task_id);
35
36 Ok(())
37}examples/user_run_task.rs (line 11)
5async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
6 let args = env::args().skip(1).collect::<Vec<_>>();
7 let addr = &args[0];
8 let jwt_a = &args[1];
9 let jwt_b = &args[2];
10 let msg = if args.len() > 3 { &args[3] } else { "hello" };
11 let user_id_a = decode_jwt_without_validation(jwt_a).unwrap().user_id;
12 let user_id_b = decode_jwt_without_validation(jwt_b).unwrap().user_id;
13
14 let participants = vec![
15 Participant {
16 user_id: user_id_a.to_string(),
17 role: "initiator".to_string(),
18 },
19 Participant {
20 user_id: user_id_b.to_string(),
21 role: "receiver".to_string(),
22 },
23 ];
24 let cl = CoLink::new(addr, jwt_a);
25 let task_id = cl
26 .run_task("greetings", msg.as_bytes(), &participants, true)
27 .await?;
28 println!(
29 "Task {} has been created, but it will remain in waiting status until the protocol starts.",
30 task_id
31 );
32
33 Ok(())
34}examples/user_greetings_to_multiple_users.rs (line 10)
5async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
6 let args = env::args().skip(1).collect::<Vec<_>>();
7 let addr = &args[0];
8 let jwt_initiator = &args[1];
9 let msg = "hello";
10 let user_id_initiator = decode_jwt_without_validation(jwt_initiator)
11 .unwrap()
12 .user_id;
13
14 let mut participants = vec![Participant {
15 user_id: user_id_initiator.to_string(),
16 role: "initiator".to_string(),
17 }];
18 for i in 2..args.len() {
19 participants.push(Participant {
20 user_id: decode_jwt_without_validation(&args[i])
21 .unwrap()
22 .user_id
23 .to_string(),
24 role: "receiver".to_string(),
25 });
26 }
27
28 let cl = CoLink::new(addr, jwt_initiator);
29 let task_id = cl
30 .run_task("greetings", msg.as_bytes(), &participants, true)
31 .await?;
32 println!(
33 "Task {} has been created, but it will remain in waiting status until the protocol starts.",
34 task_id
35 );
36
37 Ok(())
38}examples/host_import_users_and_exchange_guest_jwts.rs (line 41)
5async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
6 let args = env::args().skip(1).collect::<Vec<_>>();
7 let addr = &args[0];
8 let jwt = &args[1];
9 let num = &args[2];
10 let num: usize = num.parse().unwrap();
11 let expiration_timestamp: i64 = if args.len() > 3 {
12 args[3].parse().unwrap()
13 } else {
14 // A default expiration timestamp at 31 days later
15 chrono::Utc::now().timestamp() + 86400 * 31
16 };
17
18 let cl = CoLink::new(addr, jwt);
19 let mut users = vec![];
20 let mut guest_jwts = vec![];
21 for i in 0..num {
22 let (pk, sk) = generate_user();
23 let core_pub_key = cl.request_info().await?.core_public_key;
24 let (signature_timestamp, sig) =
25 prepare_import_user_signature(&pk, &sk, &core_pub_key, expiration_timestamp);
26 users.push(
27 cl.import_user(&pk, signature_timestamp, expiration_timestamp, &sig)
28 .await?,
29 );
30 let cl = CoLink::new(addr, &users[i]);
31 guest_jwts.push(
32 cl.generate_token_with_expiration_time(expiration_timestamp, "guest")
33 .await?,
34 );
35 }
36 for i in 0..num {
37 for j in 0..num {
38 if i != j {
39 let cl = CoLink::new(addr, &users[i]);
40 cl.import_guest_jwt(&guest_jwts[j]).await?;
41 let jwt = decode_jwt_without_validation(&guest_jwts[j])?;
42 cl.import_core_addr(&jwt.user_id, addr).await?;
43 }
44 }
45 }
46 for i in 0..num {
47 println!("{}", users[i]);
48 }
49
50 Ok(())
51}Additional examples can be found in: