diff --git a/config.template.toml b/config.template.toml index 230b8dc1..9855f098 100644 --- a/config.template.toml +++ b/config.template.toml @@ -896,4 +896,44 @@ options = [ "Following Starknet on social media.", "Attending a cryptocurrency seminar." ] + +[quizzes.rango] +name = "Rango Quiz" +desc = "Take part in our Quiz to test your knowledge about Rango, and you'll have a chance to win an exclusive Rango Castle Bridge NFT as your reward." +intro = "Starknet Quest Quiz Rounds, a quiz series designed to make Starknet ecosystem knowledge accessible and enjoyable for all. Test your understanding of the workings of Rango, enjoy the experience, and earn an exclusive NFT reward by testing your knowledge about Starknet Ecosystem projects!" + +[[quizzes.rango.questions]] +kind = "text_choice" +layout = "default" +question = "What does Rango specialize in?" +options = [ + "Decentralized applications ", + "Cross-chain swaps and aggregating bridges and DEXs", + "58  blockchains", + "Only the Lightning network " +] +correct_answers = [*] + +[[quizzes.rango.questions]] +kind = "text_choice" +layout = "default" +question = "How many connections does Rango support in Web3?" +options = [ + "20 Cosmos Appchains and 50 CEXes", + "100 blockchains and 10 DEXes.", + "Capital inefficiency and poor price discovery in AMMs", + "Lack of social media engagement " +] +correct_answers = [*] + +[[quizzes.rango.questions]] +kind = "text_choice" +layout = "default" +question = "What makes Rango Multichain?" +options = [ + "It only supports one type of EVM blockchain.", + "Rango is a sidechain on Starknet.", + "Rango integrates multiple types of blockchains, including EVM-based, Cosmos, Solana, and many more.", + "Rango focuses exclusively on a zkEVM blockchain type" +] correct_answers = [*] \ No newline at end of file diff --git a/src/config.rs b/src/config.rs index 953fb3ee..5bfc9e73 100644 --- a/src/config.rs +++ b/src/config.rs @@ -122,6 +122,11 @@ pub_struct!(Clone, Deserialize; Starkscan { api_key: String, }); +pub_struct!(Clone, Deserialize; Api { + api_endpoint: String, + api_key: String, +}); + pub_struct!(Clone, Deserialize; Achievement { contract: FieldElement, }); @@ -145,6 +150,7 @@ pub_struct!(Clone, Deserialize; Config { starkscan: Starkscan, achievements: Achievements, quest_boost: QuestBoost, + rango: Api, }); pub fn load() -> Config { diff --git a/src/endpoints/quest_boost/get_claim_params.rs b/src/endpoints/quest_boost/get_claim_params.rs index 8803439c..037d18c3 100644 --- a/src/endpoints/quest_boost/get_claim_params.rs +++ b/src/endpoints/quest_boost/get_claim_params.rs @@ -59,4 +59,4 @@ pub async fn handler( .into_response(), Err(e) => get_error(format!("Error while generating signature: {}", e)), } -} +} \ No newline at end of file diff --git a/src/endpoints/quests/mod.rs b/src/endpoints/quests/mod.rs index 658df1f7..a967ebbd 100644 --- a/src/endpoints/quests/mod.rs +++ b/src/endpoints/quests/mod.rs @@ -17,3 +17,4 @@ pub mod tribe; pub mod uri; pub mod verify_quiz; pub mod zklend; +pub mod rango; \ No newline at end of file diff --git a/src/endpoints/quests/rango/check_trade.rs b/src/endpoints/quests/rango/check_trade.rs new file mode 100644 index 00000000..d6418380 --- /dev/null +++ b/src/endpoints/quests/rango/check_trade.rs @@ -0,0 +1,55 @@ +use std::sync::Arc; + +use crate::models::EmailQuery; +use crate::utils::{CompletedTasksTrait}; +use crate::{models::AppState, utils::get_error}; +use axum::{ + extract::{Query, State}, + http::StatusCode, + response::IntoResponse, + Json, +}; +use serde_json::json; + +pub async fn handler( + State(state): State>, + Query(query): Query, +) -> impl IntoResponse { + let task_id = 92; + + let res = make_rango_request(&state.conf.rango.api_endpoint, &state.conf.rango.api_key).await; + let response = match res { + Ok(response) => response, + Err(e) => return get_error(format!("{}", e)), + }; + + if let Some(_) = response.get("data") { + if let Some(result) = response.get("result") { + if result.as_bool().unwrap() { + return match state.upsert_completed_task(query.addr, task_id).await { + Ok(_) => (StatusCode::OK, Json(json!({"res": true}))).into_response(), + Err(e) => get_error(format!("{}", e)), + }; + } + } + } + get_error("User has not completed the task".to_string()) +} + +async fn make_rango_request(endpoint: &str, api_key: &str) -> Result { + let client = reqwest::Client::new(); + match client.get(endpoint).header("apiKey", api_key).send().await { + Ok(response) => match response.json::().await { + Ok(json) => { + if let Some(res) = json.get("res") { + if res.as_bool().unwrap() { + return Ok(json!({"res": true})); + } + } + Err(format!("Failed to get JSON response: {}", json)) + } + Err(e) => Err(format!("Failed to get JSON response: {}", e)), + }, + Err(e) => Err(format!("Failed to send request: {}", e)), + } +} diff --git a/src/endpoints/quests/rango/claimable.rs b/src/endpoints/quests/rango/claimable.rs new file mode 100644 index 00000000..9913a78b --- /dev/null +++ b/src/endpoints/quests/rango/claimable.rs @@ -0,0 +1,101 @@ +use crate::models::{AppState, CompletedTaskDocument, Reward, RewardResponse}; +use crate::utils::{get_error, get_nft}; +use axum::{ + extract::{Query, State}, + http::StatusCode, + response::IntoResponse, + Json, +}; +use futures::StreamExt; +use mongodb::bson::doc; +use serde::Deserialize; +use starknet::{ + core::types::FieldElement, + signers::{LocalWallet, SigningKey}, +}; +use std::sync::Arc; + +const QUEST_ID: u32 = 23; +const TASK_IDS: &[u32] = &[92, 93, 94, 95]; +const LAST_TASK: u32 = TASK_IDS[3]; +const NFT_LEVEL: u32 = 30; + +#[derive(Deserialize)] +pub struct ClaimableQuery { + addr: FieldElement, +} + +pub async fn handler( + State(state): State>, + Query(query): Query, +) -> impl IntoResponse { + let collection = state + .db + .collection::("completed_tasks"); + + let pipeline = vec![ + doc! { + "$match": { + "address": &query.addr.to_string(), + "task_id": { "$in": TASK_IDS }, + }, + }, + doc! { + "$lookup": { + "from": "tasks", + "localField": "task_id", + "foreignField": "id", + "as": "task", + }, + }, + doc! { + "$match": { + "task.quest_id": QUEST_ID, + }, + }, + doc! { + "$group": { + "_id": "$address", + "completed_tasks": { "$push": "$task_id" }, + }, + }, + doc! { + "$match": { + "completed_tasks": { "$all": TASK_IDS }, + }, + }, + ]; + + let completed_tasks = collection.aggregate(pipeline, None).await; + match completed_tasks { + Ok(mut tasks_cursor) => { + if tasks_cursor.next().await.is_none() { + return get_error("User hasn't completed all tasks".into()); + } + + let signer = LocalWallet::from(SigningKey::from_secret_scalar( + state.conf.nft_contract.private_key, + )); + + let mut rewards = vec![]; + + let Ok((token_id, sig)) = get_nft(QUEST_ID, LAST_TASK, &query.addr, NFT_LEVEL, &signer).await else { + return get_error("Signature failed".into()); + }; + + rewards.push(Reward { + task_id: LAST_TASK, + nft_contract: state.conf.nft_contract.address.clone(), + token_id: token_id.to_string(), + sig: (sig.r, sig.s), + }); + + if rewards.is_empty() { + get_error("No rewards found for this user".into()) + } else { + (StatusCode::OK, Json(RewardResponse { rewards })).into_response() + } + } + Err(_) => get_error("Error querying rewards".into()), + } +} \ No newline at end of file diff --git a/src/endpoints/quests/rango/discord_fw_callback.rs b/src/endpoints/quests/rango/discord_fw_callback.rs new file mode 100644 index 00000000..4c79fccb --- /dev/null +++ b/src/endpoints/quests/rango/discord_fw_callback.rs @@ -0,0 +1,145 @@ +use std::sync::Arc; + +use crate::utils::CompletedTasksTrait; +use crate::{ + models::AppState, + utils::{get_error_redirect, success_redirect}, +}; +use axum::{ + extract::{Query, State}, + response::IntoResponse, +}; +use mongodb::bson::doc; +use reqwest::header::AUTHORIZATION; +use serde::Deserialize; +use starknet::core::types::FieldElement; + +#[derive(Deserialize)] +pub struct TwitterOAuthCallbackQuery { + code: String, + state: FieldElement, +} + +#[derive(Deserialize)] +pub struct Guild { + id: String, + #[allow(dead_code)] + name: String, +} + +pub async fn handler( + State(state): State>, + Query(query): Query, +) -> impl IntoResponse { + let quest_id = 23; + let task_id = 94; + let guild_id = "1079299393712300112"; + let authorization_code = &query.code; + let error_redirect_uri = format!( + "{}/quest/{}?task_id={}&res=false", + state.conf.variables.app_link, quest_id, task_id + ); + + // Exchange the authorization code for an access token + let params = [ + ("client_id", &state.conf.discord.oauth2_clientid), + ("client_secret", &state.conf.discord.oauth2_secret), + ("code", &authorization_code.to_string()), + ( + "redirect_uri", + &format!( + "{}/quests/rango/discord_fw_callback", + state.conf.variables.api_link + ), + ), + ("grant_type", &"authorization_code".to_string()), + ]; + let access_token = match exchange_authorization_code(params).await { + Ok(token) => token, + Err(e) => { + return get_error_redirect( + error_redirect_uri, + format!("Failed to exchange authorization code: {}", e), + ); + } + }; + + // Get user guild information + let client = reqwest::Client::new(); + let response_result = client + .get("https://discord.com/api/users/@me/guilds") + .header(AUTHORIZATION, format!("Bearer {}", access_token)) + .send() + .await; + let response: Vec = match response_result { + Ok(response) => { + let json_result = response.json().await; + match json_result { + Ok(json) => json, + Err(e) => { + return get_error_redirect( + error_redirect_uri, + format!( + "Failed to get JSON response while fetching user info: {}", + e + ), + ); + } + } + } + Err(e) => { + return get_error_redirect( + error_redirect_uri, + format!("Failed to send request to get user info: {}", e), + ); + } + }; + + for guild in response { + if guild.id == guild_id { + match state.upsert_completed_task(query.state, task_id).await { + Ok(_) => { + let redirect_uri = format!( + "{}/quest/{}?task_id={}&res=true", + state.conf.variables.app_link, quest_id, task_id + ); + return success_redirect(redirect_uri); + } + Err(e) => return get_error_redirect(error_redirect_uri, format!("{}", e)), + } + } + } + + get_error_redirect( + error_redirect_uri, + "You're not part of Rango's Discord server".to_string(), + ) +} + +async fn exchange_authorization_code( + params: [(&str, &String); 5], +) -> Result> { + let client = reqwest::Client::new(); + let res = client + .post("https://discord.com/api/oauth2/token") + .form(¶ms) + .send() + .await?; + let json: serde_json::Value = res.json().await?; + match json["access_token"].as_str() { + Some(s) => Ok(s.to_string()), + None => { + println!( + "Failed to get 'access_token' from JSON response : {:?}", + json + ); + Err(Box::new(std::io::Error::new( + std::io::ErrorKind::Other, + format!( + "Failed to get 'access_token' from JSON response : {:?}", + json + ), + ))) + } + } +} diff --git a/src/endpoints/quests/rango/mod.rs b/src/endpoints/quests/rango/mod.rs new file mode 100644 index 00000000..7f8deb1d --- /dev/null +++ b/src/endpoints/quests/rango/mod.rs @@ -0,0 +1,4 @@ +pub mod verify_twitter_fw; +pub mod discord_fw_callback; +pub mod check_trade; +pub mod claimable; \ No newline at end of file diff --git a/src/endpoints/quests/rango/verify_twitter_fw.rs b/src/endpoints/quests/rango/verify_twitter_fw.rs new file mode 100644 index 00000000..abeea52f --- /dev/null +++ b/src/endpoints/quests/rango/verify_twitter_fw.rs @@ -0,0 +1,24 @@ +use std::sync::Arc; + +use crate::{ + models::{AppState, VerifyQuery}, + utils::{get_error, CompletedTasksTrait}, +}; +use axum::{ + extract::{Query, State}, + http::StatusCode, + response::IntoResponse, + Json, +}; +use serde_json::json; + +pub async fn handler( + State(state): State>, + Query(query): Query, +) -> impl IntoResponse { + let task_id = 93; + match state.upsert_completed_task(query.addr, task_id).await { + Ok(_) => (StatusCode::OK, Json(json!({"res": true}))).into_response(), + Err(e) => get_error(format!("{}", e)), + } +} diff --git a/src/endpoints/quests/uri.rs b/src/endpoints/quests/uri.rs index 1ddce28f..c62b05d5 100644 --- a/src/endpoints/quests/uri.rs +++ b/src/endpoints/quests/uri.rs @@ -329,7 +329,7 @@ pub async fn handler( }), ) .into_response(), - + Some(29) => ( StatusCode::OK, Json(TokenURI { @@ -340,6 +340,17 @@ pub async fn handler( }), ) .into_response(), + + + Some(30) => ( + StatusCode::OK, + Json(TokenURI { + name: "Rango Exchange Castle Bridge NFT".into(), + description: "A Rango Exchange Quest NFT won for successfully finishing the Quest".into(), + image: format!("{}/rango/bridge.webp", state.conf.variables.app_link), + attributes: None, + }), + ).into_response(), _ => get_error("Error, this level is not correct".into()), } diff --git a/src/endpoints/quests/verify_quiz.rs b/src/endpoints/quests/verify_quiz.rs index 5511dfc2..0a9ba3f1 100644 --- a/src/endpoints/quests/verify_quiz.rs +++ b/src/endpoints/quests/verify_quiz.rs @@ -28,6 +28,7 @@ fn get_task_id(quiz_name: &str) -> Option { "briq" => Some(67), "element_starknetid" => Some(73), "nostra" => Some(79), + "rango" => Some(95), "braavos" => Some(98), _ => None, } diff --git a/src/main.rs b/src/main.rs index 70e89faf..2a676fd9 100644 --- a/src/main.rs +++ b/src/main.rs @@ -416,6 +416,22 @@ async fn main() { "/quests/nostra/verify_added_liquidity", get(endpoints::quests::nostra::verify_added_liquidity::handler), ) + .route( + "/quests/rango/verify_twitter_fw", + get(endpoints::quests::rango::verify_twitter_fw::handler), + ) + .route( + "/quests/rango/discord_fw_callback", + get(endpoints::quests::rango::discord_fw_callback::handler), + ) + .route( + "/quests/rango/check_trade", + get(endpoints::quests::rango::check_trade::handler), + ) + .route( + "/quests/rango/claimable", + get(endpoints::quests::rango::claimable::handler), + ) .route( "/achievements/verify_default", get(endpoints::achievements::verify_default::handler),