1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use beserial::{Deserialize, Serialize, ReadBytesExt, WriteBytesExt, SerializingError};
use keys::Address;
use block::Block;
use transaction::Transaction;
use primitives::coin::Coin;
use std::collections::HashSet;

#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
#[repr(u8)]
pub enum SubscriptionType {
    None = 0,
    Any = 1,
    Addresses = 2,
    MinFee = 3
}


#[derive(Clone, Debug)]
pub enum Subscription {
    None,
    Any,
    Addresses(HashSet<Address>),
    MinFee(Coin), // Fee per byte
}


impl Subscription {
    pub fn subscription_type(&self) -> SubscriptionType {
        match self {
            Subscription::None => SubscriptionType::None,
            Subscription::Any => SubscriptionType::Any,
            Subscription::Addresses(_) => SubscriptionType::Addresses,
            Subscription::MinFee(_) => SubscriptionType::MinFee
        }
    }

    pub fn matches_block(&self, _block: &Block) -> bool {
        match self {
            Subscription::None => false,
            _ => true
        }
    }

    pub fn matches_transaction(&self, transaction: &Transaction) -> bool {
        match self {
            Subscription::None => false,
            Subscription::Any => true,
            Subscription::Addresses(addresses) => addresses.contains(&transaction.sender),
            Subscription::MinFee(min_fee) => {
                // TODO: Potential overflow for u64
                min_fee.checked_factor(transaction.serialized_size() as u64)
                    .map(|block_fee| transaction.fee >= block_fee)
                    .unwrap_or(true)
            }
        }
    }
}



impl Deserialize for Subscription {
    fn deserialize<R: ReadBytesExt>(reader: &mut R) -> Result<Self, SerializingError> {
        let sub_type: SubscriptionType = Deserialize::deserialize(reader)?;

        match sub_type {
            SubscriptionType::Addresses => {
                // parse number of addresses and cast to usize
                // FIXME We should check for an overflow
                let num_addresses: u16 = Deserialize::deserialize(reader)?;
                let num_addresses = num_addresses as usize;

                // parse addresses and push them into vector
                let mut addresses = HashSet::with_capacity(num_addresses);
                for _ in 0..num_addresses {
                    let address: Address = Deserialize::deserialize(reader)?;
                    addresses.insert(address);
                }

                Ok(Subscription::Addresses(addresses))
            },

            SubscriptionType::MinFee => {
                let min_fee: Coin = Deserialize::deserialize(reader)?;
                Ok(Subscription::MinFee(min_fee))
            },

            SubscriptionType::None => Ok(Subscription::None),
            SubscriptionType::Any => Ok(Subscription::Any)

        }
    }
}



impl Serialize for Subscription {
    fn serialize<W: WriteBytesExt>(&self, writer: &mut W) -> Result<usize, SerializingError> {
        let mut size: usize = 0;

        // Serialize subscription type
        size += Serialize::serialize(&self.subscription_type(), writer)?;

        match self {
            Subscription::Addresses(addresses) => {
                // Serialize number of addresses
                if addresses.len() > 0xFFFF {
                    return Err(SerializingError::Overflow)
                }
                size += Serialize::serialize(&(addresses.len() as u16), writer)?;

                // Serialize addresses
                for address in addresses {
                    size += Serialize::serialize(address, writer)?;
                }
            },

            Subscription::MinFee(min_fee) => {
                // Serialize minFee
                size += Serialize::serialize(min_fee, writer)?;
            }

            _ => {}
        }

        Ok(size)
    }

    fn serialized_size(&self) -> usize {
        1 + (match self {
            // 2 bytes #n addresses, 20 * #n for the addresses
            // XXX This ignores an overflow of number of addresses
            Subscription::Addresses(addresses) => 2 + 20 * addresses.len(),

            // 64 bit minFee value
            Subscription::MinFee(_) => 8,

            _ => 0
        })
    }
}