Participa en el lanzamiento de Symbol: 1 XEM = 1 XYM. Haz clic aquí
Participa en el lanzamiento de Symbol:
1 XEM = 1 XYM. Haz clic aquí

JavaScript

nem-696x449

Transacciones de NEMBlockchain Faucet usando ReasonML

, , ,

En este artículo se explicará cómo se podrá aprovechar la criptomoneda XEM. Incluyendo las transacciones usando NEM SDK con ReasonML. Parte 2

Este artículo tiene una etapa previa la cual podrán encontrar en este enlace.

El Objetivo

Nuestro objetivo es transferir XEM, de una cuenta a otra, para eso necesitamos crear nuestras dos cuentas y llenarlas con XEM, usando un grifo.

En caso de que quiera aprender solo sobre el grifo, puede omitir la sección de tiempo de retorno completamente.

Retrocedamos

En caso de que se haya perdido el anterior artículo, usted debió terminar con un arcivo con la siguiente estructura- el cual vamos a necesitar para integrar el faucet de NEM.

Resultado de la estructura del archivo, del anterior artículo

Gracias a @44uk_i3, NEM2 Faucet existen. Y lo configuraremos ahora mismo, comenzamos clonando el repositorio, una vez que esté clonado, creamos un Dockerfile, que podemos usar para iniciarlo.

$> git clone https://github.com/44uk/nem2-faucet
$> cd nem2-faucet && touch Dockerfile

Faucet DockerFile

El siguiente paso lógico es construir una imagen, donde realmente podamos ejecutar la llave. Necesitaremos nodejs, así que vamos a utilizar la misma versión que hemos utilizado en el artículo anterior para nuestro entorno ReasonML. (nodo: 11.4)

Luego, tendremos que completar un grupo de variables ENV para que la llave funcione correctamente. Revisemos las variables y expliquemos cómo y dónde obtener los valores necesarios.

API_HOST

Esta será la URL de la red de conexión del contenedor, donde se ejecuta nuestra puerta de enlace NEM Rest. Sabemos que en nuestra configuración, el nombre del contenedor es catapult-service-bootstrap_rest-gateway_1

API_PORT

Este es el puerto de la puerta de enlace predeterminada, 3000.

PRIVATE_KEY

Esta es una private_key de una cuenta, que se genera cuando comienza nuestra pila de catapultas. Parte de las llamadas direcciones de nemesis, que se rellenan previamente con xem.

¿Cómo puedes encontrar la clave privada requerida? El primer paso es lanzar la pila de catapultas.

$> cd catapult-service-bootstrap
$> docker-compose up

Luego, navegue a catapult-service-bootstrap / build / genera-address / Address.yaml, y busque nemesis_addresses.

Tome la primera clave privada que encuentre, debe estar poblada con suficiente xem para alimentar nuestro grifo.

Entonces nuestro valor valor será:

F1C69759140256420EB42CF39906A01DD02A57FB6D0676AE134343A13A1CBC21

Lista de direcciones nemesis generadas, que se rellenan previamente con xem

RECAPTCHA_CLIENT_SECRET &

RECAPTCHA_SERVER_SECRET

Faucet cuenta con recaptcha de google, por lo que en caso de que su llave sea pública, estará protegida contra ciertos tipos de abuso.

¿Dónde podemos conseguir esos secretos? Navegue al sitio recaptcha de google. Y entrar en la interfaz de administración.

Navegando a la interfaz de administración de recaptcha

Una vez que esté dentro, complete la información de su sitio, en nuestro caso localhost / 127.0.0.1, acepte los términos y condiciones y confirme. Navegará a una página en la que finalmente podremos extraer los secretos para la recaptcha de nuestro faucet.

Registro de un sitio para recaptcha

Nuestros secretos serían visibles abajo, en el área coloreada.

RECAPTCHA_CLIENT_SECRET = Clave del sitio

RECAPTCHA_SERVER_SECRET = Clave secreta

Recuperando sitio y clave secreta de recaptcha admin

Con todos los secretos a nuestra disposición, para la configuración de nuestro entorno, escribamos el propio Dockerfile, para que podamos construir una imagen para ejecutar nuestro faucet.

Hemos creado el Dockerfile anteriormente, ahora lo completamos.

# Use a recent nodejs image
FROM node:11.4
ENV COOKIE_SECRET=ff1014b6a302a2eb5a43773d8df30122b6f92c8e
ENV PORT=3000
ENV NETWORK=MIJIN_TEST
ENV API_HOST=http://catapult-service-bootstrap_rest-gateway_1
ENV API_PORT=3000
ENV PRIVATE_KEY=__replace with your nemesis address private key__
ENV MIN_XEM=1000000000
ENV MAX_XEM=2000000000
ENV OPT_XEM=
ENV ENOUGH_BALANCE=20000000000
ENV MAX_UNCONFIRMED=5
ENV WAIT_HEIGHT=0
ENV RECAPTCHA_CLIENT_SECRET=__replace with your site key__
ENV RECAPTCHA_SERVER_SECRET=__replace with your secret key__

Estamos listos para volver a la terminal, para construir nuestra imagen y ejecutar el grifo. Usaremos un archivo run-in-docker.sh, similar al creado en el artículo anterior.

Asegúrate de que tu pila de catapultas esté funcionando primero

$> docker build . -t nem2-faucet

Construye nuestra imagen de Faucet

# Inside nem2-faucet directory
$> touch run-in-docker.sh && chmod +x run-in-docker.sh

Crea un run-in-docker.sh script

docker run –network=”catapult-service-bootstrap_default” -p 9000:3000 -v “$PWD”:/app -w /app -it nem2-faucet:latest /bin/bash

Contenido de nem2-faucet / run-in-docker.sh

Para finalizar la configuración de la llave, instalemos sus dependencias. Ejecute npm install utilizando run-in-docker.sh.

Si todo ha salido bien, deberíamos correr Faucet

Primero creamos una cuenta usando NEM2-CLI, donde podremos enviar algunos XEM

Encienda un contenedor docker con nem2-cli instalado, idealmente app / run-in-docker.sh. La explicación detallada sobre cómo crear una cuenta / cartera de NEM Blockchain se puede encontrar en el primer artículo.

Solución de problemas


En caso de que tenga problemas con los servicios de catapulta, puede intentar ejecutar la ventana acoplable, utilizando esta confirmación desde julio de 2018.

Puede borrar todos los archivos de compilación y otros “errores” que crea la catapulta, ejecutando ./clear-all dentro del directorio de la catapulta.

No olvide actualizar la variable env de clave privada de su faucet y reconstruir la imagen de la ventana acoplable, cada vez que limpie y componga sus servicios de catapulta, porque las direcciones de nemesis cambiarán.

Creando una nueva cuenta usando NEM2-CLI

Usaremos esta cuenta para verificar que nuestra llave funciona de la manera esperada. Vamos a empezar el grifo ahora. Use nem2-faucet / run-in-docker.sh y ejecute los siguientes comandos.

$> npm run dev

Arrancando el faucet a través de la línea de comando.

Navegue a http:// localhost:9000 en su navegador favorito, para verificar que la llave esté funcionando como se esperaba.

Faucet cargado

Transferencia de XEM desde el Faucet a su cuenta de NEM

En los pasos anteriores, hemos creado una cuenta NEM con la dirección pública de SD5BOY-KFIWDU-PTSJEK-64RVG2-CQGQYQ-63UXEN-DDKU.

Vamos a usar el grifo, para enviar un XEM a nuestra dirección. Rellene el formulario, y pulse reclamo. No olvides convencer a Google de que no eres un robot.

Enviando XEM desde faucet, a nuestra nueva cuenta.

¿Cómo podemos verificar que el XEM realmente llegó a nuestra dirección? Podemos usar nem2-cli para ver nuestro equilibrio. Usemos app / run-in-docker.sh y verifiquemos el saldo de nuestra cuenta, usando nem2-cli.

Los XEM llegaron sin problemas, a nuestra cuenta

Enhorabuena, ha transferido con éxito 1000 XEM, de la llave, a su propia cuenta. ¡Ahora estás listo para intercambiar y explorar la cadena de bloques NEM!

Aceleremos el paso

Ahora que tenemos suficientes “racks en nuestros bolsillos”, podemos intentar transferir XEM mediante programación utilizando NEM2-SDK.

Comencemos por crear una segunda cuenta, donde podemos transferir nuestro dinero virtual.

Ahora tenemos dos cuentas, guardadas en dos perfiles: my_account (1000 xem) y my_other_account (0 xem).

Vamos a escribir un script ReasonML, para transferir algunos xem, de uno a otro.

El Flujo

Primero, debemos definir la dirección del destinatario, en nuestro caso será nuestra nueva / segunda cuenta.

Dirección del destinatario: SB7COE-YWEP7K-LAKHJX-VPMBL5–4PIYU7-KTNA7J-LYY3

Luego, necesitamos una clave privada, de la cuenta que contiene nuestro 1000xem, porque la usaremos para firmar la transacción.

Clave privada: 5EBAFD9F3258188E6C1F2AC44CFBF89BF352878FECC517847D4953AD7518EEDD

A continuación, tenemos que especificar la cantidad que queremos enviar, le enviaremos un 100xem, porque es Navidad y nos sentimos generosos.

Cantidad de XEM a enviar: 100

Aparte de eso, solo necesitamos especificar nuestra URL de la puerta de enlace REST, pero lo hicimos muchas veces antes, lo verás en el código.

Cosas que se hacen en nuestro código ReasonML:

1. Convierte la dirección del destinatario en una cuenta NEM.

2. Convierta la clave privada en una cuenta NEM, utilizada para firmar la transacción
3. Defina el objeto de la transacción de transferencia, incluidos la fecha límite, el destinatario, los mosaicos para transferir (en nuestro caso, solo XEM), el mensaje y la red
4. Firme la transacción, utilizando la cuenta NEM, creada a partir de nuestra clave privada.
5. Anuncie la transacción a la red blockchain

La mayoría del archivo que se muestra a continuación, son definiciones de tipo, desaparecerían, una vez que NEM-SDK proporcione un mapeo/versión de ReasonML. Pero por ahora, podemos especificar los tipos nosotros mismos, por lo que la interoperabilidad JS funciona perfectamente.

Vamos a crear un nuevo archivo, transferXem.re con el siguiente contenido.

/*
   SDK Type definitions
*/
[@bs.module “nem2-sdk”] external networkType: Js.Dict.t(int) = “NetworkType”;

type nemAddress;

[@bs.module “nem2-sdk”] external address: (nemAddress) = “Address”;
[@bs.send] external createFromRawAddress: (nemAddress, string) => nemAddress = “createFromRawAddress”;
[@bs.send] external prettyAddress: (nemAddress) => nemAddress = “pretty”;

type nemDeadline;
[@bs.module “nem2-sdk”] external deadline: (nemDeadline) = “Deadline”;
[@bs.send] external createDeadline: (nemDeadline) => nemDeadline = “create”;

type nemMosaic;

type nemXem;
[@bs.module “nem2-sdk”] external xem: (nemXem) = “XEM”;
[@bs.send] external createRelative: (nemXem, float) => nemMosaic = “createRelative”;

type nemPlainMessage;
[@bs.module “nem2-sdk”] external plainMessage: (nemPlainMessage) = “PlainMessage”;
[@bs.send] external createPlainMessage: (nemPlainMessage, string) => nemPlainMessage = “create”;

type nemTransferTransaction;
[@bs.module “nem2-sdk”] external transaction: (nemTransferTransaction) = “TransferTransaction”;
[@bs.send] external createTransferTransaction: (nemTransferTransaction, nemDeadline, nemAddress, array(nemMosaic), nemPlainMessage, int) => nemTransferTransaction = “create”;

type nemSignedTransaction;

type nemAccount;
[@bs.module “nem2-sdk”] external account: (nemAccount) = “Account”;
[@bs.send] external createFromPrivateKey: (nemAccount, string, int) => nemAccount = “createFromPrivateKey”;
[@bs.send] external sign: (nemAccount, nemTransferTransaction) => nemSignedTransaction = “sign”;

type nemTransactionHttp;
[@bs.new] [@bs.module “nem2-sdk”] external transactionHttp: (string) => nemTransactionHttp = “TransactionHttp”;
[@bs.send] external announce: (nemTransactionHttp, nemSignedTransaction) => unit = “announce”;


/*
   Transactional code
*/
let recipientAddressRaw: string = “SB7COE-YWEP7K-LAKHJX-VPMBL5-4PIYU7-KTNA7J-LYY3”;
let recipient: nemAddress = address->createFromRawAddress(recipientAddressRaw);
let transactionDeadline = deadline->createDeadline;
let arrayOfMosaicsForTransaction = [|
   xem->createRelative(float_of_int(100))
|]
let message = plainMessage->createPlainMessage(“Pocket money for you!”);
let transactionNetwork = switch(Js.Dict.get(networkType, “MIJIN_TEST”)) {
   | Some(network) => network
   | _ => -1
}

let transferTransaction: nemTransferTransaction = transaction
   ->createTransferTransaction(
       transactionDeadline,
       recipient,
       arrayOfMosaicsForTransaction,
       message,
       transactionNetwork
   );

let privateKey: string = “5EBAFD9F3258188E6C1F2AC44CFBF89BF352878FECC517847D4953AD7518EEDD”;
let senderAccount: nemAccount = account->createFromPrivateKey(privateKey, transactionNetwork);

let signedTransaction: nemSignedTransaction = senderAccount->sign(transferTransaction);

let apiUrl: string = “http://catapult-service-bootstrap_rest-gateway_1:3000”;
transactionHttp(apiUrl)
   ->announce(signedTransaction);
view rawtransferXem.re hosted

Podemos compilarlo y ejecutarlo desde nuestro contenedor ReasonML, usando run-in-docker.sh, con este comando.

$> yarn build && node src/transferXem.bs.js

El Resultado

Verifiquemos si nuestro XEM llegó con éxito a my_other_account. Podemos hacerlo usando NEM-CLI y verificando la información de la cuenta como lo hicimos anteriormente.

Podemos ver que una de nuestras cuentas tiene 900 XEM, en lugar de 1000 XEM, y la segunda cuenta ahora tiene 100 XEM, en lugar de 0 / sin historial en la cadena de bloques.

¿Que sigue?

En el siguiente artículo, crearemos mosaicos personalizados y los intercambiaremos entre cuentas utilizando transacciones de firma múltiple.

Fuente: Medium

nemdev

ReasonML y NEM Blockchain

, , , , ,

Introducción de la integración de la Blockchain de NEM con ReasonML

Este artículo explica el uso básico del NEM2-SDK con ReasonML, junto a NEM2-CLI

Introducción

Realizaremos la configuración de los servicios NEM Catapult, para exponenciar nuestro flujo de trabajo de Blockchain, luego interactuamos con la misma blockchain utilizando NEM SDK para javascript, pero para ser extra-cool ™ escribiremos nuestros ejemplos utilizando ReasonML.

ReasonML es esencialmente una sintaxis para el lenguaje de programación OCaml, viene con una variedad de herramientas útiles, que nos permiten compilarlo en Javascript.

NEM es una tecnología de cadena de bloques relativamente nueva, que maneja transacciones de firma múltiple con facilidad y tiene un avanzado desarrollo de herramientas.

Pre Requisitos

Se asume que el lector tenga un conocimiento  de programación y en conocer el lenguaje Docker, Javascript, Git y Blockchain (P.e. Ethereum, tezos…).

Glosario

Primero que todo, vamos ahondar un poco en la tecnología que usaremos:

  • NEM Blockchain es una plataforma Blockchain que facilita la integración con aplicaciones nuevas o existentes, al proporcionar una experiencia de desarrollado más confortable a comparación de otras Blockchain. Permite una blockchain tanto privada como pública, en la que se puede desarrollar activos inteligentes y transacciones de multi-firma.
  • ReasonML es una sintaxis del lenguaje OCaml y a su vez una “caja de herramienta”, orientada a desarrolladores de Javascript
  1. Instalar Catapult

Se comienza por clonar la base de código del catapult-service-bootstrap, luego organice todos los servicios de la ventana acoplable utilizando los comandos a continuación.

“Para quienes no están familiarizados con Docker o Git, se ha copiado el código de almacenamiento remoto, para luego iniciar los servicio provistos utilizando las “máquinas virtuales” de la ventana acoplable. “

$> git clone https://github.com/tech-bureau/catapult-service-bootstrap
$> cd catapult-service-bootstrap
$> docker-compose up

Una vez que Nem empiece a compilar, su terminal output lucirá algo así

El siguiente paso es de verificar, que el resto de la Blockchain y nodos estén corriendo. Usted puede hacer esto integrando el REST API , proporcionado por Catapult Rest, como se muestra a continuación.

$> curl localhost:3000/block/1

Si todo sale como se esperaba, usted verá replicado el JSON replicado como se ve arriba  

Se ha instalado correctamente NEM Blockchain y los nodos REST en su máquina

2.  Configuración ReasonML/ NEM environment

Para desarrollar nuestra integración de la blockchain con Catapult REST, se usará el NEM SDK, con ReasonML

Se empezará por crear la estructura apropiada de la carpeta:

Los siguientes comandos, se ejecutan por fuera del directorio “git clonado” que se creó en el paso 1

$> mkdir app
$> cd app
$> touch Dockerfile
$> touch run-in-docker.sh & chmod +x run-in-docker.sh

Creación de la estructura de la carpeta

“Se necesitará de un ambiente para compilar los scripts. Use un nodo basado en la imagen docker, con la plataforma-bs (Herramienta ReasonML) ya instalada. De click aquí para aprender qué rol juega acá bs-platform a.k.a. bucklescript. “

# Use a recent nodejs image
FROM node:11.4

# Install bucklescript compiler
RUN yarn global add bs-platform
RUN yarn global add nem2-cli

Contenido previo de la carpeta Docker

“El siguiente paso es de construir la imagen docker, por lo que se podrá utilizar el reason environment. “

$> docker build . -t reason-bread

Creación de la imagen, ahora se podrá correr el run-in-docker.sh

“Cuando utilizamos el run-in-docker.sh para proporcionar una capa interactiva con el ReasonML instalado. “

docker run –network=”catapult-service-bootstrap_default” -v “$PWD”:/app -w /app -it reason-bread:latest /bin/bash

Pequeño y útil script, que nos permite correr el reason-able shel, encima de nuestras carpetas

Resultado de los comandos anteriores. Dockerfile, run-in-docker.sh creado con el contenido apropiado, y la imagen de motivo disponible.

Felicidades, ahora está listo para comunicarse con  la NEM Blockchain, a través de scripts escritos en ReasonML: todo lo que necesita para compilar y ejecutar scripts ReasonML, sucede en la imagen de la ventana acoplable que acabamos de crear.

3. Configuración del Proyecto Reason

Hasta ahora, hemos establecido una base sólida. Se están ejecutando los bloques NEM blockchain y REST, y tenemos una imagen acoplable con un pequeño script auxiliar para ejecutar el código ReasonML.

El siguiente paso es armar / generar un proyecto de Reason.

$> cd app
$> ./run-in-docker.sh

Nuestra instancia interactiva / bin / bash, con bucklescript disponible debería tener este aspecto.

$> bsb -init . -theme basic-reason

Proyecto generado, exitosamente

“ Para confirmar que nuestro proyecto ha sido generado como esperábamos. Compilamos y ejecutamos nuestro demo script.

$> yarn build && node src/Demo.bs.js

Sientase libre de usar el editor de código de su preferencia, yo usualmente utilizo opt-in para vscode.  Nuestra imagen acoplable toma / monta los archivos del mismo sistema de al que podemos acceder desde nuestra “computadora real”.

Our generated Demo script written in Reason, as shown in visual studio code editor.

Nuestro script de demostración generado en Reason, como se muestra en el editor de código de estudio visual.

“Demo.re es un archivo, que fue generado usando bsb-init y Demo.bs.js, que es lo mismo pero se compila en javascript”

Compile y corra usando el nodo, como cualquier archivo de javascript

Vamos a hacer esto !

Nuestra configuración funciona como se esperaba, podemos pasar a la parte divertida.

El primer ejercicio creará una nueva cuenta en NEM Blockchain, utilizando el sdk y el cli.

En nuestro entorno docker, instale nem2-sdk.

$> yarn add nem2-sdk

Generar una nueva cuenta -SDK

Nuestro proyecto de demostración contiene un archivo llamado Demo.re. El cual podemos eliminar. En su lugar, vamos a crear un nuevo archivo en src /, llamado generateNewAccount.re. Escribiremos un código ReasonML, que usará NEM2-SDK, para hablar con la pila de Catapult que configuramos anteriormente. ReasonML nos permite escribir código funcional de tipo seguro, que se intera sin problemas con javascript (navegador y nodo).

Queremos crear una cuenta / billetera NEM, que es un bloque de identidad básica para la cadena de bloques. Lo que nos permite usar todas las características geniales de NEM, como el intercambio de activos inteligentes o las transacciones de firma múltiple. Terminaremos con una clave privada, una clave pública y una dirección.

/*
   Define a nemAccount type, so we can access
   Account properties from the SDK
*/
type nemAccount = Js.t({
   .
   publicKey: string,
   privateKey: string,
   publicAccount: unit
});

/* Import SDK’s Account class */
[@bs.module “nem2-sdk”] external account: (nemAccount) = “Account”;
/* Import SDK’s NetworkType enum, as a dictionary of integers */
[@bs.module “nem2-sdk”] external networkType: Js.Dict.t(int) = “NetworkType”;
/* SDK’s Account.generateNewAccount, is a static method */
[@bs.send] external generateNewAccount: (nemAccount, int) => nemAccount = “generateNewAccount”;

/* Get the ID of our desired network, so we can create an account */
let mijinTestNetwork = Js.Dict.get(networkType, “MIJIN_TEST”);

switch (mijinTestNetwork) {
   | None => Js.log(“Failed to create an account, wrong network used”);
   | Some(network) => {
       let newAccount: nemAccount = generateNewAccount(account, network);
       Js.log(newAccount##publicAccount);
       Js.log(“Private key: ” ++ newAccount##privateKey);
   }
}

Verifiquemos que los archivos hayan compilado y ejecutado primero, después iremos con los contenidos

$> yarn start

El output de yarn corre

Ahora un nuevo archivo aparece, generateNewAccount.bs.js. Esto sucedio por ejecutar el javascript, gracias al compilador bucklescript. Miremos esto:

// Generated by BUCKLESCRIPT VERSION 4.0.11, PLEASE EDIT WITH CARE
‘use strict’;

var Js_dict = require(“bs-platform/lib/js/js_dict.js”);
var Nem2Sdk = require(“nem2-sdk”);

var mijinTestNetwork = Js_dict.get(Nem2Sdk.NetworkType, “MIJIN_TEST”);

if (mijinTestNetwork !== undefined) {
 var newAccount = Nem2Sdk.Account.generateNewAccount(mijinTestNetwork);
 console.log(newAccount.publicAccount);
 console.log(“Private key: ” + newAccount.privateKey);
} else {
 console.log(“Failed to create an account, wrong network used”);
}

exports.mijinTestNetwork = mijinTestNetwork;
/* mijinTestNetwork Not a pure module */

Parece familiar, ¿no ? ¿Qué es lo que hace?

  1. Importa el SDK
  2. Extrae el  valor typescript enums, para MIJIN_TEST
  3. Sí la prueba de la red corre normal, usa la cuenta SDK class, para crear una nueva cuenta  

Ahora puedes ejecutar el salida del script, usando el nodo

$> node src/generateNewAccount.bs.js

Tenemos la llave público/privada, con la dirección de NEM

Generación de una nueva cuenta – CLI

Hasta ahora hemos podido crear una nueva cuenta NEM, utilizando el SDK, con enlaces personalizados de ReasonML. Ahora intentemos lograr el mismo resultado utilizando la CLI de NEM.

Nuestra imagen docker ya contiene nem2-cli, así que vamos a usarla.

“En caso de que los servicios de catapulta no se estén ejecutando, puede utilizar los siguientes comandos para volver a activarlos.”

$> cd catapult-service-bootstrap
$> docker-compose up

Ejecute esto fuera del contenedor dock de razón-pan, también lo hemos hecho en la sección de inicio, ¡siéntase libre de desplazarse hacia atrás hasta allí!

Ahora usaremos cli para generar una nueva cuenta y guardarla en la lista de perfiles de la CLI. Más o menos lo mismo, como lo hizo nuestro código. Asegúrese de ejecutar los siguientes comandos, dentro de run-in-docker.sh, porque necesita acceso a nem2-cli que está instalado allí.

El comando a continuación le pedirá cierta información, usaremos el mismo tipo de red que en nuestros ejemplos de Razón, mientras que la URL del nodo NEM2 cambiará (se muestra a continuación); esto se debe al hecho de que el nodo REST se ejecuta en un contenedor separado, que nuestro run-in-docker.sh, por lo que esencialmente se trata de una red de conexión, que puede obtener más información aquí.

# Network Type: MIJIN_TEST
# Save it?: y
# NEM2 NODE URL: http://catapult-service-bootstrap_rest-gateway_1:3000
# Profile name: main (this can be whatever you desire)
$> nem2-cli account generate

Puede verificar si su cuenta se generó y guardó con éxito, enumerando los perfiles existentes.

Usar la clave privada preestablecida con Reason

Si desea, puede rellenar la lista de perfiles de la CLI, con las cuentas generadas programáticamente (utilizando nuestro código de razón).

Es bastante sencillo:

# Network Type: MIJIN_TEST
# Private key: Output from your reason script, done in the previous step
# NEM2 NODE URL: http://catapult-service-bootstrap_rest-gateway_1:3000
# Profile name: generated-with-reason (this can be whatever you desire)
$> nem2-cli profile create

Un nuevo perfil aparece en el final

Felicitaciones ¿ha creado con éxito dos (o más) cuentas NEM, que ahora puede usar para explorar el resto de la cadena de bloques NEM? Hay una amplia documentación disponible, puede encontrarla en este enlace.

¿Que sigue?


En el siguiente artículo, exploraremos las transacciones de NEM2 Faucet, Mosaics y Multi-signature.


Esto nos permitirá intercambiar nuestro Bread  personalizado (Mosaic / smart asset), por xem (moneda virtual) con otras cuentas en la cadena de bloques.

Fuente: Medium