hypercall_api/handlers/

profile_image.rs

use axum::extract::State;
use base64::{engine::general_purpose, Engine as _};
use hypercall_types::WalletAddress;
use reqwest::StatusCode;
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::time::Duration;
use utoipa::ToSchema;

use super::AppState;
use crate::{error::ApiError, middleware::SignerContext, sonic_json::SonicJson};

const MAX_PROFILE_IMAGE_BYTES: usize = 5 * 1024 * 1024;
const DEFAULT_CLOUDFLARE_API_BASE_URL: &str = "https://api.cloudflare.com/client/v4";
const DEFAULT_CLOUDFLARE_VARIANT: &str = "public";
const EXTERNAL_REQUEST_TIMEOUT: Duration = Duration::from_secs(10);

#[derive(Debug, Deserialize, ToSchema)]
pub struct SetProfileImageRequest {
    pub image_data_base64: String,
    pub content_type: String,
    pub image_sha256: String,
}

#[derive(Debug, Serialize, ToSchema)]
pub struct SetProfileImageResponse {
    pub wallet: WalletAddress,
    pub profile_image_url: String,
}

#[derive(Debug, Deserialize)]
struct CloudflareImagesResponse {
    success: bool,
    result: Option<CloudflareImage>,
    errors: Option<Vec<CloudflareError>>,
}

#[derive(Debug, Deserialize)]
struct CloudflareImage {
    id: String,
    variants: Vec<String>,
}

#[derive(Debug, Deserialize)]
struct CloudflareError {
    code: Option<u64>,
    message: String,
}

struct UploadedCloudflareImage {
    id: String,
    url: String,
}

/// Set the authenticated wallet's profile image.
#[utoipa::path(
    post,
    path = "/profile/image",
    request_body = SetProfileImageRequest,
    responses(
        (status = 200, description = "Profile image set", body = SetProfileImageResponse),
        (status = 400, description = "Validation error"),
        (status = 500, description = "Internal server error"),
    ),
    security(("eip712_signature" = [])),
    tag = "Portfolio"
)]
pub async fn set_profile_image(
    State(state): State<AppState>,
    signer_ctx: SignerContext,
    SonicJson(request): SonicJson<SetProfileImageRequest>,
) -> Result<SonicJson<SetProfileImageResponse>, ApiError> {
    let wallet = WalletAddress(signer_ctx.wallet_address.0);
    let content_type = normalize_content_type(&request.content_type)?;
    let bytes = decode_image_data(&request.image_data_base64)?;
    if bytes.len() > MAX_PROFILE_IMAGE_BYTES {
        return Err(ApiError::bad_request("profile image exceeds 5 MB"));
    }
    verify_image_hash(&bytes, &request.image_sha256)?;

    let uploaded_image = upload_cloudflare_image(wallet, &content_type, bytes).await?;
    let previous_profile_image_url = match state
        .competition_service
        .set_profile_image_url(wallet, &uploaded_image.url)
        .await
    {
        Ok(previous_profile_image_url) => previous_profile_image_url,
        Err(error) => {
            tracing::error!(%wallet, error = %error, "failed to persist profile image URL");
            if let Err(cleanup_error) = delete_cloudflare_image(&uploaded_image.id).await {
                tracing::error!(
                    %wallet,
                    image_id = %uploaded_image.id,
                    error = ?cleanup_error,
                    "failed to delete orphaned profile image after DB persistence failure"
                );
            }
            return Err(ApiError::internal_error("Failed to set profile image"));
        }
    };

    if let Some(previous_profile_image_url) = previous_profile_image_url {
        if previous_profile_image_url != uploaded_image.url {
            if let Some(previous_image_id) =
                cloudflare_image_id_from_url(&previous_profile_image_url)
            {
                if previous_image_id != uploaded_image.id {
                    if let Err(cleanup_error) = delete_cloudflare_image(&previous_image_id).await {
                        tracing::error!(
                            %wallet,
                            image_id = %previous_image_id,
                            error = ?cleanup_error,
                            "failed to delete replaced profile image"
                        );
                    }
                }
            }
        }
    }

    Ok(SonicJson(SetProfileImageResponse {
        wallet,
        profile_image_url: uploaded_image.url,
    }))
}

fn normalize_content_type(raw: &str) -> Result<String, ApiError> {
    let content_type = raw.trim().to_ascii_lowercase();
    match content_type.as_str() {
        "image/jpeg" | "image/png" | "image/webp" => Ok(content_type),
        _ => Err(ApiError::bad_request(
            "profile image must be JPEG, PNG, or WEBP",
        )),
    }
}

fn decode_image_data(raw: &str) -> Result<Vec<u8>, ApiError> {
    let encoded = raw
        .split_once(',')
        .map(|(_, data)| data)
        .unwrap_or(raw)
        .trim();
    general_purpose::STANDARD
        .decode(encoded)
        .or_else(|_| general_purpose::URL_SAFE_NO_PAD.decode(encoded))
        .map_err(|_| ApiError::bad_request("profile image data is not valid base64"))
}

fn verify_image_hash(bytes: &[u8], expected: &str) -> Result<(), ApiError> {
    let expected = expected
        .trim()
        .trim_start_matches("0x")
        .to_ascii_lowercase();
    if expected.len() != 64 || !expected.chars().all(|ch| ch.is_ascii_hexdigit()) {
        return Err(ApiError::bad_request(
            "image_sha256 must be a SHA-256 hex digest",
        ));
    }
    let actual = hex::encode(Sha256::digest(bytes));
    if actual != expected {
        return Err(ApiError::bad_request(
            "image_sha256 does not match image data",
        ));
    }
    Ok(())
}

async fn upload_cloudflare_image(
    wallet: WalletAddress,
    content_type: &str,
    bytes: Vec<u8>,
) -> Result<UploadedCloudflareImage, ApiError> {
    let image_id = profile_image_id_for_wallet(wallet);
    match upload_cloudflare_image_once(&image_id, content_type, bytes.clone()).await {
        Ok(uploaded_image) => return Ok(uploaded_image),
        Err(CloudflareUploadError::DuplicateCustomId) => {
            delete_cloudflare_image(&image_id).await?;
        }
        Err(CloudflareUploadError::Api(error)) => return Err(error),
    }

    upload_cloudflare_image_once(&image_id, content_type, bytes)
        .await
        .map_err(|error| match error {
            CloudflareUploadError::DuplicateCustomId => {
                ApiError::internal_error("Failed to replace profile image")
            }
            CloudflareUploadError::Api(error) => error,
        })
}

enum CloudflareUploadError {
    DuplicateCustomId,
    Api(ApiError),
}

async fn upload_cloudflare_image_once(
    image_id: &str,
    content_type: &str,
    bytes: Vec<u8>,
) -> Result<UploadedCloudflareImage, CloudflareUploadError> {
    let account_id = std::env::var("CLOUDFLARE_IMAGES_ACCOUNT_ID")
        .map_err(|_| cloudflare_upload_error("Cloudflare Images is not configured"))?;
    let api_token = std::env::var("CLOUDFLARE_IMAGES_API_TOKEN")
        .map_err(|_| cloudflare_upload_error("Cloudflare Images is not configured"))?;
    let api_base_url = std::env::var("CLOUDFLARE_IMAGES_API_BASE_URL")
        .unwrap_or_else(|_| DEFAULT_CLOUDFLARE_API_BASE_URL.to_string());
    let variant = std::env::var("CLOUDFLARE_IMAGES_VARIANT")
        .unwrap_or_else(|_| DEFAULT_CLOUDFLARE_VARIANT.to_string());
    let url = format!(
        "{}/accounts/{}/images/v1",
        api_base_url.trim().trim_end_matches('/'),
        account_id.trim()
    );
    let part = reqwest::multipart::Part::bytes(bytes)
        .file_name(profile_image_filename(content_type))
        .mime_str(content_type)
        .map_err(|_| cloudflare_upload_error("invalid profile image content type"))?;
    let metadata = serde_json::to_string(&serde_json::json!({
        "source": "hypercall-profile",
    }))
    .map_err(|_| cloudflare_upload_error("Failed to prepare profile image metadata"))?;
    let form = reqwest::multipart::Form::new()
        .text("id", image_id.to_string())
        .part("file", part)
        .text("requireSignedURLs", "false")
        .text("metadata", metadata);
    let client = reqwest::Client::builder()
        .timeout(EXTERNAL_REQUEST_TIMEOUT)
        .build()
        .map_err(|error| {
            tracing::error!(error = %error, "Cloudflare Images client build failed");
            cloudflare_upload_error("Failed to upload profile image")
        })?;
    let response = client
        .post(url)
        .bearer_auth(api_token.trim())
        .multipart(form)
        .send()
        .await
        .map_err(|error| {
            tracing::error!(error = %error, "Cloudflare Images upload failed");
            cloudflare_upload_error("Failed to upload profile image")
        })?;
    let status = response.status();
    let body = response.text().await.map_err(|error| {
        tracing::error!(error = %error, "Cloudflare Images response read failed");
        cloudflare_upload_error("Failed to upload profile image")
    })?;
    if !status.is_success() {
        if cloudflare_response_has_error_code(&body, 5409) {
            return Err(CloudflareUploadError::DuplicateCustomId);
        }
        tracing::error!(%status, body, "Cloudflare Images returned error");
        return Err(cloudflare_upload_error("Failed to upload profile image"));
    }
    let response = serde_json::from_str::<CloudflareImagesResponse>(&body).map_err(|error| {
        tracing::error!(error = %error, "Cloudflare Images response parse failed");
        cloudflare_upload_error("Failed to upload profile image")
    })?;
    if !response.success {
        if response
            .errors
            .as_ref()
            .is_some_and(|errors| errors.iter().any(|error| error.code == Some(5409)))
        {
            return Err(CloudflareUploadError::DuplicateCustomId);
        }
        let message = response
            .errors
            .unwrap_or_default()
            .into_iter()
            .map(|error| error.message)
            .collect::<Vec<_>>()
            .join(", ");
        tracing::error!(message, "Cloudflare Images upload rejected");
        return Err(cloudflare_upload_error("Failed to upload profile image"));
    }
    let image = response
        .result
        .ok_or_else(|| cloudflare_upload_error("Cloudflare Images response missing result"))?;
    let url = image
        .variants
        .iter()
        .find(|url| url.ends_with(&format!("/{}", variant.trim())))
        .cloned()
        .or_else(|| image.variants.first().cloned())
        .ok_or_else(|| cloudflare_upload_error("Cloudflare Images response missing variant"))?;
    if let Some(custom_url) = custom_delivery_url(&url) {
        return Ok(UploadedCloudflareImage {
            id: image.id,
            url: custom_url,
        });
    }
    Ok(UploadedCloudflareImage { id: image.id, url })
}

fn cloudflare_upload_error(message: &'static str) -> CloudflareUploadError {
    CloudflareUploadError::Api(ApiError::internal_error(message))
}

fn profile_image_id_for_wallet(wallet: WalletAddress) -> String {
    wallet.as_hex().to_ascii_lowercase()
}

fn profile_image_filename(content_type: &str) -> &'static str {
    match content_type {
        "image/jpeg" => "profile-image.jpg",
        "image/png" => "profile-image.png",
        "image/webp" => "profile-image.webp",
        _ => "profile-image",
    }
}

fn cloudflare_response_has_error_code(body: &str, expected_code: u64) -> bool {
    serde_json::from_str::<CloudflareImagesResponse>(body)
        .ok()
        .and_then(|response| response.errors)
        .is_some_and(|errors| errors.iter().any(|error| error.code == Some(expected_code)))
}

fn custom_delivery_url(cloudflare_variant_url: &str) -> Option<String> {
    let host = std::env::var("CLOUDFLARE_IMAGES_DELIVERY_DOMAIN")
        .or_else(|_| std::env::var("CLOUDFLARE_IMAGES_DELIVERY_HOST"))
        .ok()?;
    custom_delivery_url_for_host(&host, cloudflare_variant_url)
}

fn custom_delivery_url_for_host(host: &str, cloudflare_variant_url: &str) -> Option<String> {
    let host = host
        .trim()
        .trim_start_matches("https://")
        .trim_start_matches("http://")
        .trim_end_matches('/');
    if host.is_empty() {
        return None;
    }

    let delivery_path = cloudflare_variant_url
        .trim_start_matches("https://")
        .trim_start_matches("http://")
        .split_once('/')
        .map(|(_, path)| path)?;
    Some(format!(
        "https://{host}/cdn-cgi/imagedelivery/{delivery_path}"
    ))
}

fn cloudflare_image_id_from_url(url: &str) -> Option<String> {
    let url = reqwest::Url::parse(url).ok()?;
    let segments = url.path_segments()?.collect::<Vec<_>>();
    if let ["cdn-cgi", "imagedelivery", _account_hash, image_id, ..] = segments.as_slice() {
        return Some((*image_id).to_string());
    }
    if url.host_str() == Some("imagedelivery.net") {
        return segments.get(1).map(|image_id| (*image_id).to_string());
    }
    segments.first().map(|image_id| (*image_id).to_string())
}

async fn delete_cloudflare_image(image_id: &str) -> Result<(), ApiError> {
    let account_id = std::env::var("CLOUDFLARE_IMAGES_ACCOUNT_ID")
        .map_err(|_| ApiError::internal_error("Cloudflare Images is not configured"))?;
    let api_token = std::env::var("CLOUDFLARE_IMAGES_API_TOKEN")
        .map_err(|_| ApiError::internal_error("Cloudflare Images is not configured"))?;
    let api_base_url = std::env::var("CLOUDFLARE_IMAGES_API_BASE_URL")
        .unwrap_or_else(|_| DEFAULT_CLOUDFLARE_API_BASE_URL.to_string());
    let url = format!(
        "{}/accounts/{}/images/v1/{}",
        api_base_url.trim().trim_end_matches('/'),
        account_id.trim(),
        image_id
    );
    let client = reqwest::Client::builder()
        .timeout(EXTERNAL_REQUEST_TIMEOUT)
        .build()
        .map_err(|error| {
            tracing::error!(error = %error, "Cloudflare Images delete client build failed");
            ApiError::internal_error("Failed to delete profile image")
        })?;
    let response = client
        .delete(url)
        .bearer_auth(api_token.trim())
        .send()
        .await
        .map_err(|error| {
            tracing::error!(error = %error, "Cloudflare Images delete failed");
            ApiError::internal_error("Failed to delete profile image")
        })?;
    let status = response.status();
    if status.is_success() || status == StatusCode::NOT_FOUND {
        return Ok(());
    }
    let body = response.text().await.unwrap_or_default();
    tracing::error!(%status, body, "Cloudflare Images delete returned error");
    Err(ApiError::internal_error("Failed to delete profile image"))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn validates_image_hash() {
        let bytes = b"profile";
        let hash = hex::encode(Sha256::digest(bytes));
        verify_image_hash(bytes, &hash).unwrap();
        assert!(verify_image_hash(bytes, "00").is_err());
    }

    #[test]
    fn decodes_plain_and_data_url_base64() {
        let encoded = general_purpose::STANDARD.encode(b"abc");
        assert_eq!(decode_image_data(&encoded).unwrap(), b"abc");
        assert_eq!(
            decode_image_data(&format!("data:image/png;base64,{encoded}")).unwrap(),
            b"abc"
        );
    }

    #[test]
    fn rejects_unsupported_content_types() {
        assert!(normalize_content_type("image/png").is_ok());
        assert!(normalize_content_type("text/html").is_err());
    }

    #[test]
    fn profile_image_id_is_lowercase_wallet_address() {
        let wallet = "0x1EA156C6722c11c04A73dC9080e55f6AC0e676A3"
            .parse::<WalletAddress>()
            .unwrap();

        assert_eq!(
            profile_image_id_for_wallet(wallet),
            "0x1ea156c6722c11c04a73dc9080e55f6ac0e676a3"
        );
    }

    #[test]
    fn chooses_file_extension_for_content_type() {
        assert_eq!(profile_image_filename("image/jpeg"), "profile-image.jpg");
        assert_eq!(profile_image_filename("image/png"), "profile-image.png");
        assert_eq!(profile_image_filename("image/webp"), "profile-image.webp");
    }

    #[test]
    fn detects_cloudflare_duplicate_custom_id_error_with_pretty_json() {
        let body = r#"{
          "result": null,
          "success": false,
          "errors": [
            {
              "code": 5409,
              "message": "Resource already exists. Verify the resource information and try again."
            }
          ],
          "messages": []
        }"#;

        assert!(cloudflare_response_has_error_code(body, 5409));
        assert!(!cloudflare_response_has_error_code(body, 5404));
    }

    #[test]
    fn custom_delivery_url_uses_cloudflare_imagedelivery_path() {
        let url = custom_delivery_url_for_host(
            "hypercall.xyz",
            "https://imagedelivery.net/account_hash/image-id/public",
        )
        .unwrap();

        assert_eq!(
            url,
            "https://hypercall.xyz/cdn-cgi/imagedelivery/account_hash/image-id/public"
        );
    }

    #[test]
    fn extracts_cloudflare_image_id_from_delivery_urls() {
        assert_eq!(
            cloudflare_image_id_from_url("https://imagedelivery.net/account_hash/image-id/public"),
            Some("image-id".to_string())
        );
        assert_eq!(
            cloudflare_image_id_from_url(
                "https://hypercall.xyz/cdn-cgi/imagedelivery/account_hash/image-id/public"
            ),
            Some("image-id".to_string())
        );
        assert_eq!(
            cloudflare_image_id_from_url("https://hypercall.xyz/image-id/public"),
            Some("image-id".to_string())
        );
    }
}