Method validate

plugins/lsps-plugin/src/proto/lsps2.rs:178–238

(
        &self,
        secret: &[u8],
        payment_size_msat: Option<Msat>,
        receivable: Option<Msat>,
    )

impl OpeningFeeParams {
    pub fn validate(
        &self,
        secret: &[u8],
        payment_size_msat: Option<Msat>,
        receivable: Option<Msat>,
    ) -> Result<(), Error> {
        // LSPs MUST check that the opening_fee_params.promise does in fact
        // prove that it previously promised the specified opening_fee_params.
        let mut hmac = HmacEngine::<sha256::Hash>::new(&secret);
        hmac.input(&self.min_fee_msat.msat().to_be_bytes());
        hmac.input(&self.proportional.ppm().to_be_bytes());
        hmac.input(self.valid_until.to_rfc3339().as_bytes());
        hmac.input(&self.min_lifetime.to_be_bytes());
        hmac.input(&self.max_client_to_self_delay.to_be_bytes());
        hmac.input(&self.min_payment_size_msat.msat().to_be_bytes());
        hmac.input(&self.max_payment_size_msat.msat().to_be_bytes());
        let promise: String = Hmac::from_engine(hmac)
            .to_byte_array()
            .iter()
            .map(|b| format!("{:02x}", b))
            .collect();
        if self.promise != Promise(promise) {
            return Err(Error::InvalidOpeningFeeParams);
        }

        // LSPs MUST check that the opening_fee_params.valid_until is not a past
        // datetime.
        let now = Utc::now();
        if now > self.valid_until {
            debug!("Got invalid opening fee params: timeout, {:?}", self);
            return Err(Error::InvalidOpeningFeeParams);
        }

        // If the payment_size_msat is specified in the request, the LSP:
        //  - MUST compute the opening_fee and check that the computation did
        //         not hit an overflow failure.
        //     - MUST check that the resulting opening_fee is strictly less than
        //            the payment_size_msat.
        //  - SHOULD check that it has sufficient incoming liquidity from the
        //           public network to be able to receive at least
        //           payment_size_msat.
        if let Some(payment_size_msat) = payment_size_msat {
            let opening_fee = compute_opening_fee(
                payment_size_msat.msat(),
                self.min_fee_msat.msat(),
                self.proportional.ppm() as u64,
            )
            .ok_or(Error::PaymentSizeTooLarge)?;
            if opening_fee >= payment_size_msat.msat() {
                return Err(Error::PaymentSizeTooSmall);
            }

            if let Some(rec) = receivable {
                if opening_fee >= rec.msat() {
                    return Err(Error::PaymentSizeTooLarge);
                }
            }
        }