---
# System prepended metadata

title: Python & Polar
tags: [talleres_mln]

---

# Crear invoices desde linea de comando usando Python y Polar
###### tags: `talleres_mln`

Este es un workshop para crear una lightning app para crear bolt11 invoices desde consola usando un nodo LND 

**Tabla de contenido**
[TOC]

## Autor
Twitter para correcciones, comentarios o sugerencias: [@bitao36](https://twitter.com/bitao36)

El presente tutorial fue elaborado para el [Seminario socrático de Mastering Lightning](https://libreriadesatoshi.com/) a través de [@libreriadesatoshi](https://twitter.com/libdesatoshi).

## Requerimientos :information_source: 
:::info
Tener instalado Linux
Tener instalado Polar
Haber creado una red en Polar con dos nodos uno de ellos LND
Tener instalado Python 3.10

:::
## Lightning Polar
Lightning Polar (en adelante Polar) es una aplicación que permite crear rápidamente una red  local de nodos lightning.

[Taller de Polar](/cutFDwM_TNaz-4GcDBXHCA)

## Conexion al nodo LND 

Como se ha visto en clases previas, se puede efectuar conexiones a un nodo LND mediante REST, sin embargo en este caso lo haremos por gRPC que es la forma más usada.

### Que es gGRPC

gRPC (gRPC Remote Procedure Call) es un marco de trabajo de código abierto desarrollado por Google para facilitar la comunicación remota entre servicios distribuidos. Utiliza HTTP/2 para el transporte, Protocol Buffers (protobufs) para la serialización de mensajes y puede operar en muchos lenguajes de programación. Aquí te explico cómo funciona la conexión en el lado del cliente y el lado del servidor:
   #### Stubs y Skeletons
Cliente Stub: En el lado del cliente, gRPC genera stubs a partir de las definiciones de servicios en el archivo .proto. Los stubs permiten que el cliente llame a los métodos del servidor como si fueran métodos locales.
        
Servidor Skeleton: En el lado del servidor, gRPC genera skeletons que deserializan las solicitudes entrantes, llaman a los métodos correspondientes en el servidor y serializan las respuestas de vuelta al cliente.


### Acceso gRPC al nodo LND

Generación de Stubs gRPC

Utiliza el archivo grpc_tools.protoc para generar stubs en tu lenguaje de programación preferido. 

Los archivos proto de LND se pueden encontrar en el repositorio oficial de LND en GitHub.

En el repositorio que usarás más adelante ya están generados los archivos necesarios para generar invoices sin embargo aquí están los comandos para generarlos.

Con los siguientes comandos generaremos  los archivos necesarios para el cliente gRPC en Python que nos ayudará a generar bolt11 invoices.


```
$sudo apt-get install python3-dev
$python3 -m venv lndproto
$source lndproto/bin/activate
$pip3 install grpcio grpcio-tools googleapis-common-protos mypy-protobuf
$git clone https://github.com/googleapis/googleapis.git
$curl -o lightning.proto -s https://raw.githubusercontent.com/lightningnetwork/lnd/master/lnrpc/lightning.proto
python -m grpc_tools.protoc --proto_path=googleapis:. --mypy_out=. --python_out=. --grpc_python_out=. lightning.proto

```

Después de seguir estos pasos estos tres archivos son generados: ```lightning_pb2.py, lightning_pb2_grpc.py and lightning_pb2.pyi ``` 

En caso de requerir otros subsistemas de LND como router o estado de invoices, se usan comandos similares cambiando el nombre de los archivos .proto

Para el subsistema router:

```
curl -o router.proto -s https://raw.githubusercontent.com/lightningnetwork/lnd/master/lnrpc/routerrpc/router.proto
python3 -m grpc_tools.protoc --proto_path=googleapis:. --mypy_out=. --python_out=. --grpc_python_out=. router.proto
```

Después de seguir estos pasos estos tres archivos son generados:

router_pb2.py, router_pb2_grpc.py and router_pb2.pyi

Para el subsistema invoices:
```
curl -o invoices.proto -s https://raw.githubusercontent.com/lightningnetwork/lnd/master/lnrpc/invoicesrpc/invoices.proto
python3 -m grpc_tools.protoc --proto_path=googleapis:. --mypy_out=. --python_out=. --grpc_python_out=. invoices.proto
```

Después de seguir estos pasos estos tres archivos son generados:
``` invoices_pb2_grpc.py, invoices_pb2.py, invoices_pb2.pyi ```


### Autenticación TLS y Macaroons

LND utiliza certificados TLS y macaroons para la autenticación. Necesitarás cargar el certificado TLS y el macaroon adecuado para realizar llamadas autenticadas.

### Pero que es un macaroon?

Los macaroons son tokens portables que se pueden utilizar para controlar el acceso a recursos protegidos. Se diferencian de otros tokens de autenticación en que se pueden restringir con condiciones adicionales llamadas caveats. Estas restricciones permiten una granularidad fina en la autorización, sin necesidad de modificar el servidor.


#### Creación del Macaroon:
Cuando un nodo LND se inicia, genera varios macaroons predefinidos para diferentes propósitos (admin.macaroon, invoice.macaroon, readonly.macaroon).
        Estos macaroons contienen una serie de identificadores y una firma HMAC (Hash-based Message Authentication Code) que garantiza su integridad.

#### Restricciones o Caveats:
Los macaroons pueden ser restringidos con condiciones adicionales, conocidas como caveats. Por ejemplo, un macaroon puede ser limitado para que solo sea válido por un cierto tiempo, o para que solo permita el acceso a ciertos métodos de la API.
Las caveats pueden ser de dos tipos:
* First-party caveats: Restringen el macaroon de manera que el mismo servidor que creó el macaroon puede verificar.
* Third-party caveats: Requieren una autoridad externa para la verificación.

#### Verificación del Macaroon:
Cuando un cliente envía un macaroon con una solicitud a la API de LND, el servidor verifica la firma del macaroon y cualquier caveat presente.
        Si la firma es válida y todas las caveats se cumplen, el servidor permite el acceso a los recursos solicitados.

## Ejecutar proyecto en Python

Usaremos un proyecto que ya tiene configurado un componente básico para crear la conexión con un nodo LND mediante gRPC.

Al ejecutar el proyecto, se pide la cantidad de satoshis con la cual se desea crear el invoice con una descripción opcional.

Si la cantidad es un entero mayor a cero, el bolt11 invoice es creado, en caso contrario se pide de nuevo ingresar la cantidad de satoshis. 


1. Clonar proyecto de github: ``` git clone https://github.com/bitao36/pylapp.git ```
1. Crear entorno virtual: ```$ python3 -m venv venv ```
1. Activar entorno virtual: ```$ source venv/bin/activate ``` 
1. Instalar dependencias: ```$ pip3 install -r requirements.txt```
1. Ejecutar Polar 
1. Crear red con mínimo dos nodos uno de ellos LND
1. Obtener archivo cert y macaroons del nodo LND y copiarlos en la carpeta credentials del proyecto clonado
1. Ejecutar proyecto ```$ python3 app.py```

## Testear proyecto 
Ingresa el monto en sats y una descripción opcional. Si todo ha ido bien se te imprime en consola un invoice bolt11. 
Puedes decodificarlo para  verificar la información con el siguiente programa para decodificar invoices https://lndecode.com/

Ahora puedes ir a Polar y pagar en invoice con un nodo que no sea el que generó el invoice.


 
 


