Configure su propia red Ethereum de prueba de autoridad privada con Geth

febrero de 2018.

actualizaciones :

1. geth 1.8 se lanzó unos días después de la publicación de esta guía y, afortunadamente, no rompe nada. Esta publicación es válida y se probó tanto para geth 1.7.3 como para geth 1.8. Impresionante :)
2. He aprendido a posteriori que el límite de gas por bloque es dinámico . Por lo tanto, actualicé la sección 2.3 para brindar más información sobre este caso en particular. En mi red privada donde los bloques están vacíos la mayor parte del tiempo, ¡no sé cuál es el límite de gas para disminuir en absoluto!
3. Clique requiere que los selladores int(N/2+1) (donde N es el número de selladores definidos en el archivo de génesis, en el campo extraData ) estén en línea para poder ejecutarse.
4. Gracias a Ivica Aracic por señalar que clique PoA SÍ FUNCIONA con un solo nodo . Por alguna razón me lo perdí y me disculpo por la confusión. Con un solo nodo, solo necesitamos (A) crear un archivo de génesis con un solo sellador (solo 1 dirección en extraData ) (B) crear una cuenta (C) init geth (D) ejecutar geth, desbloquear la cuenta y la mía. No se requiere bootnode entonces.
5. con geth 1.8 si obtiene el error "host especificado no válido", intente agregar la opción --rpcvhosts value al comando geth. Ver geth --help

Objetivo : guía paso a paso para ayudarlo a configurar una red ethereum privada local utilizando el motor de consenso de prueba de autoridad (también llamado clique ).

En pocas palabras : configuraremos dos nodos en la misma máquina, creando una red peer-to-peer en nuestro localhost. Además de los dos nodos, también se configurará un bootnode (servicio de descubrimiento).

Me tomó bastante tiempo y una investigación exhaustiva y buscar en Google para finalmente tener un entorno de desarrollo de ethereum sólido para probar mis contratos inteligentes y mis DApps.

En esta publicación, he decidido compartir cómo estoy configurando una red de prueba de autoridad usando el motor de consenso de camarilla de Geth. Es mi manera de agradecer a la comunidad retribuyendo y, con suerte, haciendo la vida más fácil para cualquiera que esté dispuesto a explorar el universo Ethereum.

Sistema operativo y software

Mi sistema operativo es Ubuntu 16.04 LTS (este tutorial se realizó en una máquina virtual nueva).

Para el cliente Ethereum, estoy usando Geth (la implementación Go del protocolo Ethereum). Creo que Geth es fácil de instalar con muchos tutoriales geniales, así que no voy a cubrir ninguna instalación aquí. Actualmente estoy ejecutando Geth 1.7.3-estable:

$ geth versionGethVersion: 1.7.3-stableGit Commit: 4bb3c89d44e372e6a9ab85a8be0c9345265c763aArchitecture: amd64Protocol Versiones: [63 62]

y Geth 1.8.1-estable

$ geth versionGethVersion: 1.8.1-stableGit Commit: 1e67410e88d2685bc54611a7c9f75c327b553cccArchitecture: amd64Protocol Versiones: [63 62]

Recomiendo encarecidamente consultar la documentación de la interfaz de línea de comandos de Geth. Lo vas a necesitar. Mucho.

1. Comencemos

1.0 descripción general

Empecemos por el final... Para mayor claridad, esto es lo que se supone que debes obtener cuando hayas completado el Capítulo 1.

devnet$ árbol -L 2.├── cuentas.txt├── boot.key├── genesis.json├── nodo1│ ├── geth│ ├── almacén de claves│ └── contraseña.txt└── nodo2 ├── geth├── almacén de claves└── contraseña.txt

1.1 crear un espacio de trabajo

$ mkdir devnet$ cd devnetdevnet$ mkdir nodo1 nodo2

1.2 crea tus cuentas

Las cuentas (también llamadas monedero) contienen un par de claves públicas y privadas que se requieren para interactuar con cualquier cadena de bloques . Cualquier nodo de minería (estrictamente hablando, nuestros nodos no estarán minando sino votando) debe poder firmar transacciones (usando su clave privada) e identificarse en la red (la dirección se deriva de la clave pública). Por lo tanto, necesitamos al menos dos cuentas, una por nodo.

En la jerga geth, un nodo de votación se llama Sellador.

para el nodo 1:

devnet$ geth --datadir node1/ account newSu nueva cuenta está bloqueada con una contraseña. Por favor, proporcione una contraseña. No olvide esta contraseña. Frase de contraseña: pwdnode1 (por ejemplo) Repita la frase de contraseña: pwdnode1 Dirección: {87366ef81db496edd0ea2055ca605e8686eec1e6}

para el nodo 2:

devnet$ geth --datadir node2/ account newSu nueva cuenta está bloqueada con una contraseña. Por favor, proporcione una contraseña. No olvide esta contraseña. Frase de contraseña: pwdnode2 (por ejemplo) Repita la frase de contraseña: pwdnode2 Dirección: {08a58f09194e403d02a1928a7bf78646cfc260b0}

Esto crea el almacén de keystore/ carpeta que contiene el archivo de su cuenta. Tenga en cuenta que la última parte del nombre del archivo en keystore/ es la dirección de su cuenta (también impresa en el terminal justo arriba).

Sugiero copiar estas dos direcciones desde la pantalla del terminal y guardarlas en un archivo de texto. Eso facilitará un poco el trabajo de copiar y pegar más adelante. Sin embargo, recuerde que puede leer esas direcciones desde el archivo UTC-datetime-address en keystore/ .

devnet$ echo '87366ef81db496edd0ea2055ca605e8686eec1e6' >> cuentas.txtdevnet$ echo '08a58f09194e403d02a1928a7bf78646cfc260b0' >> cuentas.txt

Para cada nodo, propongo guardar su contraseña en un archivo. Eso facilitará algunos procesos para más adelante (como desbloquear su cuenta)

devnet$ echo 'pwdnode1' > nodo1/contraseña.txtdevnet$ echo 'pwdnode2' > nodo2/contraseña.txt

1.3 crea tu archivo Génesis

Un archivo de génesis es el archivo utilizado para inicializar la cadena de bloques. El primer bloque, llamado bloque génesis, está diseñado en función de los parámetros del archivo genesis.json .

Geth viene con un montón de ejecutables como puppeth o bootnode . Puede encontrar la lista completa en Geth github . Puppeth elimina el dolor de crear un archivo de génesis desde cero (y hace mucho más). Iniciar marioneta:

devnet$ marioneta

y felizmente responda las preguntas (cada valor se puede actualizar a mano más adelante, así que no dedique demasiado tiempo a diseñarlo para sus primeras pruebas).

Especifique un nombre de red para administrar (sin espacios, por favor)> devnet¿Qué le gustaría hacer? (predeterminado = estadísticas)

1. Mostrar estadísticas de red
2. Configurar nueva génesis
3. Rastrear nuevo servidor remoto

4. 
   

   Implementar componentes de red> 2

¿Qué motor de consenso utilizar? (predeterminado = camarilla)

1. Ethash - prueba de trabajo

2. 
   

   Clique - prueba de autoridad> 2

¿Cuántos segundos deben tomar los bloques? (predeterminado = 15)> 5 // por ejemplo

¿Qué cuentas se pueden sellar? (obligatorio al menos uno)> 0x87366ef81db496edd0ea2055ca605e8686eec1e6 //copiar y pegar de cuenta.txt :)> 0x08a58f09194e403d02a1928a7bf78646cfc260b0

¿Qué cuentas deben prefinanciarse? (recomendable al menos uno) > 0x87366ef81db496edd0ea2055ca605e8686eec1e6 // ethers gratis ! > 0x08a58f09194e403d02a1928a7bf78646cfc260b0

Especifique su ID de cadena/red si desea uno explícito (predeterminado = aleatorio)> 1515 // por ejemplo. No uses nada del 1 al 10

¿Algo divertido para incrustar en el bloque de génesis? (máximo 32 bytes)>

Que te gustaría hacer? (predeterminado = estadísticas)

1. Mostrar estadísticas de red
2. Administrar la génesis existente
3. Rastrear nuevo servidor remoto

4. 
   

   Implementar componentes de red> 2

1. Modificar las reglas de bifurcación existentes2. Exportar configuración de génesis> 2

¿En qué archivo guardar el génesis? (predeterminado = devnet.json)> genesis.jsonINFO [01-23|15:16:17] Bloque de génesis existente exportado

Que te gustaría hacer? (predeterminado = estadísticas)

1. Mostrar estadísticas de red
2. Administrar la génesis existente
3. Rastrear nuevo servidor remoto

4. 
   

   Implementar componentes de red> ^C // ctrl+C para salir de puppeth

Nota al margen: de Clique PoA EIP#225

PoA no tiene recompensas mineras

Por lo tanto, le sugiero encarecidamente que asigne algunos éteres (definidos en la unidad de wei) a un montón de direcciones en el archivo de génesis; de lo contrario, se quedará sin ningún éter y, por lo tanto, no podrá pagar sus transacciones. Podría tener un precio de gasPrice de cero, pero eso a veces conduce a un comportamiento no deseado de los nodos que podría pasar desapercibido (como no transmitir transacciones pendientes dependiendo de la configuración de los otros nodos en la red). Sin embargo, te animo a jugar con todos los parámetros :)

1.4 Inicializa tus nodos

Ahora que tenemos el archivo genesis.json , ¡forjemos el bloque génesis! Cada nodo DEBE inicializarse con el MISMO archivo de génesis.

devnet$ geth --datadir nodo1/ init genesis.jsondevnet$ geth --datadir nodo2/ init genesis.json

tada! hecho.

Nota al margen: ¿cómo sabe su nodo acerca de los parámetros de génesis cuando se une a Ethereum Mainnet o Ropsten testnet o Rinkeby testnet? Ya están definidos en el código fuente en params/config.go .

1.5 Crear un nodo de arranque

El único propósito de un nodo de arranque es ayudar a los nodos a descubrirse entre sí (recuerde, la cadena de bloques de Ethereum es una red de igual a igual). Los nodos podrían tener IP dinámica, ser apagados y encendidos nuevamente. El bootnode generalmente se ejecuta en una IP estática y, por lo tanto, actúa como un pub donde los nodos saben que encontrarán a sus compañeros.

Inicialice el nodo de arranque:

devnet$ bootnode -genkey boot.key

Esto crea un valor llamado enode que identifica de manera única su bootnode (más sobre esto pronto) y almacenamos este enodo en el archivo boot.key .

1.6 Celebración a mitad de camino

Felicitaciones ! El capítulo 1 está hecho :) inténtalo

devnet$ árbol -L 2

y compare la salida con la sección 1.0. Esperemos que usted debe obtener el mismo árbol.

En este punto, la configuración está lista y estamos listos para poner en marcha esta cadena de bloques.

2. Hazlo en vivo

2.1 Inicie el servicio de nodo de arranque

devnet$ bootnode -nodekey boot.key -verbosity 9 -addr :30310INFO [02-07|22:44:09] UDP listener up self=enode://3ec4fef2d726c2c01f16f0a0030f15dd5a81e274067af2b2157cafbf76aa79fa9c0be52c6664e80cc5b08162ede53279bd70ee10d024fe86613b0b09e1106c40@[::]:30310

Me gusta tener algo de verbosidad para mi bootnode, ya que es bueno ver cuando los nodos están jugando ping-pong en la red (¡lo que significa que está funcionando!).

Siéntase libre de usar cualquier puerto que desee, pero evite los principales (como 80 para HTTP). 30303 se utiliza para las redes públicas de ethereum.

2.2 Iniciando sus nodos

¡Gran momento! Finalmente (pero por lo general aquí también llegan los problemas).

¡Todo en un gran comando! Voy a cubrir algunas opciones, pero haga su tarea y consulte el documento .

nodo inicial 1

devnet$ geth --datadir node1/ --syncmode 'full' --port 30311 --rpc --rpcaddr 'localhost' --rpcport 8501 --rpcapi 'personal,db,eth,net,web3,txpool,miner' - -bootnodes 'enode://3ec4fef2d726c2c01f16f0a0030f15dd5a81e274067af2b2157cafbf76aa79fa9c0be52c6664e80cc5b08162ede53279bd70ee10d024fe86613b0b09e1106c40@127.0.0.1:30310' --networkid 1515 --gasprice '1' -unlock '0x87366ef81db496edd0ea2055ca605e8686eec1e6' --password node1/password.txt --mine

• --syncmode 'full' ayuda a prevenir el error Discarded Bad Propagated Block .
• --port 30311 es el puerto de enodo para el nodo1 y tiene que ser diferente del puerto de bootnode (es decir, 30310 si siguió mi comando) porque estamos en un host local. En una red real (un nodo por máquina), use el mismo puerto.
• --rpcapi permite que los módulos enumerados se usen en llamadas RPC (consulte la sección 3.3 para ver un ejemplo). Consulte las API de administración de Geth para obtener más información. Tenga en cuenta los hacks, ya que todos pueden llamar a sus métodos RPC si no hay un firewall que proteja su nodo.
• --bootnodes le dice a su nodo en qué dirección encontrar su bootnode. Reemplace [::] con la IP del nodo de arranque. ¡ No se permiten nombres de dominio ! Solo IP. Compruebe el formato de URL de enodo .
• --networkId como se define en el archivo genesis.json . ¡Utilice la misma identificación!
• --gasprice '1' No me gusta pagar en mi propia red :) tenga cuidado con gasprice. Si sus transacciones no se transmiten a la red, pero solo el nodo que las recibe las procesa, significa que envió una transacción con un precio de gasolina que no es aceptado (demasiado bajo) por los otros nodos de la red. No se devolverá ningún error. Si tiene dos nodos, solo uno procesará las transacciones. Esto es astuto y reduce el rendimiento de su red en un factor 2.
• --unlock --password --mine dígale al nodo que desbloquee esta cuenta, con la contraseña en ese archivo y que comience a minar (es decir, votar/sellar para la Prueba de autoridad)
• --targetgaslimit value ver la actualización en la sección 2.3.

lo mismo para el nodo 2 (parámetros de actualización específicos del nodo)

devnet$ geth --datadir node2/ --syncmode 'full' --port 30312 --rpc --rpcaddr 'localhost' --rpcport 8502 --rpcapi 'personal,db,eth,net,web3,txpool,miner' - -bootnodes 'enode://3ec4fef2d726c2c01f16f0a0030f15dd5a81e274067af2b2157cafbf76aa79fa9c0be52c6664e80cc5b08162ede53279bd70ee10d024fe86613b0b09e1106c40@127.0.0.1:30310' --networkid 1515 --gasprice '0' --unlock '0x08a58f09194e403d02a1928a7bf78646cfc260b0' --password node2/password.txt --mine

En este punto, su nodo de arranque debería transmitir conexiones provenientes del nodo 1 (puerto 30311) y del nodo 2 (puerto 30312) como se muestra en la ventana superior de la terminal. El nodo 1 (terminal central) y el nodo 2 (terminal inferior) deberían estar felizmente minando y firmando bloques. Aquí tengo un período de 1 segundo (definido en el archivo de génesis), por lo tanto, la creación rápida de bloques.

2.3 Actualice su archivo de génesis

Estoy seguro de que querrá modificar algunos valores en su archivo de génesis. Avanzar ! Sin embargo, para que esos cambios sean efectivos, debemos inicializar una nueva cadena de bloques. Aquí está el archivo de génesis que estoy usando actualmente:

{"config": {"chainId": 1515,"homesteadBlock": 1,"eip150Block": 2,"eip150Hash": "0x0000000000000000000000000000000000000000000000000000000000000000","eip155Block": 3,"eip158Block": 3,"byzantiumBlock": 4, "clique": {"period": 1,"epoch": 30000}},"nonce": "0x0","timestamp": "0x5a722c92","extraData": "0x000000000000000000000000000000000000000000000000000000000000000008a58f09194e403d02a1928a7bf78646cfc260b087366ef81db496edd0ea2055ca605e8686eec1e60000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","gasLimit": "0x59A5380" ,"difficulty": "0x1","mixHash": "0x0000000000000000000000000000000000000000000000000000000000000000","coinbase": "0x0000000000000000000000000000000000000000","alloc": {"08a58f09194e403d02a1928a7bf78646cfc260b0": {"balance": "0x200000000000000000000000000000000000000000000000000000000000000"},"87366ef81db496edd0ea2055ca605e8686eec1e6": {" saldo": "0x200000000000000000000000000000000000000000000000000 0000000000000"},"F464A67CA59606f0fFE159092FF2F474d69FD675": {"balance": "0x200000000000000000000000000000000000000000000000000000000000000"}},"number": "0x0","gasUsed": "0x0","parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000"}

He limpiado las direcciones vacías que incluye puppeth al crear el archivo (en la sección 1.3). También agregué una tercera dirección que se financia cuando se crea el bloque de génesis. Luego cambié el period de 15 segundos a 1 para extraer esos bloques más rápido (tenga cuidado ya que un bloque vacío pesa 1024 bytes; aquí mi carpeta chaindata/ gana 1024 bytes por segundo (y más si los bloques no están vacíos). Finalmente He aumentado el gasLimit para permitir más transacciones (hablando en serio, computación) por bloque.

actualización : ¡El gasLimit definido en el archivo de génesis solo se aplica al bloque de génesis! El gasLimit de gas de los bloques nuevos es DINÁMICO , lo que significa que su valor cambia con el tiempo según la cantidad de gas que se usó en el bloque principal (anterior). El cálculo del nuevo gasLimit se realiza en la función CalcGasLimit ( fuente de github ). Si desea un límite de gas constante, use la opción --targetgaslimit intValue cuando ejecute geth. Recomendaría establecerlo igual a gasLimit en el archivo de génesis (la opción de comando es un número entero mientras que el valor de génesis es hexadecimal) para que obtenga un límite de gas constante que ya no cambie con el tiempo. Dado el archivo de génesis anterior con "gasLimit":"0x59A5380" , estoy ejecutando mi nodo con --targetgaslimit 94000000 para un límite de gas constante en todos los bloques.

El campo extraData contiene la dirección que se permite sellar (es por eso que es bueno tener marionetas).

Investigué el impacto de cambiar el period y el gasLimit en la cantidad de transacciones por segundo (tasa de transacción) que la cadena de bloques puede procesar. Pero ese será otro artículo; Enlace aquí.

Cuando esté satisfecho con su archivo de génesis. Elimine sus nodos si se están ejecutando (ctrl C en la terminal). Luego elimine la carpeta geth/ en el node1/ y geht/ en el node2/ . ¡Elimine solo carpetas geth/ !

Luego inicialice sus nodos. De la sección 1.4:

devnet$ geth --datadir nodo1/ init genesis.jsondevnet$ geth --datadir nodo2/ init genesis.json

y vuelva a iniciar sus nodos con los comandos de la sección 2.2

3. Interactúa con tus nodos

Genial, su red ahora está activa :) pero, ¿cómo conectarse a ella y comenzar a explorar?

3.1 Abra una consola Geth Javascript

La forma más simple y probablemente más directa de jugar con un nodo es probablemente adjuntar una consola Geth javascript a uno de los nodos.

3.1.1 A través de CIP

IPC ( Comunicación entre procesos ) funciona solo localmente: debe estar en la misma máquina que su nodo. Abra una terminal adicional y conéctela a su nodo. Para conectarse al nodo1:

$ cd devnetdevnet$ geth attach node1/geth.ipc ¡Bienvenido a la consola de JavaScript de Geth!

instancia: Geth/v1.7.3-stable-4bb3c89d/linux-amd64/go1.9coinbase: 0x87366ef81db496edd0ea2055ca605e8686eec1e6at bloque: 901 (sábado, 10 de febrero de 2018 21:15:30 CET)datadir: /home/salanfe/privateNetworks/node1 administrador: 1.0 camarilla: 1.0 depuración: 1.0 eth: 1.0 minero: 1.0 red: 1.0 personal: 1.0 rpc: 1.0 txpool: 1.0 web3: 1.0

>

El archivo geth.ipc se crea solo cuando el nodo se está ejecutando. Así que no espere encontrarlo si su nodo1 está apagado.

RPC brinda acceso sin restricciones a todos los módulos enumerados en la terminal: admin: 1.0 clique:1.0 debug:1.0 eth:1.0 miner:1.0 net:1.0 personal:1.0 rpc:1.0 txpool:1.0 web3:1.0

3.1.2 A través de RPC

RPC (llamada de procedimiento remoto ) funciona a través de Internet como solicitudes HTTP. Por lo tanto, tenga cuidado cuando abra RPC al mundo exterior, ya que todos tendrán acceso a su nodo. Por esta razón, RPC está deshabilitado por defecto y cuando está habilitado no da acceso a todos los módulos. En esta guía permitimos RPC en nuestro nodo Geth con el comando --rpc y dimos acceso a los módulos personal,db,eth,net,web3,txpool,miner (de la sección 2.2). Para conectarse al nodo 1 mediante RPC:

$ cd devnetdevnet$ geth adjuntar 'http://localhost:8501' ¡Bienvenido a la consola JavaScript de Geth!

instancia: Geth/v1.7.3-stable-4bb3c89d/linux-amd64/go1.9coinbase: 0x87366ef81db496edd0ea2055ca605e8686eec1e6at bloque: 945 (sábado, 10 de febrero de 2018 21:16:14 CET) módulos: eth: 1.0 minero: 10 personal: red: 1.0 rpc:1.0 txpool:1.0 web3:1.0

>

3.1.3 Uso de la consola Geth Javascript

Estos son algunos ejemplos de métodos.

> net.version "1515"> Eth.BlockNumber1910> Eth.coinbase "0x87366ef81db496edd0ea2055ca605e8686eec1e6"> eth.sendtransaction ({'de': eth.coinbase, 'to': '0x08a58f09194e4033428628', oval. 'ether')})"0x299a99baa1b39bdee5f02e3c660e19e744f81c2e886b5fc24aa83f92fe100d3f"> eth.getTransactionReceipt("0x299a99baa1b39bdee5f02e3c660e19e744f81c2e886b5fc24aa83f92fe100d3f"){blockHash: "0x212fb593980bd42fcaf3f6d1e6db2dd86d3764df8cac2d90408f481ae7830de8",blockNumber: 2079,contractAddress: null,cumulativeGasUsed: 21000,from: "0x87366ef81db496edd0ea2055ca605e8686eec1e6",gasUsed: 21000,logs: [ ],logsBloom: "0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",status: "0x1",to: "0x08a58f09194e403d02a1928a7bf78646cfc260b0",transactionHash: "0x299a99baa1b39bdee5f02e3c660e19e744f81c2e886b5fc24aa83f92fe100d3f",transactionIndex: 0}> exit // to quit the Geth javascript console

para obtener la lista completa de métodos, consulte API de administración y API JSON RPC .

3.2 Uso de la niebla

El navegador Mist proporciona una interfaz gráfica de usuario para implementar e interactuar con contratos inteligentes y administrar cuentas. Para conectar Mist a su red privada local a través de IPC, simplemente haga lo siguiente:

devnet$ niebla --rpc nodo1/geth.ipc

y sobre RPC (asegúrese de que RPC esté habilitado)

$ niebla --rpc 'http://localhost:8501'

El procedimiento es exactamente el mismo si desea utilizar la billetera Ethereum en lugar de la niebla. Simplemente reemplace mist por ethereumwallet en los comandos anteriores.

3.3 Realización de llamadas RPC con su lenguaje de programación favorito

En la sección 3.1, vimos cómo interactuar con la API de Geth a mano. Ahora usemos nuestra PC para lo que mejor se le da: automatización.

La referencia y, con mucho, para enviar solicitudes JSON-RPC a su nodo es la biblioteca javascript web3.js. Creo que Internet está lleno de excelentes tutoriales y ejemplos sobre cómo usar la biblioteca web3.js. Por lo tanto, no voy a encubrir nada de eso aquí.

Actualmente, las API de JSON-RPC también se están implementando en java con la biblioteca web3.j y en python con la biblioteca web3.py. Esas bibliotecas ofrecen métodos de alto nivel para trabajar con la cadena de bloques ethereum al igual que web3.js.

Sin embargo, también es posible enviar solicitudes JSON-RPC sin procesar directamente a su nodo. Creo que vale la pena intentarlo, ya que proporciona una valiosa comprensión de cómo funcionan esas bibliotecas de alto nivel bajo el capó.

Aquí hay un ejemplo simple de cómo enviar una solicitud JSON-RPC sin procesar a mi nodo usando python 3:

$ pythonPython 3.6.4 |Anaconda personalizada (64 bits)| (predeterminado, 16 de enero de 2018, 18:10:19) [GCC 7.2.0] en Linux Escriba "ayuda", "derechos de autor", "créditos" o "licencia" para obtener más información.>>> solicitudes de importación>>> importar json >>> sesión = solicitudes.Sesión()>>> método = 'eth_getTransactionCount'>>> params = ["0x627306090abaB3A6e1400e9345bC60c78a8BEf57","latest"]>>> PAYLOAD = {"jsonrpc":"2.0",... " method":method,... "params":params,... "id":67}>>> PAYLOAD = json.dumps(PAYLOAD)>>> headers = {'Content-type': 'application/json '}>>> respuesta = session.post(' http://127.0.0.1:8501' , data=PAYLOAD, headers=headers)>>> respuesta.contentb'{"jsonrpc":"2.0","id" :67,"resultado":"0x0"}\n'>>> json.loads(respuesta.contenido)['resultado']'0x0'

El método geth_transactionCount está documentado aquí .

El nonce de "cuenta" es un contador de transacciones y no tiene nada que ver con el nonce de Prueba de trabajo. Un nonce de cuenta de cero significa que la dirección 0x627306090abaB3A6e1400e9345bC60c78a8BEf57 nunca realizó ninguna transacción en la red: 0x0 es la representación hexadecimal de cero.

3.4 Implemente y pruebe sus contratos inteligentes con Truffle en su red privada

Los marcos de desarrollo como Truffle (o Embark , Populus ) son excelentes herramientas para desarrollar y probar contratos inteligentes.

Cuando inicializa un espacio de trabajo con

$ trufa inicial

Truffle crea una serie de archivos y carpetas para ayudarlo a comenzar. Normalmente edito el archivo truffle.js como tal

module.exports = {// Consulte < http://truffleframework.com/docs/advanced/configuration >// para personalizar su configuración de Truffle! redes: {devnet: {host: '127.0.0.1', puerto: 8501, network_id : '*'}, ganache: {host: '127.0.0.1', puerto: 7545, network_id: '*'}}};

luego usa el comando

$ implementación de trufas --network devnet

para implementar sus contratos inteligentes definidos migrations/X_deploy.js . O para ejecutar sus pruebas en test/

$ prueba de trufa --network devnet

Por lo general, el simulador Ganache de Ethereum Blockchain es más que suficiente para ejecutar sus pruebas. Sin embargo, me gusta usar mi cadena de bloques privada para realizar pruebas definitivas en un nodo real y no solo en un simulador. Con Ganache, creo que la capa de abstracción es demasiado grande, cuál es su belleza, pero también un peligro, ya que no requiere comprender en absoluto la complejidad de un nodo real (grupo de transacciones, gasPrice, gasLimit, transmisión de transacciones entre nodos , minería o votación, tiempo de cómputo, motor de consenso, etc.).

Que sigue ?

Eso es más o menos todo para esta guía. Si entiende todo aquí, creo que ya está en muy buen camino y tiene una base sólida sobre la cual puede continuar su viaje con confianza.

Puede comenzar a desarrollar Dapps (aplicaciones descentralizadas) tomando una biblioteca web3 o creando su propio contenedor JSON-RPC personalizado.

En esta publicación , exploro cómo usar python para implementar y realizar transacciones con un contrato inteligente utilizando solo solicitudes HTTP sin procesar.

Ethereum: cree solicitudes JSON-RPC sin procesar con Python para implementar y realizar transacciones con un… _Febrero de 2018._medium.com

Ultimas palabras

Enhorabuena si llegaste hasta el final. Espero que esta guía sea completa y te haya ayudado en tu viaje. ¡Agradezco cualquier comentario para mejorar esta guía!

Y MUCHAS gracias a la comunidad por toda la documentación, tutoriales, sitios web de preguntas y respuestas y guías disponibles.

¡Feliz hackeo!