> ## Documentation Index
> Fetch the complete documentation index at: https://shinydapps-bd9fa40b.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Providers

> Deux modes — Géré (0,3% fixe, sans nœud) ou Soberano (0%, votre propre nœud Lightning). ManagedProvider, Blink, LNbits, OpenNode, et personnalisé.

## Deux modes

| Mode         | Provider          | Frais        | Testnet / Sandbox                | Configuration                     |
| ------------ | ----------------- | ------------ | -------------------------------- | --------------------------------- |
| **Géré** ⭐   | `ManagedProvider` | 0,3% par sat | ❌ (utiliser mock dans les tests) | Adresse Lightning uniquement      |
| **Soberano** | Blink             | 0%           | ❌ mainnet uniquement             | Compte custodial gratuit          |
| **Soberano** | LNbits            | 0%           | ✅ RegTest / signet               | Auto-hébergé ou instance publique |
| **Soberano** | OpenNode          | 0%           | ✅ `testMode: true`               | Compte sandbox gratuit            |
| **Soberano** | Alby Hub          | 0%           | ✅ via portefeuille testnet Hub   | Nœud cloud auto-custodial         |
| **Soberano** | BTCPay            | 0%           | ✅ Support RegTest                | Nœud auto-hébergé                 |
| **Soberano** | Personnalisé      | 0%           | ✅ selon votre configuration      | N'importe quel backend Lightning  |

**Mode géré** — l402kit.com héberge le nœud Lightning. Vous ajoutez votre adresse Lightning. Nous vous reversons automatiquement 99,7% de chaque sat.

**Mode Soberano** — Vous connectez votre propre portefeuille/nœud Lightning. 0% de frais, garde totale, fonctionne avec n'importe quel provider.

***

## ManagedProvider (Recommandé)

Aucun nœud Lightning requis. Ajoutez votre adresse Lightning et commencez à gagner — l402kit.com gère toute la création de factures et le routage des paiements.

**Frais :** 0,3% par sat reçu. 99,7% arrive directement dans votre portefeuille Lightning. Aucun abonnement mensuel.

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { l402, ManagedProvider } from 'l402-kit';
  import express from 'express';

  const app = express();
  const lightning = ManagedProvider.fromAddress('you@yourdomain.com');

  app.get('/premium', l402({ priceSats: 10, lightning }), (req, res) => {
    res.json({ data: 'Payment confirmed ⚡' });
  });

  app.listen(3000);
  // 0.3% fee · no node setup · works immediately
  ```

  ```python Python theme={null}
  from l402kit import l402_required, ManagedProvider
  from fastapi import FastAPI

  app = FastAPI()
  lightning = ManagedProvider.from_address("you@yourdomain.com")

  @app.get("/premium")
  @l402_required(price_sats=10, lightning=lightning)
  async def premium():
      return {"data": "Payment confirmed ⚡"}
  # 0.3% fee · no Lightning node required
  ```

  ```go Go theme={null}
  import (
      "fmt"
      "net/http"
      l402kit "github.com/shinydapps/l402-kit/go"
  )

  func main() {
      provider := l402kit.NewManagedProvider("you@yourdomain.com")
      http.Handle("/premium", l402kit.Middleware(l402kit.Options{
          PriceSats: 10,
          Lightning: provider,
      }, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
          fmt.Fprintln(w, `{"data":"Payment confirmed ⚡"}`)
      })))
      http.ListenAndServe(":8080", nil)
  }
  ```

  ```rust Rust theme={null}
  use axum::{middleware, routing::get, Router};
  use l402kit::{l402_middleware, Options, ManagedProvider};
  use std::sync::Arc;

  #[tokio::main]
  async fn main() {
      let provider = ManagedProvider::new("you@yourdomain.com".into());
      let opts = Arc::new(Options::new(10, provider));
      let app = Router::new()
          .route("/premium", get(|| async { r#"{"data":"Payment confirmed ⚡"}"# }))
          .route_layer(middleware::from_fn_with_state(opts, l402_middleware));
      let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
      axum::serve(listener, app).await.unwrap();
  }
  ```
</CodeGroup>

**Comment ça fonctionne :**

1. Votre API appelle `ManagedProvider.fromAddress("you@domain.com")`
2. Lorsqu'un appelant atteint votre endpoint, l402kit.com crée une facture Lightning
3. L'appelant paie → Lightning règle → 99,7% transféré instantanément vers votre adresse Lightning
4. Votre API vérifie la preuve cryptographique et renvoie `200 OK`

<Note>
  Les frais de routage de 0,3% constituent le seul coût. Aucun abonnement mensuel. Aucune inscription de compte. Toute adresse Lightning fonctionne (Blink, Phoenix, Alby, Strike, Wallet of Satoshi, etc.).
</Note>

### Confiance & disponibilité

**Qui gère l402kit.com ?** ShinyDapps (open source, MIT). L'infrastructure gérée fonctionne sur Cloudflare Workers — distribuée mondialement, aucun serveur unique susceptible de tomber en panne.

**Disponibilité** : Surveillée 24h/24 et 7j/7 sur [stats.uptimerobot.com/57uOzF17jK](https://stats.uptimerobot.com/57uOzF17jK). Objectif SLA : 99,9%.

**Et si l402kit.com disparaît ?** Votre logique de vérification est locale — `SHA256(preimage) == paymentHash` s'exécute dans votre processus, sans aucun appel réseau. Seule la *création* de factures touche l402kit.com. Si le service géré tombe en panne, basculez vers n'importe quel provider soberano en une seule ligne :

```typescript theme={null}
// Avant (géré)
const lightning = ManagedProvider.fromAddress("you@yourdomain.com");

// Après (soberano — 0% de frais, garde totale)
const lightning = new BlinkProvider(process.env.BLINK_API_KEY!, process.env.BLINK_WALLET_ID!);
```

Aucune autre modification de code. Les tokens déjà payés continuent de fonctionner — la vérification est purement cryptographique.

**Puis-je auto-héberger la couche gérée ?** Oui. Le code source complet est sur [GitHub](https://github.com/ShinyDapps/l402-kit) sous licence MIT. `cloudflare/` contient le worker de l'API gérée — déployez-le sur votre propre compte Cloudflare en 5 minutes.

***

## Blink (Soberano — 0% de frais)

[Blink](https://blink.sv) est un portefeuille Bitcoin Lightning custodial gratuit avec une API GraphQL. Pas de KYC, pas d'abonnement mensuel, configuration instantanée. Utilisez-le pour fonctionner en mode soberano avec 0% de frais.

<Note>
  **Plan de secours :** Blink est un service gratuit — leurs tarifs peuvent changer. Si Blink ajoute des frais ou limite l'API, basculez vers un autre provider soberano en une seule ligne de code (aucune autre modification requise, les tokens déjà payés continuent de fonctionner). Zéro verrouillage. Bonnes alternatives : LNbits (auto-hébergé, 0% à jamais), OpenNode (SLA commercial), Alby Hub (auto-custodial), ou BTCPay (entièrement souverain).
</Note>

**Pour commencer :**

1. Créez un compte sur [dashboard.blink.sv](https://dashboard.blink.sv)
2. Allez dans **API Keys** → créez une nouvelle clé
3. Copiez votre **BTC Wallet ID** depuis la page du portefeuille

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { BlinkProvider } from 'l402-kit';

  const blink = new BlinkProvider(
    process.env.BLINK_API_KEY!,    // blink_xxx...
    process.env.BLINK_WALLET_ID!,  // UUID
  );
  ```

  ```python Python theme={null}
  from l402kit.providers.blink import BlinkProvider

  blink = BlinkProvider(
      api_key=os.environ["BLINK_API_KEY"],
      wallet_id=os.environ["BLINK_WALLET_ID"],
  )
  ```

  ```go Go theme={null}
  import "github.com/shinydapps/l402-kit/go"

  provider := l402kit.NewBlinkProvider(
      os.Getenv("BLINK_API_KEY"),
      os.Getenv("BLINK_WALLET_ID"),
  )
  ```
</CodeGroup>

**Variables d'environnement :**

```bash theme={null}
BLINK_API_KEY=blink_xxxxxxxxxxxxxxxxxxxxxxxx
BLINK_WALLET_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

***

## LNbits (Soberano — 0% de frais)

[LNbits](https://lnbits.com) est un serveur de portefeuille Lightning open source. Hébergez-le vous-même ou utilisez une instance publique.

**Pour commencer :**

1. Installez LNbits (auto-hébergé ou utilisez legend.lnbits.com)
2. Créez un portefeuille → copiez la **clé Invoice/read**

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { LNbitsProvider } from 'l402-kit';

  const lnbits = new LNbitsProvider(
    process.env.LNBITS_KEY!,
    process.env.LNBITS_URL ?? 'https://legend.lnbits.com',
  );
  ```

  ```python Python theme={null}
  from l402kit.providers.lnbits import LNbitsProvider

  lnbits = LNbitsProvider(
      api_key=os.environ["LNBITS_KEY"],
      base_url=os.environ.get("LNBITS_URL", "https://legend.lnbits.com"),
  )
  ```
</CodeGroup>

**Variables d'environnement :**

```bash theme={null}
LNBITS_KEY=your-invoice-read-key
LNBITS_URL=https://your-lnbits-instance.com
```

***

## OpenNode (Soberano — 0% de frais)

[OpenNode](https://opennode.com) est un provider Lightning avec un sandbox gratuit pour les tests.

**Pour commencer :**

1. Créez un compte sur [app.opennode.com](https://app.opennode.com)
2. Allez dans **Integrations** → **API Keys** → créez une clé

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { OpenNodeProvider } from 'l402-kit';

  const opennode = new OpenNodeProvider(
    process.env.OPENNODE_KEY!,
    process.env.NODE_ENV !== 'production', // testMode
  );
  ```

  ```python Python theme={null}
  from l402kit.providers.opennode import OpenNodeProvider

  opennode = OpenNodeProvider(
      api_key=os.environ["OPENNODE_KEY"],
      test_mode=os.environ.get("NODE_ENV") != "production",
  )
  ```
</CodeGroup>

***

## Alby Hub (Soberano — 0% de frais)

[Alby Hub](https://hub.getalby.com) est un nœud Lightning auto-custodial dans le cloud. Vos clés, vos sats — aucun dépositaire.

**Pour commencer :**

1. Créez un Hub sur [hub.getalby.com](https://hub.getalby.com) (ou auto-hébergez)
2. Allez dans **Settings → Access Tokens** → créez un token avec les portées `invoices:create` + `invoices:read`
3. Copiez votre URL Hub et votre token d'accès

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { AlbyProvider } from 'l402-kit';

  const alby = new AlbyProvider(
    process.env.ALBY_ACCESS_TOKEN!,  // Hub → Settings → Access Tokens
    process.env.ALBY_HUB_URL!,       // ex. "https://your-name.getalby.com"
  );
  ```
</CodeGroup>

**Variables d'environnement :**

```bash theme={null}
ALBY_ACCESS_TOKEN=your-alby-access-token
ALBY_HUB_URL=https://your-name.getalby.com
```

***

## BTCPay Server (Soberano — 0% de frais)

[BTCPay Server](https://btcpayserver.org) est entièrement souverain en matière de Bitcoin + Lightning. Votre nœud, vos clés, zéro garde.

**Compatible avec :** auto-hébergé (Umbrel, Start9, VPS) ou géré (Voltage, LunaNode).

**Pour commencer :**

1. Boutique BTCPay → **Lightning → Settings**
2. **Account → API Keys** → générez une clé avec la portée `btcpay.store.cancreatelightninginvoice`
3. Copiez votre Store ID depuis l'URL de la boutique

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { BTCPayProvider } from 'l402-kit';

  const btcpay = new BTCPayProvider(
    process.env.BTCPAY_URL!,       // ex. "https://btcpay.yourdomain.com"
    process.env.BTCPAY_API_KEY!,   // Account → API Keys
    process.env.BTCPAY_STORE_ID!,  // depuis l'URL de la boutique
  );
  ```
</CodeGroup>

**Variables d'environnement :**

```bash theme={null}
BTCPAY_URL=https://btcpay.yourdomain.com
BTCPAY_API_KEY=your-api-key
BTCPAY_STORE_ID=your-store-id
```

***

## Provider personnalisé (Soberano — 0% de frais)

Implémentez l'interface `LightningProvider` pour utiliser n'importe quel backend Lightning :

<CodeGroup>
  ```typescript TypeScript theme={null}
  import type { LightningProvider, Invoice } from 'l402-kit';

  class MyProvider implements LightningProvider {
    async createInvoice(amountSats: number): Promise<Invoice> {
      // Call your Lightning node API
      const result = await myNode.createInvoice(amountSats);
      const macaroon = Buffer.from(
        JSON.stringify({ hash: result.hash, exp: Date.now() + 3_600_000 })
      ).toString('base64');
      return {
        paymentRequest: result.bolt11,
        paymentHash: result.hash,
        macaroon,
        amountSats,
        expiresAt: Date.now() + 3_600_000,
      };
    }

    async checkPayment(paymentHash: string): Promise<boolean> {
      return myNode.isPaid(paymentHash);
    }
  }
  ```

  ```python Python theme={null}
  from l402kit.types import LightningProvider, Invoice
  from datetime import datetime, timedelta
  import base64, json

  class MyProvider(LightningProvider):
      async def create_invoice(self, amount_sats: int) -> Invoice:
          result = await my_node.create_invoice(amount_sats)
          exp = int((datetime.now() + timedelta(hours=1)).timestamp() * 1000)
          macaroon = base64.b64encode(
              json.dumps({"hash": result.hash, "exp": exp}).encode()
          ).decode()
          return Invoice(
              payment_request=result.bolt11,
              payment_hash=result.hash,
              macaroon=macaroon,
              amount_sats=amount_sats,
              expires_at=exp,
          )

      async def check_payment(self, payment_hash: str) -> bool:
          return await my_node.is_paid(payment_hash)
  ```
</CodeGroup>