Cómo Obtener los Signers de una Transacción en Solana Usando Python

En la blockchain de Solana, una transacción está compuesta por múltiples elementos, incluyendo las firmas de los participantes que autorizan y autentican la acción. Identificar los signers (firmantes) de una transacción es esencial para comprender quiénes están involucrados en la ejecución de dicha transacción. Este artículo proporciona una guía detallada sobre cómo obtener los signers de una transacción en Solana utilizando Python, integrando las mejores prácticas y herramientas disponibles.

Requisitos Previos

Antes de profundizar en el código, es importante asegurarse de contar con los siguientes requisitos:

• Python Instalado: Se recomienda utilizar Python versión 3.7 o superior.
• Bibliotecas Necesarias: solana-py y requests para interactuar con la blockchain de Solana.
• Acceso a un Nodo RPC de Solana: Puede ser el endpoint público de Solana o servicios de terceros como QuickNode o Alchemy.

Paso 1: Instalación de Dependencias

Primero, asegúrate de tener instaladas las bibliotecas necesarias. Puedes instalarlas utilizando pip:

pip install solana requests

La biblioteca solana-py facilita la interacción con la blockchain de Solana, mientras que requests es utilizada para realizar solicitudes HTTP, esenciales para comunicarse con los nodos RPC.

Paso 2: Configuración del Cliente RPC de Solana

Para interactuar con la blockchain de Solana, necesitas configurar un cliente RPC. Puedes utilizar el endpoint público de Solana o uno proporcionado por servicios de terceros. A continuación, se muestra cómo configurar el cliente utilizando solana-py:

from solana.rpc.api import Client

# Conectar al nodo RPC de Solana (mainnet-beta)
client = Client("https://api.mainnet-beta.solana.com")

Si prefieres utilizar devnet o testnet, simplemente reemplaza la URL del endpoint:

• Devnet: https://api.devnet.solana.com
• Testnet: https://api.testnet.solana.com

Paso 3: Obtener y Analizar la Transacción

Una vez configurado el cliente RPC, el siguiente paso es obtener los detalles de la transacción utilizando su signature (firma) y extraer los signers. A continuación, se presenta un script completo que realiza esta tarea:

Código Completo en Python

from solana.rpc.api import Client
import sys

def obtener_signers(signature):
# Instanciar el cliente RPC de Solana
client = Client("https://api.mainnet-beta.solana.com")

try:
# Obtener los detalles de la transacción
respuesta = client.get_transaction(signature, encoding="jsonParsed")

if not respuesta["result"]:
print("Transacción no encontrada o aún está confirmando.")
return

# Extraer la información de la transacción
transaccion = respuesta["result"]["transaction"]
mensaje = transaccion["message"]
account_keys = mensaje["accountKeys"]

# Identificar los signers
signers = []
for account in account_keys:
# Dependiendo de la estructura, verificar si es signer
# Si es dict, verificar clave 'signer'
if isinstance(account, dict):
if account.get("signer", False):
signers.append(account["pubkey"])
# Si es lista o tupla, asume que el segundo elemento indica si es signer
elif isinstance(account, (list, tuple)):
if len(account) > 1 and account[1]:
signers.append(account[0])

# Mostrar los signers encontrados
if signers:
print("Signers de la transacción:")
for signer in signers:
print(f"- {signer}")
else:
print("No se encontraron signers en esta transacción.")
except Exception as e:
print(f"Ocurrió un error al obtener la transacción: {e}")

if __name__ == "__main__":
if len(sys.argv) != 2:
print("Uso: python obtener_signers.py ")
sys.exit(1)

tx_signature = sys.argv[1]
obtener_signers(tx_signature)

Explicación del Código

1. Importaciones: Se importan las clases necesarias de solana.rpc.api para interactuar con la API RPC de Solana y la biblioteca sys para manejar argumentos de línea de comandos.
2. Función obtener_signers:
   • Instanciación del Cliente RPC: Se crea un objeto Client que se conecta al endpoint de mainnet-beta de Solana.
   • Obtención de la Transacción: Utiliza el método get_transaction para obtener los detalles de la transacción especificada por su firma, con la codificación jsonParsed para facilitar el análisis.
   • Verificación de la Respuesta: Se comprueba si la transacción fue encontrada y está confirmada.
   • Extracción de accountKeys: Se accede a las claves de cuenta involucradas en la transacción.
   • Identificación de Signers: Itera sobre cada cuenta en accountKeys y verifica si está marcada como signer. Dependiendo de la estructura de los datos (dict o list/tuple), se extrae la clave pública del signer.
   • Salida: Si se encuentran signers, se imprimen sus direcciones públicas. De lo contrario, se indica que no se encontraron signers en la transacción.
3. Bloque __main__: Permite ejecutar el script desde la línea de comandos, aceptando la firma de la transacción como argumento. Si no se proporciona una firma, muestra un mensaje de uso y termina la ejecución.

Paso 4: Ejecución del Script

Para utilizar el script anterior, sigue estos pasos:

1. Guardar el Script: Copia el código proporcionado y guárdalo en un archivo llamado, por ejemplo, obtener_signers.py.
2. Ejecutar el Script: Abre una terminal o línea de comandos y navega hasta el directorio donde guardaste el archivo. Luego, ejecuta el script proporcionando la firma de la transacción que deseas analizar:

python obtener_signers.py 5F4fTyiLF4Awc7iHchEvl2t7FbdYMWHFD1Vd3x4A2XY3yQA8QNMGPMnBZH93GcC75PCbfXVCvY8G5epnCWqkrafo

Ejemplo de Salida:

Signers de la transacción:
- GkL5B1K...
- 3NdZmfZ...

Cada línea representa una dirección pública que firmó la transacción.

Consideraciones Adicionales

1. Transacciones con Múltiples Signers

En casos de transacciones complejas o multi-firma (multisig), puede haber múltiples signers involucrados. Este script está diseñado para identificar todos los signers presentes en una transacción, siempre que estén correctamente etiquetados en los accountKeys.

2. Transacciones en Programas Personalizados

Si estás trabajando con transacciones que interactúan con programas personalizados, como los tokens SPL, la lógica para determinar los signers puede variar. Es posible que necesites analizar instrucciones adicionales o campos específicos según el programa que esté ejecutando la transacción.

3. Manejo de Excepciones

El script incluye un manejo básico de excepciones para capturar errores al obtener la transacción. Para aplicaciones en producción, considera implementar manejos más robustos y detallados, como reintentos en caso de fallos temporales de red o validaciones adicionales de los datos recibidos.

Alternativa: Uso de la Biblioteca Solathon

Además de solana-py, otra opción popular es utilizar la biblioteca solathon. A continuación, se presenta un ejemplo de cómo lograr lo mismo utilizando solathon:

Código con Solathon

from solathon import Client, PublicKey

def obtener_signers_solathon(signature):
client = Client("https://api.mainnet-beta.solana.com")

try:
# Obtener la información de la transacción
transaccion = client.get_transaction(signature)

if not transaccion or 'transaction' not in transaccion:
print("Transacción no encontrada o aún está confirmando.")
return

# Extraer los signers
signers = []
for account in transaccion['transaction']['message']['accountKeys']:
if account.get('signer', False):
signers.append(account['pubkey'])

if signers:
print("Signers de la transacción:")
for signer in signers:
print(f"- {signer}")
else:
print("No se encontraron signers en esta transacción.")
except Exception as e:
print(f"Ocurrió un error al obtener la transacción: {e}")

if __name__ == "__main__":
import sys
if len(sys.argv) != 2:
print("Uso: python obtener_signers_solathon.py ")
sys.exit(1)

tx_signature = sys.argv[1]
obtener_signers_solathon(tx_signature)

Explicación del Código con Solathon

1. Importaciones: Se importan las clases necesarias de solathon.
2. Función obtener_signers_solathon:
   • Instanciación del Cliente RPC: Se crea un objeto Client que se conecta al endpoint de mainnet-beta de Solana.
   • Obtención de la Transacción: Se utiliza el método get_transaction para obtener los detalles de la transacción especificada por su firma.
   • Extracción de Signers: Se iteran las accountKeys y se verifica si cada cuenta está marcada como signer. Si es así, se agrega a la lista de signers.
   • Salida: Se imprimen las direcciones públicas de los signers encontrados.
3. Bloque __main__: Permite ejecutar el script desde la línea de comandos, aceptando la firma de la transacción como argumento.

Validación y Verificación

Después de ejecutar el script, es recomendable verificar los resultados utilizando exploradores de blockchain como Solscan o Solana Explorer. Estos exploradores permiten visualizar detalles de las transacciones, incluyendo los signers, para asegurarse de que el script está funcionando correctamente.

Recursos Adicionales

github.com

Repositorio de solana-py en GitHub

docs.solana.com

API RPC de Solana

solscan.io

Solscan - Explorador de Solana

solanacookbook.com

Solana Cookbook: Transacciones Básicas

Conclusión

Obtener los signers de una transacción en Solana es un proceso esencial para el análisis y la auditoría de actividades en la blockchain. Utilizando Python y bibliotecas como solana-py o solathon, es posible extraer esta información de manera eficiente y precisa. A través de los pasos detallados en este artículo, puedes implementar fácilmente scripts que te permitan identificar y verificar los firmantes de cualquier transacción en Solana, mejorando así la transparencia y el entendimiento de las operaciones dentro de esta poderosa blockchain.