anya-core 1.2.0

use std::error::Error;
use std::collections::HashMap;
use std::sync::Arc;
use async_trait::async_trait;
use chrono::Utc;
use uuid::Uuid;
use tokio::sync::Mutex;

use crate::security::hsm::provider::{
    HsmProvider, KeyGenParams, PublicKeyInfo, KeyInfo, KeyType,
    KeyUsage, SigningAlgorithm, EncryptionAlgorithm, EcCurve
};
use crate::security::hsm::error::HsmError;

/// Bitcoin HSM configuration
/// [AIR-3][AIS-3][AIT-3][AIP-3][RES-3]
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct BitcoinHsmConfig {
    /// Base HSM provider to use
    pub base_provider: Arc<dyn HsmProvider>,
    
    /// Bitcoin network (mainnet, testnet, signet, regtest)
    pub network: BitcoinNetwork,
    
    /// Default key derivation path template
    pub derivation_path_template: String,
    
    /// Whether to use Taproot keys by default
    pub use_taproot: bool,
    
    /// Default Miniscript policy template for Taproot scripts
    pub miniscript_policy_template: Option<String>,
    
    /// Default key type to use for Bitcoin operations
    pub default_key_type: BitcoinKeyType,
}

impl Default for BitcoinHsmConfig {
    fn default() -> Self {
        Self {
            base_provider: Arc::new(NoopHsmProvider {}),
            network: BitcoinNetwork::Testnet,
            derivation_path_template: "m/86'/0'/0'/0/{}".to_string(),
            use_taproot: true,
            miniscript_policy_template: Some("and(pk(@0),or(pk(@1),after(144)))".to_string()),
            default_key_type: BitcoinKeyType::Taproot,
        }
    }
}

/// Bitcoin network types
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum BitcoinNetwork {
    /// Bitcoin mainnet
    Mainnet,
    /// Bitcoin testnet
    Testnet,
    /// Bitcoin signet
    Signet,
    /// Bitcoin regtest
    Regtest,
}

/// Bitcoin key types
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum BitcoinKeyType {
    /// Legacy P2PKH keys
    Legacy,
    /// P2SH-P2WPKH keys (SegWit v0 nested)
    SegwitNested,
    /// P2WPKH keys (SegWit v0 native)
    SegwitNative,
    /// P2TR keys (Taproot, SegWit v1)
    Taproot,
}

/// Bitcoin signature type
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum BitcoinSignatureType {
    /// ECDSA signature
    Ecdsa,
    /// Schnorr signature (for Taproot)
    Schnorr,
}

/// Placeholder for a noop HSM provider that does nothing
struct NoopHsmProvider {}

#[async_trait]
impl HsmProvider for NoopHsmProvider {
    async fn initialize(&mut self) -> Result<(), HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn generate_key_pair(&self, __params: KeyGenParams) -> Result<PublicKeyInfo, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn sign(&self, __key_id: &str, __algorithm: SigningAlgorithm, __data: &[u8]) -> Result<Vec<u8>, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn verify(&self, __key_id: &str, __algorithm: SigningAlgorithm, __data: &[u8], __signature: &[u8]) -> Result<bool, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn encrypt(&self, __key_id: &str, _algorithm: EncryptionAlgorithm, __data: &[u8], _iv: Option<&[u8]>) -> Result<Vec<u8>, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn decrypt(&self, __key_id: &str, _algorithm: EncryptionAlgorithm, __data: &[u8], _iv: Option<&[u8]>) -> Result<Vec<u8>, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn get_key_info(&self, __key_id: &str) -> Result<KeyInfo, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn list_keys(&self) -> Result<Vec<KeyInfo>, HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn delete_key(&self, __key_id: &str) -> Result<(), HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
    
    async fn close(&self) -> Result<(), HsmError> {
        Err(HsmError::UnsupportedOperation("Not implemented".to_string()))
    }
}

/// Bitcoin-specific HSM provider
/// 
/// This provider extends the base HSM provider with Bitcoin-specific functionality,
/// including support for Taproot keys, DLCs, and Bitcoin signature schemes.
/// 
/// [AIR-3][AIS-3][AIT-3][AIP-3][RES-3]
pub struct BitcoinHsmProvider {
    /// Configuration
    config: BitcoinHsmConfig,
    
    /// Derivation paths for generated keys
    derivation_paths: Mutex<HashMap<String, String>>,
    
    /// Script details for generated keys
    script_details: Mutex<HashMap<String, BitcoinScriptDetails>>,
}

/// Bitcoin script details
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct BitcoinScriptDetails {
    /// Script type
    pub script_type: BitcoinScriptType,
    
    /// Script hex
    pub script_hex: String,
    
    /// Address
    pub address: String,
    
    /// Miniscript policy (if applicable)
    pub miniscript_policy: Option<String>,
    
    /// Taproot output key (if applicable)
    pub taproot_output_key: Option<String>,
    
    /// Taproot internal key (if applicable)
    pub taproot_internal_key: Option<String>,
    
    /// Taproot merkle root (if applicable)
    pub taproot_merkle_root: Option<String>,
}

/// Bitcoin script types
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub enum BitcoinScriptType {
    /// P2PKH (Pay to Public Key Hash)
    P2PKH,
    /// P2SH (Pay to Script Hash)
    P2SH,
    /// P2WPKH (Pay to Witness Public Key Hash)
    P2WPKH,
    /// P2WSH (Pay to Witness Script Hash)
    P2WSH,
    /// P2TR (Pay to Taproot)
    P2TR,
    /// Custom script
    Custom(String),
}

impl BitcoinHsmProvider {
    /// Create a new Bitcoin HSM provider
    pub fn new(config: BitcoinHsmConfig) -> Self {
        Self {
            config,
            derivation_paths: Mutex::new(HashMap::new()),
            script_details: Mutex::new(HashMap::new()),
        }
    }
    
    /// Generate a Bitcoin key
    pub async fn generate_bitcoin_key(
        &self,
        key_purpose: &str,
        bitcoin_key_type: Option<BitcoinKeyType>,
        derivation_index: Option<u32>,
    ) -> Result<BitcoinKeyInfo, HsmError> {
        let key_type = bitcoin_key_type.unwrap_or(self.config.default_key_type);
        
        // Determine appropriate EC curve
        let ec_curve = EcCurve::Secp256k1;
        
        // Create key generation parameters
        let key_id = Uuid::new_v4().to_string();
        let key_label = format!("bitcoin-{}-{}", key_purpose, key_id);
        
        let params = KeyGenParams {
            id: Some(key_id.clone()),
            label: key_label,
            key_type: KeyType::Ec { curve: ec_curve },
            extractable: false,  // Private keys should never be extractable for Bitcoin operations
            usages: vec![KeyUsage::Sign, KeyUsage::Verify],
            expires_at: None,    // Bitcoin keys typically don't expire
            attributes: HashMap::new(),
        };
        
        // Generate the key pair using the base provider
        let public_key_info = self.config.base_provider.generate_key_pair(params).await?;
        
        // Calculate derivation path
        let derivation_path = match derivation_index {
            Some(index) => self.config.derivation_path_template.replace("{}", &index.to_string()),
            None => self.config.derivation_path_template.replace("{}", "0"),
        };
        
        // Store derivation path
        {
            let mut derivation_paths = self.derivation_paths.lock().await;
            derivation_paths.insert(key_id.clone(), derivation_path.clone());
        }
        
        // Create script details based on key type
        let script_details = self.create_script_details(key_type, &public_key_info, key_purpose).await?;
        
        // Store script details
        {
            let mut scripts = self.script_details.lock().await;
            scripts.insert(key_id.clone(), script_details.clone());
        }
        
        // Create Bitcoin key info
        let bitcoin_key_info = BitcoinKeyInfo {
            key_id: key_id.clone(),
            public_key_info,
            key_type,
            derivation_path,
            network: self.config.network,
            script_details,
            created_at: Utc::now(),
        };
        
        Ok(bitcoin_key_info)
    }
    
    /// Create script details for a Bitcoin key
    async fn create_script_details(
        &self,
        key_type: BitcoinKeyType,
        public_key_info: &PublicKeyInfo,
        key_purpose: &str,
    ) -> Result<BitcoinScriptDetails, HsmError> {
        // In a real implementation, this would use bitcoin crate to create actual scripts and addresses
        // Here we just create placeholder values
        
        let (script_type, address, script_hex) = match key_type {
            BitcoinKeyType::Legacy => {
                let script_type = BitcoinScriptType::P2PKH;
                let address = format!("1Example{}", key_purpose.chars().next().unwrap_or('X'));
                let script_hex = "76a914...88ac".to_string(); // Simplified placeholder
                (script_type, address, script_hex)
            },
            BitcoinKeyType::SegwitNested => {
                let script_type = BitcoinScriptType::P2SH;
                let address = format!("3Example{}", key_purpose.chars().next().unwrap_or('X'));
                let script_hex = "a914...87".to_string(); // Simplified placeholder
                (script_type, address, script_hex)
            },
            BitcoinKeyType::SegwitNative => {
                let script_type = BitcoinScriptType::P2WPKH;
                let address = format!("bc1q{}", key_purpose.chars().next().unwrap_or('x'));
                let script_hex = "0014...".to_string(); // Simplified placeholder
                (script_type, address, script_hex)
            },
            BitcoinKeyType::Taproot => {
                let script_type = BitcoinScriptType::P2TR;
                let address = format!("bc1p{}", key_purpose.chars().next().unwrap_or('x'));
                let script_hex = "5120...".to_string(); // Simplified placeholder
                (script_type, address, script_hex)
            },
        };
        
        // For Taproot keys, create additional details
        let (taproot_output_key, taproot_internal_key, taproot_merkle_root, miniscript_policy) = 
            if key_type == BitcoinKeyType::Taproot {
                (
                    Some(hex::encode(&public_key_info.public_key)),
                    Some(format!("internal_{}", hex::encode(&public_key_info.public_key[0..4]))),
                    Some("merkle_root_placeholder".to_string()),
                    self.config.miniscript_policy_template.clone(),
                )
            } else {
                (None, None, None, None)
            };
        
        Ok(BitcoinScriptDetails {
            script_type,
            script_hex,
            address,
            miniscript_policy,
            taproot_output_key,
            taproot_internal_key,
            taproot_merkle_root,
        })
    }
    
    /// Sign a Bitcoin transaction
    pub async fn sign_bitcoin_transaction(
        &self,
        _key_id: &str,
        tx_hex: &str,
        signature_type: BitcoinSignatureType,
        sighash_type: u8,
    ) -> Result<Vec<u8>, HsmError> {
        // Get key info
        let key_info = self.config.base_provider.get_key_info(key_id).await?;
        
        // Get script details
        let script_details = {
            let scripts = self.script_details.lock().await;
            match scripts.get(key_id) {
                Some(script) => script.clone(),
                None => return Err(HsmError::InvalidParameterss(format!("No script details found for key {}", key_id))),
            }
        };
        
        // In a real implementation, this would parse the transaction, extract the sighash,
        // and create the proper signature. Here we just create a placeholder signature.
        let algorithm = match signature_type {
            BitcoinSignatureType::Ecdsa => SigningAlgorithm::EcdsaSha256,
            BitcoinSignatureType::Schnorr => {
                // Check if key type supports Schnorr
                if script_details.script_type != BitcoinScriptType::P2TR {
                    return Err(HsmError::InvalidParameterss(
                        "Schnorr signatures can only be used with Taproot keys".to_string()
                    ));
                }
                SigningAlgorithm::Ed25519 // Placeholder, in reality would use native Schnorr
            },
        };
        
        // Create sighash placeholder
        let sighash_placeholder = format!("{}_{}", tx_hex, sighash_type);
        
        // Sign the sighash
        let signature = self.config.base_provider.sign(
            key_id,
            algorithm,
            sighash_placeholder.as_bytes(),
        ).await?;
        
        // In a real implementation, we would append the sighash type
        let mut signature_with_sighash = signature.clone();
        signature_with_sighash.push(sighash_type);
        
        Ok(signature_with_sighash)
    }
    
    /// Create a Taproot output
    pub async fn create_taproot_output(
        &self,
        internal__key_id: &str,
        script_tree: Option<TaprootScriptTree>,
    ) -> Result<TaprootOutputInfo, HsmError> {
        // Get internal key info
        let internal_key_info = self.config.base_provider.get_key_info(internal_key_id).await?;
        
        // Ensure it's the right type of key
        if let KeyType::Ec { curve } = internal_key_info.key_type {
            if curve != EcCurve::Secp256k1 {
                return Err(HsmError::InvalidParameterss(
                    "Taproot internal key must be secp256k1".to_string()
                ));
            }
        } else {
            return Err(HsmError::InvalidParameterss(
                "Taproot internal key must be EC key".to_string()
            ));
        }
        
        // In a real implementation, this would compute the Taproot output key
        // from the internal key and script tree using BIP 341 algorithms
        
        // For now, create placeholder values
        let output_key_id = Uuid::new_v4().to_string();
        let output_key_bytes = vec![0xDE, 0xAD, 0xBE, 0xEF]; // Placeholder
        
        // Store the Taproot output details
        let script_details = BitcoinScriptDetails {
            script_type: BitcoinScriptType::P2TR,
            script_hex: "5120...".to_string(), // Placeholder
            address: format!("bc1p{}", hex::encode(&output_key_bytes[0..4])),
            miniscript_policy: None,
            taproot_output_key: Some(hex::encode(&output_key_bytes)),
            taproot_internal_key: Some(internal_key_id.to_string()),
            taproot_merkle_root: script_tree.as_ref().map(|_| "merkle_root_placeholder".to_string()),
        };
        
        {
            let mut scripts = self.script_details.lock().await;
            scripts.insert(output_key_id.clone(), script_details.clone());
        }
        
        Ok(TaprootOutputInfo {
            output_key_id,
            output_key: output_key_bytes,
            output_script: "5120...".to_string(), // Placeholder
            address: script_details.address,
            script_details,
        })
    }
    
    /// Verify a Bitcoin SPV proof
    pub async fn verify_bitcoin_spv_proof(&self, proof: BitcoinSpvProof) -> Result<bool, HsmError> {
        // In a real implementation, this would verify the SPV proof against the
        // Bitcoin blockchain headers stored in the HSM or fetched from a trusted source
        
        // For DLCs, this would include verification of oracle signatures
        
        // Since this is a placeholder, we just return true
        Ok(true)
    }
    
    /// Get Bitcoin key info
    pub async fn get_bitcoin_key_info(&self, _key_id: &str) -> Result<BitcoinKeyInfo, HsmError> {
        // Get key info from base provider
        let public_key_info = match self.config.base_provider.get_key_info(key_id).await {
            Ok(key_info) => PublicKeyInfo {
                id: key_info.id,
                label: key_info.label,
                key_type: key_info.key_type,
                public_key: vec![], // Placeholder, would get actual public key
                usages: key_info.usages,
                created_at: key_info.created_at,
                expires_at: key_info.expires_at,
                attributes: key_info.attributes,
            },
            Err(err) => return Err(err),
        };
        
        // Get derivation path
        let derivation_path = {
            let derivation_paths = self.derivation_paths.lock().await;
            match derivation_paths.get(key_id) {
                Some(path) => path.clone(),
                None => "unknown".to_string(),
            }
        };
        
        // Get script details
        let script_details = {
            let scripts = self.script_details.lock().await;
            match scripts.get(key_id) {
                Some(script) => script.clone(),
                None => {
                    // Create a default script detail if missing
                    BitcoinScriptDetails {
                        script_type: BitcoinScriptType::Custom("unknown".to_string()),
                        script_hex: "unknown".to_string(),
                        address: "unknown".to_string(),
                        miniscript_policy: None,
                        taproot_output_key: None,
                        taproot_internal_key: None,
                        taproot_merkle_root: None,
                    }
                },
            }
        };
        
        // Determine key type from script type
        let key_type = match script_details.script_type {
            BitcoinScriptType::P2PKH => BitcoinKeyType::Legacy,
            BitcoinScriptType::P2SH => BitcoinKeyType::SegwitNested,
            BitcoinScriptType::P2WPKH | BitcoinScriptType::P2WSH => BitcoinKeyType::SegwitNative,
            BitcoinScriptType::P2TR => BitcoinKeyType::Taproot,
            BitcoinScriptType::Custom(_) => BitcoinKeyType::Legacy, // Default to legacy for unknown types
        };
        
        Ok(BitcoinKeyInfo {
            key_id: key_id.to_string(),
            public_key_info,
            key_type,
            derivation_path,
            network: self.config.network,
            script_details,
            created_at: Utc::now(), // In a real implementation, would use actual creation time
        })
    }
    
    /// Sign a message using a Bitcoin key (for message signing, not transactions)
    pub async fn sign_bitcoin_message(
        &self,
        _key_id: &str,
        message: &str,
        use_standard_format: bool,
    ) -> Result<String, HsmError> {
        // Get key info
        let key_info = self.config.base_provider.get_key_info(key_id).await?;
        
        // Get script details to determine signature type
        let script_details = {
            let scripts = self.script_details.lock().await;
            match scripts.get(key_id) {
                Some(script) => script.clone(),
                None => return Err(HsmError::InvalidParameterss(format!("No script details found for key {}", key_id))),
            }
        };
        
        // Determine signature algorithm
        let algorithm = match script_details.script_type {
            BitcoinScriptType::P2TR => SigningAlgorithm::Ed25519, // Placeholder for Schnorr
            _ => SigningAlgorithm::EcdsaSha256,
        };
        
        // Prepare message for signing according to Bitcoin standard
        // In standard format: "\x18Bitcoin Signed Message:\n" + len(message) + message
        let message_to_sign = if use_standard_format {
            let prefix = "\x18Bitcoin Signed Message:\n";
            let msg_len = message.len();
            let mut formatted = prefix.as_bytes().to_vec();
            formatted.push(msg_len as u8); // Simplified, should handle variable-length encoding
            formatted.extend_from_slice(message.as_bytes());
            formatted
        } else {
            message.as_bytes().to_vec()
        };
        
        // Sign the message
        let signature = self.config.base_provider.sign(
            key_id,
            algorithm,
            &message_to_sign,
        ).await?;
        
        // In a real implementation, would encode signature according to Bitcoin standards
        // For now, just return base64 encoded signature
        Ok(base64::encode(signature))
    }
}

/// Taproot script tree for complex Taproot outputs
#[derive(Debug, Clone)]
pub struct TaprootScriptTree {
    /// Root node of the script tree
    pub root: TaprootScriptNode,
}

/// Node in a Taproot script tree
#[derive(Debug, Clone)]
pub enum TaprootScriptNode {
    /// Leaf node with script
    Leaf {
        /// Script hex
        script: String,
        /// Leaf version
        version: u8,
    },
    /// Internal node with two children
    Branch {
        /// Left child
        left: Box<TaprootScriptNode>,
        /// Right child
        right: Box<TaprootScriptNode>,
    },
}

/// Bitcoin SPV proof
#[derive(Debug, Clone)]
pub struct BitcoinSpvProof {
    /// Transaction hash
    pub tx_hash: String,
    /// Block header hex
    pub block_header: String,
    /// Merkle proof
    pub merkle_proof: Vec<String>,
    /// Block height
    pub block_height: u32,
    /// Confirmations
    pub confirmations: u32,
}

/// Information about a Taproot output
#[derive(Debug, Clone)]
pub struct TaprootOutputInfo {
    /// Output key ID
    pub output_key_id: String,
    /// Output key
    pub output_key: Vec<u8>,
    /// Output script
    pub output_script: String,
    /// Address
    pub address: String,
    /// Script details
    pub script_details: BitcoinScriptDetails,
}

/// Information about a Bitcoin key
#[derive(Debug, Clone)]
pub struct BitcoinKeyInfo {
    /// Key ID
    pub key_id: String,
    /// Public key information
    pub public_key_info: PublicKeyInfo,
    /// Bitcoin key type
    pub key_type: BitcoinKeyType,
    /// Derivation path
    pub derivation_path: String,
    /// Bitcoin network
    pub network: BitcoinNetwork,
    /// Script details
    pub script_details: BitcoinScriptDetails,
    /// Creation timestamp
    pub created_at: chrono::DateTime<chrono::Utc>,
}

/// DLC (Discreet Log Contract) parameters
#[derive(Debug, Clone)]
pub struct DlcParams {
    /// Oracle public keys
    pub oracle_public_keys: Vec<String>,
    /// Oracle signature points
    pub oracle_r_points: Vec<String>,
    /// Contract information
    pub contract_info: DlcContractInfo,
    /// CETs (Contract Execution Transactions)
    pub cets: Vec<DlcCetInfo>,
}

/// DLC contract information
#[derive(Debug, Clone)]
pub struct DlcContractInfo {
    /// Contract descriptor
    pub descriptor: String,
    /// Contract outcomes
    pub outcomes: Vec<DlcOutcome>,
    /// Contract maturity time
    pub maturity_time: chrono::DateTime<chrono::Utc>,
}

/// DLC outcome
#[derive(Debug, Clone)]
pub struct DlcOutcome {
    /// Outcome value
    pub value: String,
    /// Payout for party A
    pub payout_a: u64,
    /// Payout for party B
    pub payout_b: u64,
}

/// DLC CET (Contract Execution Transaction) information
#[derive(Debug, Clone)]
pub struct DlcCetInfo {
    /// Outcome index
    pub outcome_index: usize,
    /// Transaction hex
    pub tx_hex: String,
    /// Adaptor signature for party A
    pub adaptor_sig_a: Option<String>,
    /// Adaptor signature for party B
    pub adaptor_sig_b: Option<String>,
}

/// Create a DLC (Discreet Log Contract)
pub async fn create_dlc(
    hsm_provider: &BitcoinHsmProvider,
    funding__key_id: &str,
    dlc_params: DlcParams,
) -> Result<DlcInfo, HsmError> {
    // In a real implementation, this would create a DLC using the funding key
    // and the provided DLC parameters, including oracle information and CETs
    
    // Since this is a placeholder, we just create a dummy DLC
    let dlc_id = Uuid::new_v4().to_string();
    
    Ok(DlcInfo {
        dlc_id,
        funding_key_id: funding_key_id.to_string(),
        contract_id: Uuid::new_v4().to_string(),
        funding_tx_id: format!("{}_{}", dlc_id, "funding"),
        refund_tx_id: format!("{}_{}", dlc_id, "refund"),
        cet_tx_ids: dlc_params.cets.iter().enumerate()
            .map(|(i, _)| format!("{}_{}", dlc_id, i))
            .collect(),
        status: DlcStatus::Created,
        creation_time: Utc::now(),
    })
}

/// DLC information
#[derive(Debug, Clone)]
pub struct DlcInfo {
    /// DLC ID
    pub dlc_id: String,
    /// Funding key ID
    pub funding_key_id: String,
    /// Contract ID
    pub contract_id: String,
    /// Funding transaction ID
    pub funding_tx_id: String,
    /// Refund transaction ID
    pub refund_tx_id: String,
    /// CET transaction IDs
    pub cet_tx_ids: Vec<String>,
    /// DLC status
    pub status: DlcStatus,
    /// Creation timestamp
    pub creation_time: chrono::DateTime<chrono::Utc>,
}

/// DLC status
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DlcStatus {
    /// DLC has been created but not funded
    Created,
    /// DLC has been funded
    Funded,
    /// DLC has been executed
    Executed,
    /// DLC has been refunded
    Refunded,
    /// DLC has been canceled
    Canceled,
}