main.rs

mod verify;

use std::{collections::HashSet, f64::consts::E, str::FromStr};

use cosmrs::tendermint::signature;
use futures::stream::TryBufferUnordered;
use jito_merkle_tree::csv_entry::AirdropCategory;
use solana_sdk::pubkey::Pubkey;
use sp_core::H160;
use verify::{get_signed_message, validate_eth_signature};

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use utoipa_swagger_ui::SwaggerUi;
use utoipa::{
    openapi::security::{ApiKey, ApiKeyValue, SecurityScheme},
    Modify, OpenApi,
};

#[derive(Serialize, Deserialize, ToSchema, Clone)]
pub struct SignatureParams {
    signatures: String,
    pubkey: String,
    message: String,
    network: u8, //0 eth, 1 cosmos,2 polkadot
    signatures_bytes: Option<Vec<u8>>,
    message_bytes: Option<Vec<u8>>,
    cosmos_public_without_prefix: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Debug, ToSchema)]
pub struct VestingResp {
    pub is_success: bool,
    pub error_message: Option<String>,
    pub page_index: Option<u8>,
    pub amount_unlocked: u64,
    pub amount_locked: u64,
}

//post method to store new CmcSymbols
#[utoipa::path(
    post,
    path = "/vesting/domain/submitsignature",
    params(
        ("cmc_symbol" = CmcSymbolsStoreParams, description = "The Signatures to be stored")
    ),
    responses(
        (status = 200, description = "Successfully accept  signatures", body = String),
        (status = 400, description = "Invalid request parameters")
    )
)]
pub async fn submit_signature(
    signature_params: web::Json<SignatureParams>,
) -> impl Responder {
    use jito_merkle_tree::csv_entry::CsvEntry;
    use std::path::PathBuf;
    let post_params = signature_params.into_inner();

    let path_to_drop_file = "/data/mantis-indexer/mantis-indexer/dropped.json";
    let file_to_drop_csv = "/data/mantis-indexer/mantis-indexer/ethcosmosclaimprod.csv";

    println!("{}", file_to_drop_csv);
    let distribution_file = &PathBuf::from(file_to_drop_csv);
    let entity = CsvEntry::new_from_file(&distribution_file).expect("Failed to parse CSV");
    //find the claimant in the csv file
    let claimant_entity = entity.iter().find(|x| x.pubkey == post_params.pubkey);
    if claimant_entity == None {
        let ret = VestingResp {
            is_success: false,
            error_message: Some("Claimant not found".to_string()),
            page_index: None,
            amount_locked: 0,
            amount_unlocked: 0,
        };
        return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    }

    let amount_unlocked = ui_amount_to_token_amount(claimant_entity.unwrap().amount_unlocked);
    let amount_locked = ui_amount_to_token_amount(claimant_entity.unwrap().amount_locked);

    //read data from json file
    let json_data_from_file = std::fs::read_to_string(path_to_drop_file).expect("Unable to read file");
    //deserialize the json data
    let mut dropped_data: Vec<DroppedItem> = serde_json::from_str(&json_data_from_file).expect("Unable to deserialize");
    //validate that no dublicate claimant is in the dropped list
    //better to use hashmap for this but already started with vector so need to validate that no dublicate claimant is in the dropped list
    let mut seen = HashSet::new();
    for item in dropped_data.iter() {
        if !seen.insert(item.address.clone()) {
            println!("Dublicate entry: {:?}", item);
            let ret = VestingResp {
                is_success: false,
                error_message: Some("Dublicate entry".to_string()),
                page_index: None,
                amount_locked: 0,
                amount_unlocked: 0,
            };
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
    }
    fn exists_data_in_file(path_to_drop_file: &str, search: String) -> bool{
        let json_data_from_file = std::fs::read_to_string(path_to_drop_file).expect("Unable to read file");
        //deserialize the json data
        let dropped_data: Vec<DroppedItem> = serde_json::from_str(&json_data_from_file).expect("Unable to deserialize");
        let dropped_entity = dropped_data.iter().any(|x| x.address == search);
        dropped_entity
    }
    fn update_data_in_file(path_to_drop_file: &str, updated_item: DroppedItem){
        let json_data_from_file = std::fs::read_to_string(path_to_drop_file).expect("Unable to read file");
        //deserialize the json data
        let mut dropped_data: Vec<DroppedItem> = serde_json::from_str(&json_data_from_file).expect("Unable to deserialize");
        let dropped_entity = dropped_data.iter().find(|x| x.address == updated_item.address).unwrap();
        let index = dropped_data.iter().position(|x| x.address == updated_item.address).unwrap();
        dropped_data[index] = updated_item;
        let json_data = serde_json::to_string(&dropped_data).expect("Unable to serialize");
        std::fs::write(path_to_drop_file, json_data).expect("Unable to write file");
    }
    //find the claimant in the dropped list
    let dropped_entity = dropped_data.iter().find(|x| x.address == post_params.pubkey);
    if dropped_entity.is_some() && (dropped_entity.unwrap().success || dropped_entity.unwrap().signature.is_some() ){
        println!("Claimant already recieved airdrop: {:?}", dropped_entity.unwrap());
        let ret = VestingResp {
            is_success: false,
            error_message: Some("Claimant already recieved airdrop".to_string()),
            page_index: Some(1),
            amount_locked: amount_locked,
            amount_unlocked: amount_unlocked,
        };
        return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    }

    let dropped_entity = dropped_data.iter().find(|x| x.solana_address == post_params.message);
    if dropped_entity.is_some() && (dropped_entity.unwrap().success || dropped_entity.unwrap().signature.is_some() ){
        let error = format!("This solana wallet already linked to this address: {}. Please use another solana wallet", dropped_entity.unwrap().address);
        println!("{}", error.clone());
        let ret = VestingResp {
            is_success: false,
            error_message: Some(error),
            page_index: Some(1),
            amount_locked: amount_locked,
            amount_unlocked: amount_unlocked,
        };
        return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    }

    if post_params.network == 0 {
        let address_str: H160 = post_params.pubkey.parse().unwrap();
        let signed_message = get_signed_message(post_params.message.clone());
        let result = validate_eth_signature(&post_params.signatures, address_str, &signed_message);
        if result.is_err() {
            let ret = VestingResp {
                is_success: false,
                error_message: Some("Invalid ethereum signature".to_string()),
                page_index: None,
                amount_locked: 0,
                amount_unlocked: 0,
            };
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
        use cli::call_process_admin_claim;
        let claimant = Pubkey::from_str(&post_params.message).unwrap();

        let mut dropped_item = DroppedItem{
            address: post_params.pubkey.clone(),
            solana_address: post_params.message.clone(),
            // page_index: (dropped_data.len() / 200) as u8 + 1,
            page_index: 1,
            success: false,
            signature: None,
            // page_index: dropped_data.len() as u8 % 200 + 1,
        };

        if !exists_data_in_file(path_to_drop_file, dropped_item.address.clone()){
            dropped_data.push(dropped_item.clone());
            let json_data = serde_json::to_string(&dropped_data).expect("Unable to serialize");
            std::fs::write(path_to_drop_file, json_data).expect("Unable to write file");
        }
        let result = call_process_admin_claim(claimant, amount_unlocked, amount_locked, dropped_item.page_index);
        if !result.0{
            let ret = VestingResp {
                is_success: false,
                error_message: Some("Claim/vesting already exists".to_string()),
                page_index: None,
                amount_locked: amount_locked,
                amount_unlocked: amount_unlocked,
            };
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
        let ret = VestingResp {
            is_success: true,
            error_message: None,
            page_index: Some(1),
            amount_locked: amount_locked,
            amount_unlocked: amount_unlocked,
        };
        dropped_item.success = true;
        dropped_item.signature = Some(result.1);
        update_data_in_file(path_to_drop_file, dropped_item);
        return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // }

    } else if post_params.network == 1 {
        let cosmos_public_without_prefix = post_params.cosmos_public_without_prefix.clone().unwrap();
        let cosmos_address_with_prefix = post_params.pubkey.clone();
        let message = post_params.message.clone();
        let signatures = post_params.signatures.clone();

        let result = verify::cosmos_verify_keplr_sign(cosmos_address_with_prefix, cosmos_public_without_prefix, signatures, message);

        if result {
            let mut droped_item = DroppedItem{
                address: post_params.pubkey.clone(),
                solana_address: post_params.message.clone(),
                // page_index: (dropped_data.len() / 200) as u8 + 1,
                page_index: 1,
                success: false,
                signature: None,
            };

            if !exists_data_in_file(path_to_drop_file, droped_item.address.clone()){
                dropped_data.push(droped_item.clone());
                let json_data = serde_json::to_string(&dropped_data).expect("Unable to serialize");
                std::fs::write(path_to_drop_file, json_data).expect("Unable to write file");
            }

            use cli::call_process_admin_claim;
            let claimant = Pubkey::from_str(&post_params.message).unwrap();
            let result = call_process_admin_claim(claimant, amount_unlocked, amount_locked, droped_item.page_index);
            if !result.0{
                let ret = VestingResp {
                    is_success: false,
                    error_message: Some("Claim/vesting already exists".to_string()),
                    page_index: None,
                    amount_locked: amount_locked,
                    amount_unlocked: amount_unlocked,
                };
                return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
            }
            let ret = VestingResp {
                is_success: true,
                error_message: None,
                page_index: Some(1),
                amount_locked: amount_locked,
                amount_unlocked: amount_unlocked,
            };
            droped_item.success = true;
            droped_item.signature = Some(result.1);
            update_data_in_file(path_to_drop_file, droped_item);
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
        else{
            let ret = VestingResp {
                is_success: false,
                error_message: Some("Invalid cosmos signature".to_string()),
                page_index: Some(1),
                amount_locked: 0,
                amount_unlocked: 0,
            };
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
    }
    else if post_params.network == 2 {
        let result = verify::verify_polkadot_signature(post_params.message.as_bytes(), post_params.signatures_bytes.unwrap().as_slice(), &post_params.pubkey);
        if result {
            let mut dropped_item = DroppedItem{
                address: post_params.pubkey.clone(),
                solana_address: post_params.message.clone(),
                // page_index: (dropped_data.len() / 200) as u8 + 1,
                page_index: 1,
                success: false,
                signature: None,
            };

            if !exists_data_in_file(path_to_drop_file, dropped_item.address.clone()){
                dropped_data.push(dropped_item.clone());
                let json_data = serde_json::to_string(&dropped_data).expect("Unable to serialize");
                std::fs::write(path_to_drop_file, json_data).expect("Unable to write file");
            }

            use cli::call_process_admin_claim;
            let claimant = Pubkey::from_str(&post_params.message).unwrap();
            let result = call_process_admin_claim(claimant, amount_unlocked, amount_locked, dropped_item.page_index);
            if !result.0{
                let ret = VestingResp {
                    is_success: false,
                    error_message: Some("Claim/vesting already exists".to_string()),
                    page_index: None,
                    amount_locked: amount_locked,
                    amount_unlocked: amount_unlocked,
                };
                return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
            }
            let ret = VestingResp {
                is_success: true,
                error_message: None,
                page_index: Some(1),
                amount_locked: amount_locked,
                amount_unlocked: amount_unlocked,
            };
            dropped_item.success = true;
            dropped_item.signature = Some(result.1);
            update_data_in_file(path_to_drop_file, dropped_item);
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
        else{
            let ret = VestingResp {
                is_success: false,
                error_message: Some("Invalid polkadot signature".to_string()),
                page_index: Some(1),
                amount_locked: 0,
                amount_unlocked: 0,
            };
            return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
        }
    }
    let ret = VestingResp {
        is_success: false,
        error_message: Some("Invalid network. 0 for ethereum, 1 for cosmos, 2 for polkadot".to_string()),
        page_index: Some(1),
        amount_locked: 0,
        amount_unlocked: 0,
    };
    return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
}

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct DroppedItem{
    pub address: String, //cosmos/eth/polkadot address
    pub solana_address: String,
    pub success: bool,
    pub signature: Option<String>,
    pub page_index: u8,
}

fn ui_amount_to_token_amount(amount: f64) -> u64 {
    (amount * 10u64.checked_pow(9).unwrap() as f64) as u64
}

//post method to store new CmcSymbols
#[utoipa::path(
    get,
    path = "/vesting/domain/getsubmitsignature",
    params(
        ("cmc_symbol" = CmcSymbolsStoreParams, description = "The Signatures to be stored")
    ),
    responses(
        (status = 200, description = "Successfully accept  signatures", body = String),
        (status = 400, description = "Invalid request parameters")
    )
)]
pub async fn get_submit_signature(
    query: web::Query<SignatureParams>,
) -> impl Responder {
    // let path_to_drop_file = "/data/mantis-indexer/mantis-indexer/dropped.json";
    // let file_to_drop_csv = "/data/mantis-indexer/mantis-indexer/ethcosmosclaimprod.csv";
    // let post_params = query.into_inner();

    // println!("{}", file_to_drop_csv);

    // if post_params.network == 0 {
    //     let address_str: H160 = post_params.pubkey.parse().unwrap();
    //     let signed_message = get_signed_message(post_params.message.clone());
    //     let result = validate_eth_signature(&post_params.signatures, address_str, &signed_message);
    //     if result.is_ok() {
    //         use cli::call_process_admin_claim;
    //         let claimant = Pubkey::from_str(&post_params.message).unwrap();
    //         use jito_merkle_tree::csv_entry::CsvEntry;
    //         use std::path::PathBuf;
    //         let distribution_file = &PathBuf::from(file_to_drop_csv);
    //         println!("distribution_file: {:?}", distribution_file);
    //         let entity = CsvEntry::new_from_file(&distribution_file).expect("Failed to parse CSV");
    //         //find the claimant in the csv file
    //         let claimant_entity = entity.iter().find(|x| x.pubkey == post_params.pubkey);
    //         if claimant_entity == None {
    //             let ret = VestingResp {
    //                 is_success: false,
    //                 error_message: Some("Claimant not found".to_string()),
    //                 page_index: Some(1),
    //                 amount_locked: 0,
    //                 amount_unlocked: 0,
    //             };
    //             return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    //         }



    //         //read data from json file
    //         let json_data_from_file = std::fs::read_to_string(path_to_drop_file).expect("Unable to read file");
    //         //deserialize the json data
    //         let mut dropped_data: Vec<DroppedItem> = serde_json::from_str(&json_data_from_file).expect("Unable to deserialize");
    //         //find the claimant in the dropped list
    //         let dropped_entity = dropped_data.iter().find(|x| x.address == post_params.pubkey);
    //         if dropped_entity.is_some(){
    //             let ret = VestingResp {
    //                 is_success: false,
    //                 error_message: Some("Claimant already recieved airdrop".to_string()),
    //                 page_index: Some(1),
    //                 amount_locked: 0,
    //                 amount_unlocked: 0,
    //             };
    //             return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    //         }
    //         dropped_data.push(DroppedItem{
    //             address: post_params.pubkey.clone(),
    //             solana_address: post_params.message,
    //             page_index: (dropped_data.len() / 200) as u8 + 1,
    //         });
    //         //store the updated dropped list
    //         let json_data = serde_json::to_string(&dropped_data).expect("Unable to serialize");

    //         let amount_unlocked = ui_amount_to_token_amount(claimant_entity.unwrap().amount_unlocked);
    //         let amount_locked = ui_amount_to_token_amount(claimant_entity.unwrap().amount_locked);

    //         std::fs::write(path_to_drop_file, json_data).expect("Unable to write file");
    //         let result = call_process_admin_claim(claimant, amount_unlocked, amount_locked, 1);
    //         if !result{
    //             let ret = VestingResp {
    //                 is_success: false,
    //                 error_message: Some("Claim/vesting already exists".to_string()),
    //                 page_index: Some(1),
    //                 amount_locked: amount_locked,
    //                 amount_unlocked: amount_unlocked,
    //             };
    //             return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    //         }
    //         let ret = VestingResp {
    //             is_success: true,
    //             error_message: None,
    //             page_index: Some(1),
    //             amount_locked: amount_locked,
    //             amount_unlocked: amount_unlocked,
    //         };
    //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    //     }
    //     else{
    //         let ret = VestingResp {
    //             is_success: false,
    //             error_message: Some("Invalid ethereum signature".to_string()),
    //             page_index: Some(1),
    //             amount_locked: 0,
    //             amount_unlocked: 0,
    //         };
    //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    //     }
    // }
    // // else if post_params.network == 2 {
    // //     let result = verify::verify_polkadot_signature(&post_params.message.as_bytes(), &post_params.signatures.as_bytes(), &post_params.pubkey);
    // //     let result2 = verify::verify_polkadot_signature_ed25519(&post_params.message.as_bytes(), &post_params.signatures.as_bytes(), &post_params.pubkey);
    // //     if result || result2 {
    // //         use cli::call_process_admin_claim;
    // //         let claimant = Pubkey::from_str(&post_params.message).unwrap();
    // //         let result = call_process_admin_claim(claimant, 1500, 1500, 1);
    // //         if !result{
    // //             let ret = VestingResp {
    // //                 is_success: false,
    // //                 error_message: Some("Claim/vesting already exists".to_string()),
    // //                 page_index: Some(1),
    // //                 amount_locked: 1500,
    // //                 amount_unlocked: 1500,
    // //             };
    // //             return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //         }
    // //         let ret = VestingResp {
    // //             is_success: true,
    // //             error_message: None,
    // //             page_index: Some(1),
    // //             amount_locked: 1500,
    // //             amount_unlocked: 1500,
    // //         };
    // //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //     }
    // //     else{
    // //         let ret = VestingResp {
    // //             is_success: false,
    // //             error_message: Some("Invalid polkadot signature".to_string()),
    // //             page_index: Some(1),
    // //             amount_locked: 0,
    // //             amount_unlocked: 0,
    // //         };
    // //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //     }
    // // } else if post_params.network == 1 {
    // //     let sig_bytes = hex::decode(post_params.signatures);
    // //     let pub_bytes = hex::decode(post_params.pubkey);
    // //     if sig_bytes.is_err()  {
    // //         let ret = VestingResp {
    // //             is_success: false,
    // //             error_message: Some("Invalid cosmos signature hex".to_string()),
    // //             page_index: Some(1),
    // //             amount_locked: 0,
    // //             amount_unlocked: 0,
    // //         };
    // //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //     }
    // //     if pub_bytes.is_err()  {
    // //         let ret = VestingResp {
    // //             is_success: false,
    // //             error_message: Some("Invalid cosmos public key hex".to_string()),
    // //             page_index: Some(1),
    // //             amount_locked: 0,
    // //             amount_unlocked: 0,
    // //         };
    // //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //     }
    // //     let result = verify::verify_cosmos_signature(post_params.message.as_bytes(), &sig_bytes.unwrap(), &pub_bytes.unwrap());
    // //     if result {
    // //         use cli::call_process_admin_claim;
    // //         let claimant = Pubkey::from_str(&post_params.message).unwrap();
    // //         let result = call_process_admin_claim(claimant, 1500, 1500, 1);
    // //         if !result{
    // //             let ret = VestingResp {
    // //                 is_success: false,
    // //                 error_message: Some("Claim/vesting already exists".to_string()),
    // //                 page_index: Some(1),
    // //                 amount_locked: 1500,
    // //                 amount_unlocked: 1500,
    // //             };
    // //             return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //         }
    // //         let ret = VestingResp {
    // //             is_success: true,
    // //             error_message: None,
    // //             page_index: Some(1),
    // //             amount_locked: 1500,
    // //             amount_unlocked: 1500,
    // //         };
    // //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //     }
    // //     else{
    // //         let ret = VestingResp {
    // //             is_success: false,
    // //             error_message: Some("Invalid cosmos signature".to_string()),
    // //             page_index: Some(1),
    // //             amount_locked: 0,
    // //             amount_unlocked: 0,
    // //         };
    // //         return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
    // //     }
    // // }
    // // } else if post_params.network == 1 {
    // //     let result = signature::verify(&post_params.signatures.as_bytes(), &post_params.message.as_bytes(), &post_params.pubkey.as_bytes());
    // //     if result {
    // //         return HttpResponse::Ok().body("Successfully stored parsed signature");
    // //     }
    // // }
    let ret = VestingResp {
        is_success: false,
        error_message: Some("Invalid network. 0 for ethereum, 1 for cosmos, 2 for polkadot".to_string()),
        page_index: Some(1),
        amount_locked: 0,
        amount_unlocked: 0,
    };
    return HttpResponse::Ok().body(serde_json::to_string(&ret).unwrap());
}

#[utoipa::path(
    get,
    path = "/vesting/domain/status",
    params(

    ),
    responses(

    )
)]
pub async fn status(
) -> impl Responder {
    return HttpResponse::Ok().body("Vesting Service are active and ready to accept requests");

}

#[utoipa::path(
    get,
    path = "/vesting/domain/settestvesting",
    params(

    ),
    responses(

    )
)]
pub async fn set_test_vesting(
) -> impl Responder {
    use cli::call_process_admin_claim;
    let claimant = Pubkey::from_str("5pT9ijgv2Qpxn4ux4u4crCCJhgAe4w7GoeaCPJKgP4NW").unwrap();
    call_process_admin_claim(claimant, 1500, 1500, 1);
    return HttpResponse::Ok().body("Service are active and ready to accept requests");
}

#[actix_web::main(flavor = "multi_thread", thread_count = 4)]
async fn main() -> std::io::Result<()> {
    dotenv::dotenv().ok();

    let port = std::env::var("PORT").unwrap_or("3125".to_string()).parse().unwrap();

    let address = std::env::var("ADDRESS").unwrap_or("0.0.0.0".to_string());

    println!("Address: {}", address);
    println!("Port: {}", port);

    #[derive(OpenApi)]
    #[openapi(
        paths(
            get_submit_signature,
            submit_signature,
            status,
            set_test_vesting
        ),
        components(
            schemas(SignatureParams),
        ),
        tags(
            (name = "todo", description = "Todo management endpoints.")
        )
    )]
    struct ApiDoc;

    use actix_cors::Cors;
    let openapi = ApiDoc::openapi();
    HttpServer::new(move || {
        App::new()
            .wrap(
                Cors::default()
                    .allow_any_origin() // Allow requests from any origin
                    .allow_any_method() // Allow any HTTP method (GET, POST, etc.)
                    .allow_any_header() // Allow any header
                    .max_age(3600),     // Cache the CORS preflight response for 1 hour
            )
            .service(web::resource("/vesting/domain/submitsignature").route(web::post().to(submit_signature)))
            .service(web::resource("/vesting/domain/status").route(web::get().to(status)))
            .service(web::resource("/vesting/domain/settestvesting").route(web::get().to(set_test_vesting)))
            .service(web::resource("/vesting/domain/getsubmitsignature").route(web::get().to(get_submit_signature)))
            /* Swagger is working only with >= actix 4 https://docs.rs/utoipa-swagger-ui/latest/utoipa_swagger_ui/ */
            /* Can't change actix version for now */
            // .service(
            //     SwaggerUi::new("/swagger-ui/{_:.*}").url("/api-docs/openapi.json", openapi.clone()),
            // )
    })
    // .bind(("127.0.0.1", 8080))?
    .bind((address, port))?
    .run()
    .await
}