Merge pull request #148 from starknet-id/ayush/rango

feat: add rango quest

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 = [*]

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 {

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)),
     }
-}
+}

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;

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<Arc<AppState>>,
+    Query(query): Query<EmailQuery>,
+) -> 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<serde_json::Value, String> {
+    let client = reqwest::Client::new();
+    match client.get(endpoint).header("apiKey", api_key).send().await {
+        Ok(response) => match response.json::<serde_json::Value>().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)),
+    }
+}

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<Arc<AppState>>,
+    Query(query): Query<ClaimableQuery>,
+) -> impl IntoResponse {
+    let collection = state
+        .db
+        .collection::<CompletedTaskDocument>("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()),
+    }
+}

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<Arc<AppState>>,
+    Query(query): Query<TwitterOAuthCallbackQuery>,
+) -> 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<Guild> = 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<String, Box<dyn std::error::Error>> {
+    let client = reqwest::Client::new();
+    let res = client
+        .post("https://discord.com/api/oauth2/token")
+        .form(&params)
+        .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
+                ),
+            )))
+        }
+    }
+}

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;