Lightning Faucet MCP Server

officiel

Offrir aux agents IA un portefeuille Bitcoin avec des paiements via le réseau Lightning

Documentation

Lightning Wallet

Donnez un portefeuille Bitcoin à votre agent IA. Serveur MCP + CLI. Compatible avec Claude Code, OpenClaw, Cursor et tout framework d'agent.

Nouveautés de la v1.4

Outil update_operator / lw set-email - définissez l'email de votre opérateur depuis le client MCP ou la CLI ; un lien de vérification vous est envoyé par email.
Outil claim_promo / lw claim-promo - réclamez la promotion de satoshis gratuits à l'installation directement depuis votre agent. Conditions : email vérifié + compte opérateur créé depuis au moins 3 heures.
get_info fonctionne avant l'inscription - les informations sur le service ne nécessitent plus de clé API.

100 sats gratuits pour les nouveaux opérateurs

lw register --email [email protected] (ou l'outil MCP register_operator avec un email)
Cliquez sur le lien de vérification que nous vous envoyons par email
Une fois que votre compte a 3 heures : lw claim-promo (ou l'outil MCP claim_promo)

Un bonus par opérateur, limité aux 100 premières installations, aucun dépôt requis.

Nouveautés de la v1.3

v1.3.0 - Support du protocole L402 v0 selon la dernière spécification de Lightning Labs.

Protocole L402 v0 - Format d'en-tête mis à jour : version="0", token=, rétrocompatible avec macaroon=
Découverte de points de terminaison - .well-known/l402.json sur lightningfaucet.com et certvera.com
Rétrocompatible - Gère à la fois les anciens et les nouveaux formats d'en-tête L402 de n'importe quel service

Nouveautés de la v1.1

v1.1.0 - Support du protocole X402 (USDC sur Base) comme solution de repli automatique aux côtés de L402 (Lightning).

Support X402 - Paiements automatiques en USDC sur Base lorsque L402 n'est pas disponible
Détection automatique du protocole - pay_l402_api gère de manière transparente à la fois L402 et X402
Webhooks - Notifications en temps réel pour les paiements et les événements
Keysend - Envoyez des paiements sans facture en utilisant les clés publiques de nœud
Décodage de facture - Décodez les factures BOLT11 avant de payer
Analyse d'agent - Suivez les habitudes de dépenses et l'utilisation
Export de transactions - Exportez l'historique au format JSON ou CSV
Gestion de budget - Obtenez un état détaillé du budget et définissez des limites
Cycle de vie de l'agent - Désactivez, réactivez et supprimez des agents
Récupération de compte - Récupérez des comptes et faites tourner les clés API
Transferts d'agent à agent - Déplacez des fonds entre vos agents

Pourquoi Lightning Wallet MCP ?

Paiements instantanés - Les transactions Lightning Network se règlent en millisecondes
Support des protocoles L402 + X402 - Accédez automatiquement à toute API payante (Lightning ou USDC)
Hiérarchie Opérateur/Agent - Gérez plusieurs agents avec des limites de dépenses
Aucun risque de garde - Chaque agent dispose de fonds isolés sous la supervision de l'opérateur
Prêt pour la production - Infrastructure éprouvée alimentant des transactions réelles
Notifications par webhook - Soyez notifié instantanément à l'arrivée des paiements
Observabilité complète - Analyses, exports et suivi détaillé de l'état

Deux façons de l'utiliser

CLI (Tout framework d'agent)

Pour les agents axés CLI (OpenClaw, Pi, KiloCode, ou tout agent avec accès Bash) :

npm install -g lightning-wallet-mcp

Ceci installe la commande lw :

# Register and save your API key
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Bot" | jq -r '.api_key')

# Check balance
lw balance | jq '.balance_sats'

# Pay an L402 API
lw pay-api "https://lightningfaucet.com/api/l402/fortune"

# Create and fund an agent
lw create-agent "Research Bot" --budget 5000
lw fund-agent 1 1000

# Check identity
lw whoami

La sortie est en JSON par défaut (redirigez vers jq). Utilisez --human pour une sortie lisible.

Exécutez lw help pour toutes les commandes.

Serveur MCP (Claude Code, Cursor, Windsurf)

Pour les clients MCP natifs, configurez-le comme un serveur MCP :

Option A : Auto-inscription

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"]
    }
  }
}

Demandez ensuite à Claude : "Enregistre un nouveau compte opérateur Lightning Wallet"

Option B : Clé API préconfigurée

Obtenez une clé API sur lightningfaucet.com/ai-agents
Configurez Claude Code (~/.claude/settings.json) :

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"],
      "env": {
        "LIGHTNING_WALLET_API_KEY": "your-api-key-here"
      }
    }
  }
}

Référence des outils

Informations sur le service

Outil	Description
`get_info`	Obtenir l'état du service, la version et les fonctionnalités supportées
`decode_invoice`	Décoder une facture BOLT11 pour voir le montant, la destination et l'expiration

Contexte et identité

Outil	Description
`whoami`	Obtenir le contexte actuel - indique si l'on opère en tant qu'opérateur ou agent
`check_balance`	Vérifier le solde Lightning actuel en satoshis
`get_rate_limits`	Vérifier l'état actuel de la limite de débit et les requêtes restantes

Paiements (Clé d'agent requise)

Outil	Description
`pay_l402_api`	Accéder aux API payantes (L402/X402) - détecte automatiquement le protocole et paie
`pay_invoice`	Payer toute facture Lightning BOLT11
`keysend`	Envoyer un paiement directement à une clé publique de nœud (sans facture)
`pay_lightning_address`	Payer vers une adresse Lightning (format [email protected])
`create_invoice`	Générer une facture pour recevoir des paiements
`get_invoice_status`	Vérifier si une facture a été payée
`get_transactions`	Voir l'historique des transactions

LNURL (Clé d'agent requise)

Outil	Description
`lnurl_auth`	S'authentifier auprès d'un service en utilisant le protocole LNURL-auth
`claim_lnurl_withdraw`	Réclamer des fonds à partir d'un lien LNURL-withdraw

Gestion de l'opérateur

Outil	Description
`register_operator`	Créer un nouveau compte opérateur
`recover_account`	Récupérer un compte en utilisant le code de récupération
`rotate_api_key`	Générer une nouvelle clé API (délai de 60 minutes sur les retraits)
`get_deposit_invoice`	Créer une facture pour approvisionner le compte opérateur
`withdraw`	Retirer des fonds vers une destination Lightning externe
`set_operator_key`	Passer aux identifiants de l'opérateur

update_operator - définir l'email de l'opérateur (envoie un lien de vérification) et/ou le nom
claim_promo - réclamer la promotion de sats gratuits à l'installation (email vérifié + compte de 3h)

Gestion des agents

Outil	Description
`create_agent`	Créer un agent sous l'opérateur
`list_agents`	Lister tous les agents sous l'opérateur
`fund_agent`	Transférer des sats de l'opérateur vers l'agent
`transfer_to_agent`	Transférer des sats entre agents ou de l'opérateur vers l'agent
`sweep_agent`	Rapatrier les fonds de l'agent vers l'opérateur
`deactivate_agent`	Désactiver temporairement un agent
`reactivate_agent`	Réactiver un agent désactivé
`delete_agent`	Supprimer définitivement un agent (retourne le solde à l'opérateur)
`get_budget_status`	Obtenir la limite de budget et les dépenses de l'agent
`set_budget`	Définir ou mettre à jour la limite de dépenses de l'agent
`set_agent_credentials`	Passer aux identifiants de l'agent

Webhooks

Outil	Description
`register_webhook`	Enregistrer une URL pour recevoir des notifications d'événements
`list_webhooks`	Lister tous les webhooks enregistrés
`delete_webhook`	Supprimer un webhook
`test_webhook`	Envoyer un événement de test pour vérifier la connectivité du webhook

Événements de webhook :

invoice_paid - Paiement reçu sur une facture
payment_completed - Paiement sortant réussi
payment_failed - Paiement sortant échoué
balance_low - Le solde est passé sous le seuil
budget_warning - 80% du budget consommé
test - Événement de test manuel

Référence CLI

Toutes les commandes produisent une sortie JSON sur stdout. Les erreurs vont sur stderr avec le code de sortie 1.

Commande	Description
`lw register [--name "name"]`	Créer un compte opérateur, affiche la clé API
`lw whoami`	Identité actuelle (opérateur ou agent)
`lw balance`	Solde en satoshis
`lw info`	État et capacités du service
`lw deposit <amount>`	Générer une facture de dépôt
`lw withdraw <invoice>`	Retirer vers un portefeuille externe
`lw pay <invoice>`	Payer une facture BOLT11 `[--max-fee <sats>]`
`lw pay-api <url>`	Payer une API L402/X402 `[--method GET] [--body "{}"] [--max-sats 1000]`
`lw decode <invoice>`	Décoder une facture BOLT11
`lw create-agent <name>`	Créer un agent `[--budget <sats>]`
`lw fund-agent <id> <amount>`	Transférer des sats à l'agent
`lw list-agents`	Lister tous les agents
`lw transactions`	Transactions récentes `[--limit 10] [--offset 0]`
`lw help`	Afficher toutes les commandes

Exemple de flux de travail d'agent (Bash)

# 1. Register (one-time)
export LIGHTNING_WALLET_API_KEY=$(lw register --name "My Agent" | jq -r '.api_key')

# 2. Fund the account (pay the invoice with any Lightning wallet)
lw deposit 10000 | jq -r '.bolt11'

# 3. Create an agent with a budget
AGENT=$(lw create-agent "Worker" --budget 5000)
AGENT_ID=$(echo $AGENT | jq -r '.agent_id')
AGENT_KEY=$(echo $AGENT | jq -r '.agent_api_key')

# 4. Fund the agent
lw fund-agent $AGENT_ID 2000

# 5. Switch to agent context and make payments
export LIGHTNING_WALLET_API_KEY=$AGENT_KEY
lw pay-api "https://api.example.com/data" --max-sats 100

# 6. Check what happened
lw transactions --limit 5

Protocoles d'API payantes : L402 + X402

Lightning Wallet MCP prend en charge deux protocoles de paiement HTTP 402 :

L402 (principal) - Paiements Lightning Network. Le protocole original de paiement à la requête.
X402 (repli) - USDC sur Base (protocole de Coinbase). Détecté automatiquement lorsque L402 n'est pas disponible.

Lorsque vous appelez pay_l402_api, le serveur détecte automatiquement le protocole utilisé par l'API. L402 est toujours prioritaire si les deux en-têtes sont présents. Les agents paient toujours en sats, quel que soit le protocole — les montants X402 sont convertis au taux du marché.

Protocole L402

Le protocole L402 (anciennement LSAT) permet aux API de facturer à la requête en utilisant Lightning. Lorsque vous appelez un point de terminaison protégé par L402 :

Le serveur renvoie HTTP 402 avec une facture Lightning
Lightning Faucet paie la facture automatiquement
La requête se termine avec le contenu payé

Protocole X402 (Coinbase)

X402 utilise l'USDC sur Base pour les paiements d'API. Le flux est transparent pour les agents :

Le serveur renvoie HTTP 402 avec l'en-tête PAYMENT-REQUIRED
Lightning Faucet convertit le montant en USDC en sats, débite le solde de l'agent
Signe une autorisation EIP-712 et réessaie avec l'en-tête PAYMENT-SIGNATURE
La requête se termine — l'agent voit le même format de réponse qu'avec L402

La réponse inclut payment_protocol: "x402" et usdc_amount pour que les agents sachent quel protocole a été utilisé.

Registre d'API L402

Nous maintenons un répertoire d'API compatibles L402 sur lightningfaucet.com/l402-registry - parfait pour tester vos agents.

API L402 de démonstration

Essayez ces points de terminaison pour tester les paiements L402 :

# Get a fortune (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/fortune" })

# Get a joke (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/joke" })

# Get an inspirational quote (costs ~10-50 sats)
pay_l402_api({ url: "https://lightningfaucet.com/api/l402/quote" })

Consultez le Registre d'API L402 pour plus de points de terminaison et de ressources.

Exemple de flux de travail complet

// 1. Register as operator (if no API key configured)
register_operator({ name: "My AI Company" })
// Returns: { api_key: "lf_abc...", recovery_code: "xyz...", operator_id: 123 }

// 2. Activate the operator key
set_operator_key({ api_key: "lf_abc..." })

// 3. Check who you are
whoami()
// Returns: { type: "operator", id: 123, name: "My AI Company", balance_sats: 0 }

// 4. Fund your operator account
get_deposit_invoice({ amount_sats: 10000 })
// Pay this invoice with any Lightning wallet

// 5. Create an agent with budget limit
create_agent({ name: "Research Assistant", budget_limit_sats: 5000 })
// Returns: { agent_id: 456, agent_api_key: "agent_def..." }

// 6. Fund the agent
fund_agent({ agent_id: 456, amount_sats: 1000 })

// 7. Set up a webhook for payment notifications
register_webhook({
  url: "https://your-server.com/webhooks/lightning",
  events: ["invoice_paid", "payment_completed"]
})
// Returns: { webhook_id: 1, secret: "..." }  <- Save this secret!

// 8. Switch to agent mode for payments
set_agent_credentials({ api_key: "agent_def..." })

// 9. Check budget status
get_budget_status()
// Returns: { budget_limit_sats: 5000, total_spent_sats: 0, remaining_sats: 5000 }

// 10. Make payments!
pay_l402_api({ url: "https://api.example.com/premium-data" })

Paiements Keysend

Envoyez des paiements directement à un nœud Lightning sans avoir besoin d'une facture :

// Send 100 sats to a node with an optional message
keysend({
  destination: "03864ef025fde8fb587d989186ce6a4a186895ee44a926bfc370e2c366597a3f8f",
  amount_sats: 100,
  message: "Hello from my AI agent!"
})

Décodage de facture

Vérifiez les détails de la facture avant de payer :

decode_invoice({ invoice: "lnbc1000n1..." })
// Returns: {
//   amount_sats: 1000,
//   description: "Test payment",
//   destination: "03abc...",
//   expires_at: "2026-01-16T12:00:00Z",
//   is_expired: false
// }

Détails des outils

get_info

Obtenir l'état et les capacités du service.

{
  "success": true,
  "version": "1.0.1",
  "api_version": "1.0",
  "status": "operational",
  "max_payment_sats": 1000000,
  "min_payment_sats": 1,
  "supported_features": ["l402", "x402", "webhooks", "lightning_address", "keysend"]
}

whoami

Obtenir le contexte d'exploitation actuel.

Renvoie pour l'opérateur :

{
  "type": "operator",
  "id": 123,
  "name": "My Company",
  "balance_sats": 50000,
  "agent_count": 3
}

Renvoie pour l'agent :

{
  "type": "agent",
  "id": 456,
  "name": "Research Bot",
  "balance_sats": 1000,
  "budget_limit_sats": 5000,
  "operator_id": 123
}

pay_l402_api

Accéder aux API payantes avec paiement automatique. Prend en charge les protocoles L402 (Lightning) et X402 (USDC sur Base). Le protocole est détecté automatiquement à partir des en-têtes de réponse 402.

Paramètre	Type	Requis	Description
url	string	Oui	L'URL à requêter
method	string	Non	Méthode HTTP (GET, POST, PUT, DELETE). Défaut : GET
body	string	Non	Corps de la requête pour POST/PUT
max_payment_sats	number	Non	Montant maximum du paiement. Défaut : 1000

keysend

Envoyer un paiement à un nœud sans facture.

Paramètre	Type	Requis	Description
destination	string	Oui	Clé publique du nœud cible (66 caractères hex)
amount_sats	number	Oui	Montant en satoshis
message	string	Non	Message optionnel (max 1000 caractères)

register_webhook

Enregistrer une URL pour recevoir des notifications de paiement.

Paramètre	Type	Requis	Description
url	string	Oui	URL HTTPS pour recevoir les webhooks
events	array	Non	Types d'événements auxquels s'abonner. Défaut : ["invoice_paid"]

Renvoie : ID du webhook et secret HMAC pour la vérification de la signature.

Architecture

┌─────────────────────────────────────────────────────────┐
│                    OPERATOR                              │
│  • Holds main funds                                      │
│  • Creates and manages agents                            │
│  • Sets spending limits                                  │
│  • Receives webhook notifications                        │
│  • Can recover account with recovery code                │
├─────────────────────────────────────────────────────────┤
│     AGENT 1          AGENT 2          AGENT 3           │
│   ┌─────────┐      ┌─────────┐      ┌─────────┐        │
│   │ 1000 sat│      │ 5000 sat│      │ 2500 sat│        │
│   │ Budget: │      │ Budget: │      │ Budget: │        │
│   │ 5000    │      │ 10000   │      │ Unlimited│        │
│   └─────────┘      └─────────┘      └─────────┘        │
│       │                │                │               │
│   L402 APIs        Keysend          Receive             │
│   Pay Invoice      Payments         Payments            │
└─────────────────────────────────────────────────────────┘

Meilleures pratiques de sécurité

Ne jamais commit les clés API - Utilisez les variables d'environnement
Définir des limites de budget - Protégez-vous contre les dépenses incontrôlées
Utiliser les clés d'agent pour les paiements - Gardez la clé opérateur en sécurité
Vérifier les signatures de webhook - Utilisez le secret renvoyé lors de l'enregistrement
Surveiller les transactions - Utilisez get_transactions pour examiner l'activité
Codes de récupération - Stockez-les en lieu sûr, nécessaires en cas de perte de la clé API
Rotation des clés - Faites tourner les clés périodiquement en utilisant rotate_api_key

Sécurité des webhooks

Les webhooks incluent des signatures HMAC-SHA256 pour la vérification :

import hmac
import hashlib

def verify_webhook(payload, signature, secret):
    expected = hmac.new(
        secret.encode(),
        payload.encode(),
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(signature, expected)

Vérifiez l'en-tête X-Webhook-Signature par rapport à la charge utile.

Hook de politique de pré-paiement

Un hook facultatif et neutre vis-à-vis du fournisseur permet à un point de terminaison de politique externe d’autoriser ou de refuser un paiement avant son exécution. Il est désactivé par défaut — lorsque PRE_PAYMENT_HOOK_URL n’est pas défini, le comportement est exactement le même qu’auparavant. Lorsqu’il est défini, chaque paiement sortant (pay_l402_api, pay_invoice, keysend, pay_lightning_address) est d’abord vérifié auprès de votre point de terminaison ; un refus interrompt le paiement avant tout mouvement de fonds.

Cela est utile pour les politiques de dépenses, les workflows d’approbation, les contrôles de conformité ou toute couche d’autorisation externe. Le protocole du hook est générique, de sorte que tout service implémentant le contrat requête/réponse ci-dessous peut être connecté par simple configuration.

Configuration

Variable d’env	Défaut	Description
`PRE_PAYMENT_HOOK_URL`	(non défini)	Point de terminaison de politique auquel envoyer chaque proposition de paiement par POST. Non défini désactive entièrement le hook.
`PRE_PAYMENT_HOOK_TIMEOUT_MS`	`3000`	Délai d’expiration par requête en millisecondes.
`PRE_PAYMENT_HOOK_FAIL_MODE`	`closed`	`closed` refuse un paiement si le hook rencontre une erreur ou expire ; `open` le laisse continuer. La valeur par défaut est fail-closed.

{
  "mcpServers": {
    "lightning-wallet": {
      "command": "npx",
      "args": ["lightning-wallet-mcp"],
      "env": {
        "LIGHTNING_WALLET_API_KEY": "your-api-key",
        "PRE_PAYMENT_HOOK_URL": "https://your-policy-endpoint.example/hook"
      }
    }
  }
}

Requête du hook (POST depuis le client)

La proposition décrit uniquement le paiement proposé — elle n’inclut jamais votre clé d’API de portefeuille.

{
  "proposal_id": "f7e1…",
  "agent_id": 42,
  "protocol": "l402",
  "destination_or_url": "https://api.example/paid-endpoint",
  "amount_sats": null,
  "max_payment_sats": 1000,
  "method": "GET",
  "ts": "2026-06-06T18:00:00.000Z"
}

protocol est l’un de l402, x402, bolt11, keysend, lnaddress. amount_sats est le montant exact lorsqu’il est connu au moment du hook : pour keysend et lnaddress c’est le montant demandé, et pour bolt11 il est décodé localement depuis la facture (pas d’appel API supplémentaire). Pour l402/x402 il est null car le montant est fixé par le défi de paiement au moment de l’exécution — le hook applique alors max_payment_sats (le plafond autorisé par l’agent) en amont, et le montant exact réglé est disponible ultérieurement via les webhooks. max_payment_sats est le plafond autorisé par l’agent le cas échéant.

Exactement ce qui quitte le portefeuille. Seuls les huit champs ci-dessus sont envoyés à votre point de terminaison de hook : proposal_id, agent_id, protocol, destination_or_url, amount_sats, max_payment_sats, method, ts. La clé d’API du portefeuille et toute autre information d’identification ne sont jamais incluses.

Couverture. Le hook contrôle chaque dépense initiée par un agent : pay_l402_api, pay_invoice, keysend, pay_lightning_address et les Nostr zaps. La gestion des fonds à portée opérateur (retraits, financement d’agents, transferts entre agents) n’est intentionnellement pas contrôlée — il s’agit d’actions opérateur, pas de dépenses d’agent.

Réponse du hook (votre point de terminaison renvoie)

{ "decision": "allow" }

{ "decision": "deny", "reason": { "code": "over_limit", "message": "Exceeds per-transaction limit" } }

allow → le paiement est exécuté.
deny → le paiement est interrompu et l’outil renvoie une erreur PolicyDenied contenant reason.message.
Un champ optionnel attestation (JSON quelconque) est traité comme opaque par le client — il est journalisé sur stderr et ignoré autrement, afin qu’un service de politique puisse renvoyer une décision signée pour un audit ultérieur.

En cas d’erreur du hook, de délai d’expiration ou de réponse non reconnue, la règle PRE_PAYMENT_HOOK_FAIL_MODE s’applique (refus par défaut).

Tarification

Lightning Faucet facture des frais de plateforme de 2 % (min 1 sat) sur les paiements sortants :

Paiements L402 : 2 % de frais de plateforme + frais de routage Lightning
Paiements X402 : 2 % de frais de plateforme + 1 % de spread de taux de change (conversion USDC en sats)
Paiements de facture : 2 % de frais de plateforme + frais de routage Lightning
Paiements Keysend : 2 % de frais de plateforme + frais de routage Lightning
Retraits opérateur : 2 % de frais de plateforme + frais de routage Lightning
Transferts internes inter-opérateurs : 2 % de frais de plateforme (pas de frais de routage)
Transferts d’agent même opérateur : Gratuit
Dépôts : Gratuit
Réception de paiements : Gratuit
Webhooks : Gratuit

Toutes les réponses de paiement incluent platform_fee_sats, routing_fee_sats et total_cost pour une transparence totale.

Journal des modifications

v1.1.0 (2026-02-16)

Interface CLI : Nouvelle commande lw pour les agents orientés CLI (OpenClaw, Pi, KiloCode, tout agent Bash)
Même paquet, deux interfaces : npm install -g lightning-wallet-mcp vous offre à la fois le serveur MCP et la CLI
Sortie JSON-first : Toutes les commandes CLI produisent du JSON sur stdout, les erreurs sur stderr
Support X402 : Repli automatique vers X402 (USDC sur Base) lorsque L402 n’est pas disponible
Détection automatique du protocole : pay_l402_api détecte L402 ou X402 à partir des en-têtes de réponse 402
Champs de réponse : payment_protocol et usdc_amount inclus lorsque X402 est utilisé
Taux de change : Conversion BTC/USD en temps réel via CoinGecko avec cache de 5 min

v1.0.3 (2026-02-05)

Frais de plateforme : 2 % de frais (min 1 sat) sur tous les paiements sortants et transferts inter-opérateurs
Transparence des frais : Toutes les réponses de paiement incluent désormais platform_fee_sats, routing_fee_sats et total_cost
Les transferts d’agent même opérateur restent gratuits

v1.0.0 (2026-02-04)

Renommé de lightning-faucet-mcp en lightning-wallet-mcp
Variable d’environnement renommée : LIGHTNING_FAUCET_API_KEY → LIGHTNING_WALLET_API_KEY
Les 37 outils entièrement testés et prêts pour la production
Aucun changement d’API cassant - juste le nom du paquet

Versions précédentes (en tant que lightning-faucet-mcp)

Consultez le journal des modifications de lightning-faucet-mcp pour l’historique de la v1.6.0 à la v2.0.7.

Paiements de base et factures

Vitrine : Expérience de théorie des jeux avec agents IA

Nous avons mené une expérience économique de 100 tours avec 16 agents IA (8 Claude, 8 GPT-4o) utilisant du vrai Bitcoin sur Lightning. Les agents pouvaient échanger, former des alliances, investir et rivaliser — le tout propulsé par ce serveur MCP.

Résultats : Les agents ont réalisé 2 839 transactions Lightning réelles. Les agents Claude ont dominé grâce à un trading agressif précoce tandis que les agents GPT-4o ont adopté des stratégies conservatrices.

Dépôt de l’expérience : github.com/pfergi42/lf-game-theory
Article de blog : lightningfaucet.com/blog/ai-game-theory

Support

Documentation : lightningfaucet.com/ai-agents/docs
Démo : lightningfaucet.com/ai-agents/demo
Problèmes : github.com/lightningfaucet/lightning-wallet-mcp/issues
Email : [email protected]

Licence

Licence MIT - voir LICENSE pour plus de détails.

Construit avec Bitcoin | Lightning Faucet