feat: Add Spark wallet support with Breez Nodeless SDK

[aljazceru]

• Adds SparkWallet backend
• Fixes docker-compose.yaml file to only default to fakewallet if the env variables are not present

[callebtc]

nice one!

[TheRealCheebs]

You have these defaults already defined in settings.py:

    mint_spark_network: str = Field(default="mainnet")
    mint_spark_storage_dir: str = Field(default="data/spark")
    mint_spark_connection_timeout: int = Field(default=30)
    mint_spark_retry_attempts: int = Field(default=3)

We should manage them in one place.

[aljazceru]

ah yeah, good catch, i'll remove the duplicates

[aljazceru]

@TheRealCheebs I've finally looked into this properly, technically its following patterns from other backends that have settings define in settings.py but actually validate the needed credentials in their respective files

nutshell/cashu/lightning/corelightningrest.py

Line 53 in a59f369

macaroon = settings.mint_corelightning_rest_macaroon

nutshell/cashu/lightning/lndrest.py

Line 70 in a59f369

if not endpoint:

[TheRealCheebs]

I think those two are showing the pattern you have for the mint_spark_api_key and mint_spark_mnemonic; raising an exception or asserting when nothing is set. What I am calling out is you set defaults in settings.py for mint_spark_network, mint_spark_storage_dir,... , then you have defaults set again in the third parameter of getattr. The getattr defaults should be dropped as they are duplicates, and defaults should be managed in one place.

[a1denvalu3]

unrelated changes?

[aljazceru]

yeah kinda, it makes the docker file actually work properly (vars taken from .env with sane defaults). otherwise you either need docker-compose.override.yaml or you always have a diff of the file in the repo. so its an improvemen, but it should possibly be in a separate PR :)

[a1denvalu3]

?

[a1denvalu3]

Vulnerability Report: Missing Fee Limit Enforcement in Spark Backend Allows Node Drain

Description

The breez-spark-backend branch introduces the SparkWallet lightning backend (cashu/lightning/spark.py). However, its pay_invoice method completely ignores the fee_limit_msat parameter passed to it by the Mint's ledger.py.

When a user requests a melt quote, the Mint uses get_payment_quote to fetch an estimated routing fee. The user then provides Cashu tokens covering the invoice amount plus this estimated fee_reserve. When the user proceeds to pay the quote, the Mint calls backend.pay_invoice(quote, fee_limit_msat=fee_reserve * 1000).

In the SparkWallet, pay_invoice ignores this limit and recalculates the route from scratch:

    async def pay_invoice(
        self, quote: MeltQuote, fee_limit_msat: int
    ) -> PaymentResponse:
        try:
            sdk = await self._sdk_instance()
            prepare_request = PrepareSendPaymentRequest(
                payment_request=quote.request,
                amount=None,
            )
            # Re-calculates route and fee!
            prepare_response = await sdk.prepare_send_payment(
                request=prepare_request
            )
            
            options = SendPaymentOptions.BOLT11_INVOICE(
                prefer_spark=False, completion_timeout_secs=30
            )
            # Sends the payment with the newly computed fee, without checking fee limit
            request = SendPaymentRequest(
                prepare_response=prepare_response, options=options
            )
            response = await sdk.send_payment(request=request)

Because prepare_response.fees_sats is never compared against fee_limit_msat, the Spark node will blindly pay whatever routing fee the new path requires, even if it vastly exceeds what the user paid to the Mint.

Exploitation (PoC)

An attacker can exploit this to drain the Mint's Spark node balance via exorbitant routing fees:

1. The attacker sets up a Lightning node (Destination) and a routing node (Router). They create a channel from the Mint to Router, and Router to Destination.
2. The attacker generates an invoice on Destination for 100 sats.
3. The attacker configures Router to charge 0 sats fee.
4. The attacker requests a melt quote from the Mint for this invoice. SparkWallet.get_payment_quote calculates a route with a 0 sat fee and returns a quote with the default fallback fee (e.g. 2 sats).
5. The attacker accepts the quote, preparing to pay 102 sats in Cashu tokens.
6. Before executing the melt, the attacker dynamically updates the fee on their Router node to an arbitrarily high amount, e.g., 1,000,000 sats.
7. The attacker executes the melt. SparkWallet.pay_invoice calls prepare_send_payment again. The new route requires a 1,000,000 sat routing fee.
8. SparkWallet sends the payment anyway, paying the 100 sats invoice + 1,000,000 sats routing fee to the attacker.
9. The Mint loses 1,000,000 sats, while the attacker only paid 102 sats worth of Cashu tokens.

Mitigation

In cashu/lightning/spark.py, enforce the fee_limit_msat in pay_invoice by checking the computed fee against the limit before sending the payment:

            prepare_response = await sdk.prepare_send_payment(
                request=prepare_request
            )

            estimated_fee = getattr(prepare_response, "fees_sats", None) or getattr(prepare_response, "fees", 0)
            if int(estimated_fee) * 1000 > fee_limit_msat:
                return PaymentResponse(
                    result=PaymentResult.FAILED,
                    error_message=f"Fee exceeded limit: {estimated_fee} sats > {fee_limit_msat / 1000} sats"
                )