IOTA Doc Español

Tabla de contenido INTRODUCCIÓN A IOTA ........................................................................................... 3 ¿Qué es IOTA? ........................................................................................................... 3 Glosario ....................................................................................................................... 4 Preguntas Frecuentes ................................................................................................. 6 Whitepaper .................................................................................................................. 6 INSTALAR IRI .............................................................................................................. 7 Encontrar vecinos (Neighbors) .................................................................................. 7 Instalar IRI.................................................................................................................. 7 PROFUNDIZANDO IOTA ........................................................................................... 9 Una Nota sobre Trinarios .......................................................................................... 9 Seeds, Llaves Privadas y Cuentas ............................................................................. 9 Anatomía de una transacción .................................................................................. 10 Bundles (paquetes).................................................................................................... 11 Haciendo un Transacción ........................................................................................ 11 INSTALAR IGU ........................................................................................................... 12 Como instalar ............................................................................................................ 12 Instalación en Windows ........................................................................................... 12 Instalación en Mac OS X ......................................................................................... 14 Instalación en Linux ................................................................................................. 16 Nodo Light vs Nodo Full .......................................................................................... 18 DOCUMENTACIÓN DE LA API DEL IRI .............................................................. 19 Introducción a la API ............................................................................................... 19 Realizando peticiones ............................................................................................... 19 Referencias de la API ............................................................................................... 19 getNodeInfo ............................................................................................................ 19 getNeighbors........................................................................................................... 21 addNeighbors .......................................................................................................... 21 Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

1

removeNeighbors ................................................................................................... 22 getTips .................................................................................................................... 23 findTransactions ..................................................................................................... 23 getTrytes ................................................................................................................. 24 getInclusionStates ................................................................................................... 25 getBalances ............................................................................................................. 26 getTransactionsToApprove .................................................................................... 27 attachToTangle ....................................................................................................... 27 interruptAttachingToTangle ................................................................................... 28 broadcastTransactions ............................................................................................ 28 storeTransactions .................................................................................................... 29 DIRECTRICES PARA EXCHANGES ...................................................................... 31 Introducción .............................................................................................................. 31 Generación segura de una seed ............................................................................... 31 Generando direcciones de depósito de usuario ...................................................... 31 Generación y gestión de direcciones de depósito ................................................... 32 Notificaciones de depósito de usuario ..................................................................... 32 Sweeping (barrido) de dirección de depósito de usuario a las direcciones internas de un exchange ........................................................................................... 33 Retiro de procesamiento y monitoreo ..................................................................... 38 Reasignaciones de transacciones ............................................................................. 41 Generación de direcciones multisig seguras (para hot wallets y cold storage) ... 42 RESUMEN .................................................................................................................... 43

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

2

INTRODUCCIÓN A IOTA ¿Qué es IOTA? IOTA es una nueva y revolucionaria ledger, pública y de última generación que utiliza una invención novedosa en su núcleo, llamada “Tangle”. El Tangle es una nueva estructura de datos basada en un Grafico Acíclico Dirigido (conocido como DAG de sus siglas del ingles,Directed Acyclic Graph). Como tal, no tiene bloques ni cadenas y tampoco mineros. Debido a esta nueva arquitectura, las cosas en IOTA trabajan de una manera bastante diferente en comparación con el blockchain. Para conocer más detalles de IOTA, puede dirigirse a nuestro Blog.

La principal diferencia que vale la pena mencionar (aparte del DAG frente al Blockchain) es cómo IOTA logra el consenso y cómo se realizan las transacciones. Como se mencionó anteriormente, no hay mineros. Lo que esto significa es que cada participante en la red que desea realizar una transacción debe participar activamente en el consenso de la red aprobando 2 transacciones anteriores. Esta certificación de la validez de dos transacciones pasadas garantiza que toda la red alcance un consenso sobre el estado actual de las transacciones aprobadas, y permite una variedad de características únicas que solo se existen en IOTA. IOTA es la pieza que faltaba del rompecabezas para que la economía de las maquinas emerja por completo y alcance su potencial deseado. Pensamos que IOTA será la columna vertebral pública y sin permisos para el Internet de las Cosas (IoT) que permite la verdadera interoperabilidad entre todos los dispositivos.

IOTA posee varias características únicas debido a su arquitectura: 

 



Escalabilidad: IOTA puede lograr un alto rendimiento de las transacciones gracias a la validación en paralelo de las mismas sin límite en cuanto al número de transacciones que se pueden confirmar en un intervalo determinado.

Sin tarifas de transacción: IOTA no tiene tarifas de transacción.

Descentralización: IOTA no tiene mineros. Cada participante en la red que está realizando una transacción, participa activamente en el consenso. Como tal, IOTA está más descentralizado que cualquier Blockchain.

Inmunidad cuántica: IOTA utilizó una función hash trinaría recientemente diseñada llamada Curl, que es cuántica inmune (Winternitz signatures)

En las siguientes secciones, profundizaremos en algunas de las características y principios importantes detrás de IOTA.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

3

Glosario Debido a que IOTA introduce algunos conceptos bastante nuevos en el mundo del Blockchain, enumeraremos un par de términos que es importante comprender para entender completamente IOTA. Este Glosario todavía no está terminado. Si no está seguro acerca de un término, sugiéralo para que podamos agregarlo a este glosario.

Términos genéricos  Red Peer-to-Peer: Red descentralizada que consiste en pares (o nodos) que están conectados entre sí y realizan intercambio de datos entre ellos.  Prueba de trabajo (PoW): Es un algoritmo que evita la denegación de servicio (DoS) y los ataques de correo no deseado en una red (spam). Un rompecabezas (puzzle) computacional difícil de resolver, pero fácil de verificar. IOTA usa un rompecabezas basado en Hashcash.  Trinario: Alternativa a Binario, Trinario es un sistema de números base-3. Leer más aca. o Trits: Análoga a los bits, un dígito ternario es un trit (dígito trinario). los dígitos pueden tener los valores 1, 0 o -1. o Trytes: análogo a los bytes, un tryte consiste en 3 trits, que pueden representar 27 valores. en IOTA, trytes se representan como caracteres '9, A-Z'.  DAG (del ingles Directed Acyclic Graph): Gráfico Acíclico Dirigido. Es una estructura de datos específica basada en un gráfico sin ningún ciclo dirigido. En lugar de tener una única rama con nodos que tienen solo un borde, en un DAG puede haber múltiples ramas. Consulte Wikipedia para más información.

Términos de IOTA  Tangle: Un gráfico acíclico dirigido (DAG) como un ledger distribuido que almacena todos los datos de transacción de la red IOTA. Es un Blockchain sin los bloques y la cadena (¿entonces es realmente un Blockchain?). El Tangle es el primer libro de contabilidad distribuido para lograr escalabilidad, sin transacciones de tarifas, integridad y transmisión de datos, así como protección de computación cuántica.

Contrariamente a los Blockchains actuales, el consenso ya no está desacoplado, sino que es una parte intrínseca del sistema, lo que lleva a una red de peer-to-peer completamente descentralizada y autorreguladora.

 





Tips: Transacciones que no tienen otras transacciones haciendo referencia a ellas.

Curl: la principal función hash utilizada en IOTA, Curl se basa en una construcción de esponja (sponge construction) inventada por los creadores de Keccak (SHA-3), y está específicamente diseñada para IoT, que también es la primera función trinaria hash del mundo.

Kerl: Al igual que Curl, es una nueva función de hash, IOTA actualmente usa Keccak (SHA-3) para la firma. Kerl es Keccek-384, con una conversión adicional de su entrada y salida de/a 243 trits a 48 bytes utilizando el complemento básico de dos.

Winternitz one-time signature (W-OTS): un esquema de Post Quantum Signature, que se utiliza para autorizar el gasto de una dirección en IOTA (firma con su clave privada). Debido a su naturaleza única, la seguridad de los fondos en una dirección disminuye rápidamente si usted firma múltiples transacciones usando la misma clave. Por lo tanto, en IOTA nunca volverá a utilizar una dirección que se haya gastado desde (ya que una firma ya se ha compartido con la red).

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

4







IOTA el token o Suministro total: 2.779.530.283.227.761 IOTAs o Unidades La notación IOTA sigue a las unidades SI. Pi, Ti, Gi, Mi, Ki, i. Mas info.

IRI: La Implementación de Referencia de IOTA (IRI) está escrita en Java y es el cliente central (nodo) de IOTA. Se comunica con la red IOTA para retransmitir transacciones y proporcionar una API bastante limitada a los usuarios; esto se debe en gran parte por razones de seguridad, lo que hace posible la conexión a un nodo remoto.

Iota.lib.*: La biblioteca IOTA, tiene toda la funcionalidad necesaria para usar completamente IOTA, incluido el envío de transacciones, las funciones relacionadas con la criptografía y la API principal. iota.lib.js es la biblioteca establecida y utilizada actualmente.

Direcciones 

 



Seed (semilla): La seed es la clave privada maestra. Se usa para derivar todas las claves privadas y públicas. Manténgala segura y no lo comparta con nadie. Las seed en IOTA consisten en 81 Trytes ('A-Z, 9'), lo que equivale a una seguridad de 384 bits. Una seed es como una clave / contraseña privada. Si alguien tiene acceso a tu seed, puede acceder a tu cuenta. Índice clave (Key Index): Un número entero que específica qué clave derivar de la seed. subSeed = hash (seed + KeyIndex) Nivel de seguridad: Al generar una dirección, tiene la opción de elegir entre 3 modelos de seguridad: o 1: 81-trit de seguridad (baja) o 2: 162-trit de seguridad (medio) o 3: seguridad 243-trit (alta) Nivel de seguridad también afecta la longitud de los paquetes de transacción, donde cada firma de dirección de gasto se distribuye en 1,2 o 3 transacciones (respectivamente).

Dirección (address): Una dirección pública se deriva de la seed, el nivel de seguridad y el índice clave. Las direcciones en IOTA consisten en 81 Trytes ('A-Z, 9'). o Address Checksum: Para evitar errores de direcciones, se agrega una suma de comprobación a los 81 Trytes, para construir una dirección 90 Trytes: Address||hash(Address).LastChars (9) o Dirección MultiSig: Una dirección derivada de la absorción de varias claves de firma. Tal dirección necesitara varias partes para firmar una transacción para mover fondos.

Transacciones 







Transacciones: La unidad más pequeña de datos en IOTA, consta de 2673 trytes y puede usarse para transferir valor o para transferir datos en el Tangle- estructura de transacción o Branch/Trunk: Dos transacciones que fueron referenciadas y validadas por la transacción.

Paquetes (Bundles): Transacciones que se agrupan en bundles durante la creación de una transferencia. Los bundles son transferencias atómicas, se aceptan todas las transacciones dentro del bundle, o ninguna. o Estructura del paquete : haga clic aquí. o Transacción de cola (Tail transaction): La última transacción agregada al bundle, que identifica la instancia del bundle. Para la cola, se puede construir y validar un paquete atravesando el Trunk de cada transacción.

Transferencias: Enviando valor o datos a una dirección, las transferencias son una abstracción de alto nivel del bundle, transacciones, etc. o Transferir objetos: Destinatarios de una transferencia, contiene direcciones y valores de destino. o Etiqueta (tag): Se puede adjuntar un mensaje corto a una transferencia, hasta 27 Trytes ('A-Z, 9'). las etiquetas se pueden buscar. o Entradas: Direcciones con fondos utilizadas para transferencias de valores. Los objetos constan de dirección, nivel de seguridad e índice clave. o Dirección restante: Dirección utilizada para enviar el valor restante de una transferencia, si corresponde.

Selección de sugerencia: Para emitir una nueva transacción en IOTA, primero debe validar dos transacciones anteriores. Esta confirmación ocurre al validar los trytes de transacción, las firmas y la verificación cruzada de transacciones conflictivas.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

5

o



Random Walk (RW): El algoritmo utilizado para seleccionar el par de transacciones anteriores. Para obtener más información, lea el White paper del tangle. o Profundidad (Depth): El punto de partida para el RW. Cuanto mayor sea el valor, más atrás en el Tangle comenzará el RW y el tiempo de ejecución será mayor. Un valor típico, utilizado en las billeteras es 3, que inicia los hitos (milestone) del RW 3.

Prueba de trabajo (PoW): Un algoritmo que evita la denegación de servicio (DoS) y los ataques de spam en una red. Un puzzle (rompecabezas) computacional difícil de resolver, pero fácil de verificar. IOTA usa un Hashcash basado en puzzle. o Min Weight Magnitude (MWM): La cantidad de trabajo que se llevará a cabo en la etapa PoW. esto significa que una solución al puzzle es un número con MWM antes de 0 (9 en trytes). Actualmente MWM se establece en 14 en el mainnet y 9 en el testnet, cada incremento de MWM es 3 veces más difícil PoW (en promedio).

Confirmaciones 





Estado de inclusión (Inclusion State): Se utiliza para determinar si una transacción fue aceptada y confirmada por la red. Más específicamente, dada una transacción y una lista de consejos (tips): El estado de inclusión es verdadero si el consejo hace referencia a esa transacción. o Hitos (Milestones): Transacciones de punto de control, emitidas cada minuto en promedio. o Pendiente: Una transacción está pendiente si la red la ha visto, pero aún no se ha confirmado. o Confirmado: una transacción se confirma si ha sido referenciada por un hito, es decir, el estado de inclusión de la transacción (y el último hito como sugerencia) es verdadero.

Retransmisión (Rebroadcast): Reenvía los trytes sin procesar de una transacción. Como los bundles son atómicos, si falta por confirmar una transacción de un bundle, esta misma no se confirmará. En caso de que esté enviando bundles largos, la retransmisión podría ayudar a la confirmación. Si un paquete no aparece en un explorador, entonces retransmitirlo también puede ayudar.

Volver a vincular (Reattach): Toma la firma y la información de transferencia del paquete, y lo vuelve a conectar al Tangle selecciona nuevos tips y hace un PoW. En caso de que su transferencia no se confirme después de un tiempo, aproximadamente 30 minutos, volver a vincularla podría ayudar a que se confirme.

Preguntas Frecuentes ¿IOTA es inflacionario? ¿Puedo minar IOTA?

Todos los IOTA que alguna vez existirán han sido creados con la transacción génesis. Esto significa que el suministro total de IOTA siempre será el mismo y no podrá "minar" IOTA. Por lo tanto, tenga en cuenta que si usted realiza una Prueba de trabajo en IOTA no está generando nuevos tokens de IOTA, simplemente está verificando otras transacciones.

¿Cuál es el suministro total de IOTA?

El suministro total de IOTA es (3 ^ 33-1) / 2, lo que equivale a un número total de IOTA de 2.779.530.283.277.761. IOTA está diseñado específicamente para máquinas, por lo que este alto suministro hace que IOTA sea óptima para pequeñas nanotransacciones, manteniendo la eficiencia. También encaja muy bien en el valor MAX_SAFE_INTEGER en Javascript.

Whitepaper El Whitepaper de IOTA que describe la tecnología principal detrás de IOTA The Tangle - está disponible. Posee mayor detalle sobre la estructura y la seguridad de Tangle.

Versión oficial (ingles) http://iotatoken.com/IOTA_Whitepaper.pdf Versión en español: http://www.iotahispano.com/2017/11/14/explicando-un-pocoel-whitepaper-de-iota-version-en-espanol/

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

6

INSTALAR IRI Encontrar vecinos (Neighbors) Para ejecutar IRI y sincronizar con la red, necesita tener vecinos que deseen vincularse con usted. La forma más fácil y rápida de obtener vecinos es a través de nuestro Slack, donde puedes unirte al canal #nodesharing para encontrar vecinos.

Debe tenerse en cuenta que también debe compartir su propia IP y puerto con sus vecinos, ya que IOTA depende de la conexión mutua para el intercambio de datos. Si necesita ayuda, simplemente pregunte en el Slack.

Instalar IRI El repositorio oficial IRI Github se puede encontrar en: https://github.com/iotaledger/iri. Para instalar IRI, hay ciertos requisitos que deben considerarse. IRI solo funciona en arquitecturas de 64 bits.

Java 8u66 o superior (Oracle) En Windows, asegúrese de tener instalado Redistributable Update 3.

Microsoft Visual C ++ 2015

1. Instalar IRI La forma más fácil y rápida de obtener IRI es obtener la versión ya compilada de Github. Antes del lanzamiento oficial del exchange, prepararemos IRI en varios administradores de paquetes, por lo que podrá instalar y actualizar IRI más rápidamente.

Puede encontrar la versión compilada en la página de lanzamiento en Github: https://github.com/iotaledger/iri/releases 1.1. (Opcional) Compilar IRI Para compilar IRI por su cuenta requiere que instale Maven.

git clone https://github.com/iotaledger/iri cd iri mvn clean compile && mvn package Esto creará una carpeta de destino, en la que encontrará el .jar compilado (no el original) que puede usar.

2. Ejecutar IRI Ejecutar IRI es muy simple. java -jar iri.jar -p 14600 Esto iniciará el IRI en el puerto 14600. Para poder utilizar el IRI, deberá buscar vecinos (consulte la siguiente sección). Cabe señalar que IRI funciona con UDP y con TCP. Como tal, puede conectarse con sus vecinos con cualquiera de los protocolos. Para aprovechar al máximo IRI, también hemos creado un conjunto de flags (indicadores): Opción --port

Versión acotada -p

-neighbors

-n

--config

-c

--udpreceiverport --tcp-

-u -t

Descripción Esta es una opción obligatoria que define el puerto que se utilizará para enviar comandos API a su nodo.

Los vecinos con los que está conectado se agregarán a través de esta opción.

Archivo de configuración INI que se puede usar en lugar de las opciones de CLI. Ver más abajo.

Puerto del receptor UDP. El puerto estándar es 14600.

Puerto del receptor TCP.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

Ejemplo -p 14800

-n "udp://148.148.148.148:14265 tcp://[2001:db8:a0b:12f0::1]:1 4265"

-u 14800 -t 14800

7

receiverport --testnet --remote --remoteauth

--remotelimit-api

El puerto estándar es 15600.

Hace posible ejecutar IRI con el testnet de IOTA. Acceda remotamente a su nodo y envíe comandos API Requerir contraseña de autenticación para acceder de forma remota Requiere un nombre de usuario correcto: hashedpassword Excluir ciertas llamadas a API de que se pueda acceder de forma remota

--tesnet --remote --remote-auth iotatoken: iotatoken:LL9EZFNCHZCMLJLVUBCK JSWKFEXNYRHHMYS9XQLUZRDEKUUDOC MBMRBWJEMEDDXSDPHIGQULENCRVEYM O --remote-limit-api "attachToTangle, addNeighbors"

Una vez que haya iniciado satisfactoriamente IRI, se creará una carpeta de base de datos (ya sea mainnetdb o testnetdb).

2.1. Ejecutar IRI con el archivo .ini También puede proporcionar un archivo ini para almacenar su configuración de línea de comandos y actualizar fácilmente (especialmente los vecinos) si es necesario. Puede habilitarlo a través del indicador --config. Aquí hay un ejemplo de archivo INI: [IRI] PORT = 14700 UDP_RECEIVER_PORT = 14700 VECINOS = udp: //my.favorite.com: 15600 IXI_DIR = ixi HEADLESS = true DEBUG = true TESTNET = true DB_PATH = db

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

8

PROFUNDIZANDO IOTA Una Nota sobre Trinarios En este documento, a menudo escuchará la palabra basado en trinarios, que es una referencia a la estructura de datos única que se utiliza en IOTA. Cada vez que nos referimos a seed, direcciones, hash, etc., basados en trinarios, significa que la cadena solo puede estar compuesta por caracteres en el alfabeto latino y el número 9. // Todos los posibles valores tryte var trytesAlphabet = "9ABCDEFGHIJKLMNOPQRSTUVWXYZ" Debido a la forma en que funciona Kerl, un solo hash siempre consiste en 81trytes (81 caracteres); a veces puede ser 90-trytes (incluida la suma de comprobación 9-tryte).

Trytes válidos: VBVEUQY Trytes inválidos: Vaafd8432

Seeds, Llaves Privadas y Cuentas Seeds y Cuentas El punto de partida para todo es una seed. Para crear una cuenta con claves privadas y direcciones, debe tener una seed segura. La misma consiste en 81trytes (o menos, que no se recomienda), está es su clave de acceso única para su cuenta y, por lo tanto, sus fondos. La seed debe almacenarse de forma segura. Aquí puede encontrar una recomendación para generar una seed de forma segura.

En IOTA, le ofrecemos 3 niveles de seguridad para elegir. Un nivel de seguridad determina el número de rondas para el hashing, lo que significa que una sola seed puede tener 3 cuentas diferentes.

Nivel de seguridad 1 2 3

Seguridad 81-trits (bajo) 162 trits (medianos) 243-trits (alto)

Se recomienda que el nivel 3 (seguridad de 243 trits) sea utilizado para todos los intercambios. Las bibliotecas (libs) de cliente permiten cambiar fácilmente y elegir un nivel de seguridad.

Claves privadas y direcciones Las claves privadas se derivan de un índice clave de la seed. De esa clave privada se genera una dirección. El índice clave que comienza en 0, se puede incrementar para obtener una nueva clave privada y, por lo tanto, dirigirla.

Es importante tener en cuenta que todas las funciones sensibles a la seguridad se implementan desde el lado del cliente. Lo que esto significa es que puede generar claves y direcciones privadas de forma segura en el navegador o en una computadora sin conexión a internet. Todas las bibliotecas proporcionan esta funcionalidad.

IOTA utiliza Winternitz one-time signature, por lo que debe asegurarse de saber qué clave privada (y qué dirección) ya se ha utilizado para no volver a utilizarla. Posteriormente, la reutilización de claves privadas puede conducir a la pérdida de fondos (un atacante puede falsificar la firma después de la reutilización continua). Como tal, nunca vuelva a utilizar llaves y direcciones privadas. Si está esperando que una transacción/paquete confirme, ¡vuelva a conectarlo (reattach) y nunca vuelva a usarlo!

NUNCA REUTILICE LAS DIRECCION Debido a que IOTA usa las firmas únicas de Winternitz, nunca debe volver a utilizar una dirección después de haberla usado para envíos de fondos. La reutilización continua de claves privadas otorga a un atacante la capacidad de falsificar las firmas, lo que le permite robar fondos de la dirección respectiva.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

9

Puede encontrar un tutorial sobre claves privadas y direcciones aquí: http://learn.iota.org/tutorial/generating-addresses-learn-the-basics

Anatomía de una transacción Una transacción en IOTA consta de 2673 trytes (si está codificada). Cuando se decodifica los trytes, se obtiene un objeto de transacción que tiene los siguientes valores: Campo

Descripción

Tipo

Longitud (Si es cadena)

address

En caso de que este sea de salida, esta es la dirección del destinatario. En caso de que sea una entrada, entonces es la dirección de quien la utiliza para enviar los tokens (es decir, la dirección generada a partir de la clave privada)

String

27-trytes

attachmentTimestamp

Timestamp después del POW

Int

attachmentTimestampLowerBound

Lower Bound de timestamp

Int

attachmentTimestampUpperBound

Upper bound de timestamp

Int

branchTransaction

Transacción siendo aprobada

String

81-trytes

bundle

Bundle hash, que se utiliza para agrupar las transacciones de un paquete. Con el bundlehash se puede identificar transacciones que estaban en el mismo paquete.

String

81-trytes

currentIndex

Index actual dentro del bundle

Int

hash

Transaction hash

String

lastIndex

Ultimo index del bundle

Int

nonce

El nonce es requerido para que la transacción sea aceptada por la red. Se genera haciendo Prueba de trabajo (ya sea en IRI a través de la llamada a la API attachToTangle, o con una de las bibliotecas como ccurl).

String

27-trytes

obsoleteTag

Etiqueta definida por el usuario (pronto será eliminada)

String

27-trytes

signatureMessageFragment

Fragmento de mensaje firmado. En caso de que haya una entrada gastada, la firma de la clave privada se almacena aquí. Si no se requiere firma, está vacía (todos los 9) y se puede usar para almacenar el valor del mensaje cuando se realiza una transferencia. Más información de esto más adelante.

String

2187trytes

tag

Etiqueta definida por el usuario

String

27-trytes

timestamp

Timestamp (no aplicado, puede ser arbitrario)

Int

trunkTransaction

Transacción siendo aprobada

String

value

Valor de la transacción

Int

Los clientes principales codifican todos estos datos en trytes y los almacenan como una cadena de 2673-trytes. Para leer estos datos, deberá decodificarlos/codificarlos con las funciones de la biblioteca del cliente.

Aquí hay un ejemplo de cómo es una transacción en formato raw (sin procesar) trytes: SE SEGUIRA ACTUALIZANDO Y aquí está el mismo objeto de transacción (puede intentar y convertirlo usted mismo, con iota.utils.transactionObject en la biblioteca Javascript): SE SEGUIRA ACTUALIZANDO

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

10

81-trytes

81-trytes

Bundles (paquetes) IOTA usa un esquema similar a una cuenta. Esto significa que tenemos entradas (direcciones) que debe gastar para transferir tokens. Las direcciones se generan a partir de claves privadas, que a su vez se derivan de una seed codificada por trytes. Una transferencia en IOTA es un bundle que consiste en salidas y entradas. Los paquetes son transferencias atómicas, lo que significa que todas las transacciones dentro del bundle serán aceptadas por la red, o ninguna. Una transferencia típica en IOTA es un bundle que consta de 4 transacciones: Index

Propósito

Valor

0

Salida. Destinatario de la transacción

>0 (como lo define el usuario)

1

Primera entrada de paquete que pasa la totalidad de la dirección de entrada. Esta entrada del paquete también contiene la primera parte de la firma (en el caso de ejemplo, será la primera mitad de la firma de Alice)

<0 (gasto de entrada)

2

Segunda mitad de la firma de Alice.

0

3

Salida. Si hay un remanente (Alicia no gastó su saldo completo en el índice de clave respectivo), se enviará a una dirección remanente.

>0 (entradasalida)

Una característica única de los paquetes es que las transacciones se identifican a través del hash bundle, pero también a través de trunkTransaction. Lo que esto significa es que la transacción de cola (tail transacction - currentIndex: 0) hace referencia en el trunkTransaction al hash de transacción en el índice: 1, la transacción de currentIndex 1 hace referencia (y aprueba) el índice 2, y así sucesivamente. Esto hace posible obtener el conjunto completo de transacciones de solo una transacción final al desplazarse por la trunk transaction.

Una sola transacción puede contener múltiples entradas y salidas.

Haciendo un Transacción Como se mencionó anteriormente, en IOTA no hay mineros. Como tal, el proceso de hacer una transacción es diferente de cualquier Blockchain que hay hoy en día. El proceso en IOTA se ve de la siguiente manera: 1. Firma: Firmas las entradas de la transacción con tus claves privadas.

Esto se puede hacer sin conexión.

2. Selección de sugerencia (Tip selection): MCMC se utiliza para seleccionar aleatoriamente dos tips, a las que se hará referencia en su transacción (branchTransaction y trunkTransaction) 3. Prueba de Trabajo: para que su transacción sea aceptada por la red, debe realizar una Prueba de Trabajo, similar a Hashcash, no a Bitcoin (spam y sybil-resistence). Esto generalmente toma unos minutos en una PC moderna.

Después de que esto se complete, trunkTransaction, branchTransaction y nonce del objeto transacción deben actualizarse. Esto significa que puede transmitir la transacción a la red ahora y esperar a que otra persona la apruebe.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

11

INSTALAR IGU Como instalar Actualmente, la mejor manera de usar IOTA es a través de nuestro cliente IGU (interfaz gráfica de usuario, GUI del inglés Graphic User Interface). El cliente facilita la configuración rápida en todos los principales sistemas operativos. La desventaja es que esto hace que sea difícil ejecutar IOTA en dispositivos IoT más pequeños en este momento. Esto cambiará una vez que pueda compilar desde la fuente (dentro de 1 a 2 semanas).

Descargue el cliente Puede descargar el último cliente desde https://github.com/iotaledger/wallet/releases. Descargue la versión respectiva para su sistema operativo.

REQUISITO DE JAVA Todas las instalaciones requieren Java superior a 8u66. Asegúrese de tenerlo instalado, de lo contrario, el cliente IGU puede instalarlo automáticamente.

Compilando desde la fuente Si desea instalar la IGU desde el código fuente, siga las instrucciones en el archivo Léame en Github.

Instalación en Windows Después de haber descargado el archivo .exe de nuestro repositorio de Github, vaya a la carpeta Descargar y haga doble clic en el ejecutable. Después de eso, debería ver una pantalla de instalación, espere hasta que termine.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

12

Una vez que se completa la instalación, la aplicación se abrirá automáticamente y creará un acceso directo en el escritorio.

.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

13

Instalación en Mac OS X Después de haber descargado el archivo .dmg de nuestro repositorio de Github, diríjase a la carpeta Descargar y haga clic en el archivo .dmg. Debería ver una carpeta como a continuación. Arrastre el ícono IOTA Wallet a la carpeta Aplicaciones.

Una vez que haya arrastrado el IOTA Wallet en la carpeta de aplicaciones, diríjase a la carpeta Aplicaciones y haga clic con el botón derecho en IOTA Wallet y haga clic en "Abrir".

Después de eso, verá una alerta de seguridad. Haga clic en "Abrir".

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

14

Configuración de seguridad de Mac OSX

Asegúrese de que la configuración de seguridad de Mac OSX esté configurada para "Permitir aplicaciones descargadas desde: Mac App Store y desarrolladores identificados. Si desea cambiar a la cabeza a Preferencias del sistema -> Seguridad y privacidad. Luego puede cambiarlo.

Después de eso, debería ver su aplicación IOTA ejecutándose con éxito.

Felicitaciones! Ahora está conectado correctamente a la red y está ejecutando su nodo.

Actualización de Java

Si está utilizando una versión anterior de Java, la IGU le solicitara que actualice a Java 8. Puede actualizar automáticamente su versión de Java a través de la IGU.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

15

Instalación en Linux Para Linux hay varios paquetes diferentes que puede usar para instalar la IGU de IOTA. De forma más destacada, Debian, RedHat, los archivos tar, así como las AppImages recientemente provistas. Descargue su paquete de preferencia para su SO y luego siga las sencillas instrucciones de instalación.

Paquete Debian Una vez que haya descargado el paquete, vaya a la carpeta Descargar y haga doble clic en el paquete.

Luego serás llevado al Centro de Software de Ubuntu. Continúe con el proceso de instalación haciendo clic en "Instalar".

Si se le solicita autenticación, ingrese su contraseña.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

16

Una vez completado, debería ver que la billetera de IOTA se instaló correctamente.

Ahora deberías tenerlo en tu carpeta de aplicaciones.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

17

Nodo Light vs Nodo Full La billetera IGU permite usarla como una billetera ligera (Light wallet) o como una billetera completa (Full wallet). Si se usa como lightwallet, básicamente está interactuando con su nodo full alojado o con el nodo completo de un tercero (a menudo denominado "proveedor de billetera liviana").

Cabe señalar que todas las funciones confidenciales (como el hash y la firma) ocurren en el lado del cliente. Esto significa que si usted interactúa con un proveedor de billetera liviana, su seed o sus llaves privadas nunca abandonan su posesión y el proveedor de billetera liviana no puede robar sus fondos. Sin embargo, cuando se interactúa con un tercero, se debe tener en cuenta que hay diferentes suposiciones de seguridad relacionadas con eso, especialmente cuando se realizan llamadas a la API relacionadas con el estado (como getBalance y getInclusionStates). Si su uso requiere alta seguridad, asegúrese de usar un quórum de proveedores de lightwallet.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

18

DOCUMENTACIÓN DE LA API DEL IRI Introducción a la API El cliente IOTA Java hace posible interactuar con su nodo local y solicitar cierta información o acciones a tomar. Una vez que su nodo se haya configurado correctamente, puede hacer interfaz con él a través del puerto 14265 pasando un objeto JSON que contenga un comando específico; y luego de la ejecución exitosa del comando, devuelve la información solicitada.

La principal prioridad tal, todo lo que tiene lado del cliente. Para encargan de esto, pero mismo.

de la API, así como IRI en sí es la seguridad. Como que ver con las claves privadas se realiza desde el esto, hemos proporcionado varias bibliotecas que se también puede implementar esta funcionalidad usted

Para su comodidad, hemos agregado ejemplos concretos sobre cómo usar la API en Curl, Python y NodeJS. Si está utilizando Javascript, simplemente puede seguir usando XMLHttpRequest o jQuery. Para NodeJS, instale el paquete de solicitudes npn, ya que todos nuestros ejemplos requieren el paquete de solicitudes.

Para el resto de esta documentación, se supone que tiene el cliente IOTA ejecutándose en el puerto 14265 (o un puerto de su elección, cambie sus solicitudes en consecuencia).

Realizando peticiones Todas las llamadas API deben enviarse a http://localhost:14265 (si está utilizando el puerto estándar) a través de una solicitud HTTP POST. Los datos que se enviarán son un objeto JSON que sigue el mismo esquema estándar de:

{‘command': 'SUCOMANDOAQUI’} Los parámetros adicionales simplemente se agregan como pares adicionales clave-valor. Si el comando se ejecuta con éxito, la información solicitada se devuelve como un objeto o como un objeto codificado (use json.parse o equivalente para convertirlo en un objeto).

Al realizar una solicitud, asegúrese de que la biblioteca HTTP que está utilizando defina la longitud del contenido de los datos que se enviarán. Si esto no se hace automáticamente, agréguelo manualmente a través de un campo del encabezado, e.j. 'Content-Length': Buffer.byteLength (JSON.stringify (comando)).

Los ejemplos están desarrollados en Python si desea ver en otros lenguajes por favor diríjase a: https://iota.readme.io/v1.2.0/reference

Referencias de la API getNodeInfo

:: Devuelve información de su nodo.

Parámetros:  Command (string) – Requerido.

Ejemplo en Python import urllib2 import json command = { 'command': 'getNodeInfo' } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

19

jsonData = json.loads(returnData) print jsonData Salida: { "appName": "IRI", "appVersion": "1.0.8.nu", "duration": 1, "jreAvailableProcessors": 4, "jreFreeMemory": 91707424, "jreMaxMemory": 1908932608, "jreTotalMemory": 122683392, "latestMilestone": "VBVEUQYE99LFWHDZRFKTGFHYGDFEAMAEBGUBTTJRFKHCFBRTXFAJQ9 XIUEZQCJOQTZNOOHKUQIKOY9999", "latestMilestoneIndex": 107, "latestSolidSubtangleMilestone": "VBVEUQYE99LFWHDZRFKTGFHYGDFEAMAEBGUBTTJR FKHCFBRTXFAJQ9XIUEZQCJOQTZNOOHKUQIKOY9999", "latestSolidSubtangleMilestoneIndex": 107, "neighbors": 2, "packetsQueueSize": 0, "time": 1477037811737, "tips": 3, "transactionsToRequest": 0 } Valores de salida:



appName: Nombre del software IOTA que está utilizando en el momento (IRI significa Implementación de Referencia Inicial).



appVersion: La versión del software IOTA que está ejecutando actualmente.



jreAvailableProcesses: Núcleos disponibles en su máquina para JRE.



jreFreeMemory: Devuelve la cantidad de memoria libre en la máquina virtual Java.



jreMaxMemory: Devuelve la cantidad máxima de memoria que intentará usar la máquina virtual Java.



jreTotalMemory: Devuelve la cantidad total de memoria en la máquina virtual Java.



latestMilestone: El último hito (milestone) que firmó el coordinador.



latestMilestoneIndex: Índice del último hito.



latestSolidSubtangleMilestone: El último hito que es sólido y se utiliza para enviar transacciones. Para que un hito sea sólido, su nodo local básicamente debe aprobar el subnivel de las transacciones aprobadas por el coordinador y tener una vista coherente de todas las transacciones a las que se hace referencia.



latestSolidSubtangleMilestoneIndex: Índice del último subtangle sólido.



neighbors: Número de vecinos con los que está conectado directamente.



packetsQueueSize: Paquetes que están actualmente en cola.



time: Marca de tiempo UNIX actual.



tips: Número de sugerencias en la red.



transactionsToRequest: Transacciones para solicitar durante el proceso de sincronización.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

20

getNeighbors

:: Devuelve el conjunto de vecinos con los que está conectado, así como su recuento de actividades. El contador de actividad se restablece después de reiniciar IRI. Parámetros:  Command (string) – Requerido.

Ejemplo en Python import urllib2 import json command = { 'command': 'getNeighbors' } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { "duration": 37, "neighbors": [ { "address": "/8.8.8.8:14265", "numberOfAllTransactions": 922, "numberOfInvalidTransactions": 0, "numberOfNewTransactions": 92 }, { "address": "/8.8.8.8:5000", "numberOfAllTransactions": 925, "numberOfInvalidTransactions": 0, "numberOfNewTransactions": 20 } ] } Valores de salida: • address: Dirección de tu vecino.

• numberOfAllTransactions: Número de todas las transacciones enviadas (no válidas, válidas, ya vistas) • numberOfInvalidTransactions: Número de transacciones no válidas que le ha enviado su vecino. Estas son transacciones con firmas no válidas o esquema general.

• numberOfNewTransactions: Nuevas transacciones que se transmitieron.

addNeighbors

:: Agregue una lista de vecinos a su nodo. Se debe tener en cuenta que esto es solo temporal y los vecinos adicionales se eliminarán de su conjunto de vecinos después de reiniciar IRI. El URI (Identificación Única de Recursos) para agregar vecinos es: udp://IPADDRESS:PUERTO Parámetros:  Command (string) – Requerido.  Uris (Array de String) – Requerido – Lista de elementos URI.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

21

Ejemplo en Python import urllib2 import json command = { 'command': 'addNeighbors', 'uris': ['udp://8.1.8.8:14265', 'udp://8.8.2.5:14265'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { "addedNeighbors": 0, "duration": 2 }

removeNeighbors

:: Elimina una lista de vecinos de su nodo. Esto es solo temporal, y si tiene sus vecinos agregados a través de la línea de comando, se conservarán después de que reinicie su nodo.

El URI (Identificación Única de Recursos) para eliminar vecinos es: udp://IPADDRESS:PUERTO Parámetros:  Command (string) – Requerido.  Uris (Array de String) – Requerido – Lista de elementos URI. Ejemplo en Python import urllib2 import json command = { 'command': 'removeNeighbors', 'uris': ['udp://8.1.8.8:14265', 'udp://8.8.2.5:14265'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { "removedNeighbors": 0, "duration": 2 }

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

22

getTips

:: Devuelve la lista de tips.

Parámetros:  Command (string) – Requerido.

Ejemplo en Python import urllib2 import json command = { 'command': 'getTips' } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { "hashes": ["YVXJOEOP9JEPRQUVBPJMB9MGIB9OMTIJJLIUYPM9YBIWXPZ9PQCCGXYSLKQWKHBRVA9AKKKXXM XF99999", "ZUMARCWKZOZRMJM9EEYJQCGXLHWXPRTMNWPBRCAGSGQNRHKGRUCIYQDAEUUEBRDBNBY HAQSSFZZQW9999", "QLQECHDVQBMXKD9YYLBMGQLLIQ9PSOVDRLYCLLFMS9O99XIKCUHWAFWSTARY NCPAVIQIBTVJROOYZ9999"], "duration": 4 } Valores de Salida:

findTransactions

:: Encuentra las transacciones que coinciden con la entrada

especificada y las devuelve. Todos los valores de entrada son listas, para las cuales se devuelve una lista de valores (hashes de transacción), en el mismo orden, para todos los elementos individuales. Los campos de entrada pueden ser bundles, direcciones, tags o aprobaciones. El uso de múltiples de estos campos de entrada devuelve la intersección de los valores.

Parámetros

Tipos

Requerido

Descripción

paquetes

Lista

Opcional

List of bundle hashes. The hashes needs to be extended to 81 trytes by padding the hash with 9's.

direcciones

Lista

Opcional

Lista de direcciones

tags

Lista

Opcional

Lista de tags. Tiene que ser 27 trytes.

aprobaciones

Lista

Opcional

Lista de hashes de transacciones aprobadas.

Parámetros:  Command (string) – Requerido.  Bundles (Array de Strings) - Lista de hash de paquetes. Los hashes deben extenderse a 81 caracteres rellenando el hash con 9 (nueves).

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

23

Ejemplo en Python import urllib2 import json command = { 'command': 'findTransactions', 'addresses': ['RVORZ9SIIP9RCYMREUIXXVPQIPHVCNPQ9HZWYKFWYWZRE9JQKG9REPKIASH UUECPSQO9JT9XNMVKWYGVAZETAIRPTM'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { hashes: [ 'ZJVYUGTDRPDYFGFXMKOTV9ZWSGFK9CFPXTITQLQNLPPG9YNAARMKNKYQO9GSCSBIOTGMLJUFL ZWSY9999' ] } Valores de Salida: Los hashes de transacción que se devuelven dependen de su entrada. Para cada valor de entrada especificado, el comando devolverá lo siguiente: • paquetes: devuelve la lista de transacciones que contienen el hash de paquete especificado.

• direcciones: devuelve la lista de transacciones que tienen la dirección especificada como un campo de entrada / salida.

• etiquetas: devuelve la lista de transacciones que contienen el valor de etiqueta especificado.

• approvees: devuelve la lista de transacción que hace referencia (es decir, confirma) la transacción especificada.

getTrytes

:: Devuelve los datos de transacción sin procesar (trytes) de una transacción específica. Estos trytes se pueden convertir fácilmente en el objeto de transacción real. Ver funciones de utilidad para más detalles.

Parámetros:  Command (string) – Requerido.  Hashes (Array de String) - Requerido - Lista de hash de transacción de los trytes que desea obtener.

Ejemplo en Python import urllib2 import json command = { 'command': 'getTrytes', 'hashes': ['OAATQS9VQLSXCLDJVJJVYUGONXAXOFMJOZNSYWRZSWECMXAQQURHQBJNLD9IOF EPGZEPEMPXCIVRX9999'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

24

returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { trytes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}

getInclusionStates

:: Obtiene los estados de inclusión de un conjunto de transacciones. Esto es para determinar si una transacción fue aceptada y confirmada por la red o no. Puede buscar múltiples tips (y por lo tanto, hitos) para pasar los estados de inclusión de las transacciones.

Esta llamada a API simplemente devuelve una lista de valores booleanos en el mismo orden que la lista de transacciones que envió, por lo tanto, obtiene un verdadero / falso, ya sea que se confirme o no una transacción.

Parámetros:  Command (string) – Requerido.  Transactions (Array de Strings) – Requerido – Lista de transacciones para las que desea obtener el estado de inclusión.  Tips (Array de Strings) – Requerido - Lista de sugerencias (incluidos hitos) en las que desea buscar el estado de inclusión.

Ejemplo en Python import urllib2 import json command = { 'command': 'getInclusionStates', 'transactions': ['QHBYXQWRAHQJZEIARWSQGZJTAIITOZRMBFICIPAVD9YRJMXFXBDPFDTR AHHHP9YPDUVTNOFWZGFGWMYHEKNAGNJHMW'], 'tips': ['ZIJGAJ9AADLRPWNCYNNHUHRRAC9QOUDATEDQUMTNOTABUVRPTSTFQDGZKFYUUIE9 ZEBIVCCXXXLKX9999'] } stringified = json.dumps(command) Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

25

headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { "states": [true], "duration": 91 }

getBalances

:: Similar a getInclusionStates. Devuelve el saldo confirmado que tiene una lista de direcciones en el último hito confirmado. Además de los saldos, también devuelve el hito así como también el índice con el que se determinó el saldo confirmado. Los saldos se devuelven como una lista en el mismo orden en que se proporcionaron las direcciones como entrada.

Parámetros:  Command (string) – Requerido.  Addresses (Array de String) – Requerido – Lista de direcciones de las que desea obtener el saldo confirmado  Threshold (int32) – Requerido - El umbral de confirmación, es recomendable establecerse en 100.

Ejemplo en Python import urllib2 import json command = { 'command': 'getBalances', 'addresses': ['HBBYKAKTILIPVUKFOTSLHGENPTXYBNKXZFQFR9VQFWNBMTQNRVOUKPVPRNB SZVVILMAFBKOTBLGLWLOHQ'], 'threshold': 100 } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: "balances": [ "114544444" ], "duration": 30, "milestone": "INRTUYSZCWBHGFGGXXPWRWBZACYAFGVRRP9VYEQJOHYD9URMELKWAFYFMNTS P9MCHLXRGAFMBOZPZ9999", "milestoneIndex": 128 }

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

26

Valores de Salida:

getTransactionsToApprove

:: Selección de tips que devuelve trunkTransaction y branchTransaction. El valor de entrada es la profundidad (depth), que básicamente determina cuántos paquetes a devolver para determinar las transacciones para aprobar. Cuanto mayor sea su valor de profundidad, más cuidadoso sera parala red (ya que debe confirmar más transacciones).

Parámetros:  Command (string) – Requerido.  depth (int32) - Requerido - Número de paquetes a devolver para determinar las transacciones para su aprobación.  Ejemplo en Python import urllib2 import json command = { 'command': 'getTransactionsToApprove', 'depth': 27 } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { "trunkTransaction": "TKGDZ9GEI9CPNQGHEATIISAKYPPPSXVCXBSR9EIWCTHHSSEQCD9YLDP EXYERCNJVASRGWMAVKFQTC9999", "branchTransaction": "TKGDZ9GEI9CPNQGHEATIISAKYPPPSXVCXBSR9EIWCTHHSSEQCD9YLD PEXYERCNJVASRGWMAVKFQTC9999", "duration": 936 }

attachToTangle

:: Adjunta (attach) las Tangle al hacer una Prueba de Trabajo. trunkTransaction (básicamente los tips transacción), que obtendrá a través de API.

transacciones especificadas (trytes) al Debe proporcionar branchTransaction y que va a validar y referenciar con esta la llamada getTransactionsToApprove

El valor devuelto es un conjunto diferente de valores tryte que puede ingresar en broadcastTransactions y storeTransactions. El valor de tryte devuelto, los últimos 243 trytes consisten básicamente en: trunkTransaction + branchTransaction + nonce. Estos son trytes válidos que luego son aceptados por la red.

Parámetros:  Command (string) – Requerido.  trunkTransaction (String) – Requerido - Transacción Trunk para aprobar.  branchTransaction (String) – Requerido – Transacciòn Branch para aprobar.  minWeightMagnitude (int32) – Requerido - Intensidad de Prueba de Trabajo. El valor minimo es 18.  Trytes (Array de String) - Requerido - Lista de trytes (datos de transacción sin procesar) para adjuntar al Tangle.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

27

Ejemplo en Python import urllib2 import json command = { 'command': 'attachToTangle', 'trunkTransaction': 'JVMTDGDPDFYHMZPMWEKKANBQSLSDTIIHAYQUMZOKHXXXGJHJDQPOM DOMNRDKYCZRUFZROZDADTHZC9999', 'branchTransaction': 'P9KFSJVGSPLXAEBJSHWFZLGP9GGJTIO9YITDEHATDTGAFLPLBZ9F OFWWTKMAZXZHFGQHUOXLXUALY9999', 'minWeightMagnitude': 18, 'trytes': ['TRYTVALUEHERE'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: { 'trytes':['TRYTEVALUEHERE'] }

interruptAttachingToTangle

:: Interrumpe y cancela por completo el proceso de

attachToTangle.

Parámetros:  Command (string) – Requerido.

Ejemplo en Python import requests url = "http://localhost:14265/" response = requests.request("POST", url) print(response.text) Salida: Sin salida.

broadcastTransactions

:: Transmite una lista de transacciones a todos los vecinos. Los intentos de entrada para esta llamada son provistos por attachToTangle.

Parámetros:  Command (string) – Requerido.  Trytes (Array de String) – Requerido - Lista de datos sin procesar de transacciones para ser retransmitidos.

Ejemplo en Python import urllib2 import json command = { 'command': 'broadcastTransactions', 'trytes': ['BYSWEAUTWXHXZ9YBZISEK9LUHWGMHXCGEVNZHRLUWQFCUSDXZHOFHWHL9MQPVJ XXZLIXPXPXF9KYEREFSKCPKYIIKPZVLHUTDFQKKVVBBN9ATTLPCNPJDWDEVIYYLGPZGCWXOBDXMLJC 9VO9QXTTBLAXTTBFUAROYEGQIVB9MJWJKXJMCUPTWAUGFZBTZCSJVRBGMYXTVBDDS9MYUJCPZ9YDWW QNIPUAIJXXSNLKUBSCOIJPCLEFPOXFJREXQCUVUMKSDOVQGGHRNILCO9GNCLWFM9APMNMWYASHXQAY BEXF9QRIHIBHYEJOYHRQJAOKAQ9AJJFQ9WEIWIJOTZATIBOXQLBMIJU9PCGBLVDDVFP9CFFSXTDUXM EGOOFXWRTLFGV9XXMYWEMGQEEEDBTIJ9OJOXFAPFQXCDAXOUDMLVYRMRLUDBETOLRJQAEDDLNVIRQJ Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

28

UBZBO9CCFDHIX9MSQCWYAXJVWHCUPTRSXJDESISQPRKZAFKFRULCGVRSBLVFOPEYLEE99JD9SEBALQ INPDAZHFAB9RNBH9AZWIJOTLBZVIEJIAYGMC9AZGNFWGRSWAXTYSXVROVNKCOQQIWGPNQZKHUNODGY ADPYLZZZUQRTJRTODOUKAOITNOMWNGHJBBA99QUMBHRENGBHTH9KHUAOXBVIVDVYYZMSEYSJWIOGGX ZVRGN999EEGQMCOYVJQRIRROMPCQBLDYIGQO9AMORPYFSSUGACOJXGAQSPDY9YWRRPESNXXBDQ9OZO XVIOMLGTSWAMKMTDRSPGJKGBXQIVNRJRFRYEZ9VJDLHIKPSKMYC9YEGHFDS9SGVDHRIXBEMLFIINOH VPXIFAZCJKBHVMQZEVWCOSNWQRDYWVAIBLSCBGESJUIBWZECPUCAYAWMTQKRMCHONIPKJYYTEGZCJY CT9ABRWTJLRQXKMWY9GWZMHYZNWPXULNZAPVQLPMYQZCYNEPOCGOHBJUZLZDPIXVHLDMQYJUUBEDXX PXFLNRGIPWBRNQQZJSGSJTTYHIGGFAWJVXWL9THTPWOOHTNQWCNYOYZXALHAZXVMIZE9WMQUDCHDJM IBWKTYH9AC9AFOT9DPCADCV9ZWUTE9QNOMSZPTZDJLJZCJGHXUNBJFUBJWQUEZDMHXGBPTNSPZBR9T GSKVOHMOQSWPGFLSWNESFKSAZY9HHERAXALZCABFYPOVLAHMIHVDBGKUMDXC9WHHTIRYHZVWNXSVQU WCR9M9RAGMFEZZKZ9XEOQGOSLFQCHHOKLDSA9QCMDGCGMRYJZLBVIFOLBIJPROKMHOYTBTJIWUZWJM CTKCJKKTR9LCVYPVJI9AHGI9JOWMIWZAGMLDFJA9WU9QAMEFGABIBEZNNAL9OXSBFLOEHKDGHWFQSH MPLYFCNXAAZYJLMQDEYRGL9QKCEUEJ9LLVUOINVSZZQHCIKPAGMT9CAYIIMTTBCPKWTYHOJIIY9GYN PAJNUJ9BKYYXSV9JSPEXYMCFAIKTGNRSQGUNIYZCRT9FOWENSZQPD9ALUPYYAVICHVYELYFPUYDTWU SWNIYFXPX9MICCCOOZIWRNJIDALWGWRATGLJXNAYTNIZWQ9YTVDBOFZRKO9CFWRPAQQRXTPACOWCPR LYRYSJARRKSQPR9TCFXDVIXLP9XVL99ERRDSOHBFJDJQQGGGCZNDQ9NYCTQJWVZIAELCRBJJFDMCNZ U9FIZRPGNURTXOCDSQGXTQHKHUECGWFUUYS9J9NYQ9U9P9UUP9YMZHWWWCIASCFLCMSKTELZWUGCDE 9YOKVOVKTAYPHDF9ZCCQAYPJIJNGSHUIHHCOSSOOBUDOKE9CJZGYSSGNCQJVBEFTZFJ9SQUHOASKRR GBSHWKBCBWBTJHOGQ9WOMQFHWJVEG9NYX9KWBTCAIXNXHEBDIOFO9ALYMFGRICLCKKLG9FOBOX9PDW NQRGHBKHGKKRLWTBEQMCWQRLHAVYYZDIIPKVQTHYTWQMTOACXZOQCDTJTBAAUWXSGJF9PNQIJ9AJRU MUVCPWYVYVARKR9RKGOUHHNKNVGGPDDLGKPQNOYHNKAVVKCXWXOQPZNSLATUJT9AUWRMPPSWHSTTYD FAQDXOCYTZHOYYGAIM9CELMZ9AZPWB9MJXGHOKDNNSZVUDAGXTJJSSZCPZVPZBYNNTUQABSXQWZCHD QSLGK9UOHCFKBIBNETK99999999999999999999999999999999999999999999999999999999999 9999999999999999999999NOXDXXKUDWLOFJLIPQIBRBMGDYCPGDNLQOLQS99EQYKBIU9VHCJVIPFU YCQDNY9APGEVYLCENJIOBLWNB999999999XKBRHUD99C99999999NKZKEKWLDKMJCI9N9XQOLWEPAY WSH9999999999999999999999999KDDTGZLIPBNZKMLTOLOXQVNGLASESDQVPTXALEKRMIOHQLUHD9 ELQDBQETS9QFGTYOYWLNTSKKMVJAUXSIROUICDOXKSYZTDPEDKOQENTJOWJONDEWROCEJIEWFWLUAA CVSJFTMCHHXJBJRKAAPUDXXVXFWP9X9999IROUICDOXKSYZTDPEDKOQENTJOWJONDEWROCEJIEWFWL UAACVSJFTMCHHXJBJRKAAPUDXXVXFWP9X9999'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: Sin salida.

storeTransactions

:: Almacena transacciones en el almacenamiento local. Los trytes que se utilizarán para esta llamada los devuelve attachToTangle.

Parámetros:  Command (string) – Requerido.  Trytes (Array de String) – Requerido - Lista de datos sin procesar de transacciones para ser retransmitidos.

Ejemplo en Python import urllib2 import json command = { 'command': 'storeTransactions', 'trytes': ['BYSWEAUTWXHXZ9YBZISEK9LUHWGMHXCGEVNZHRLUWQFCUSDXZHOFHWHL9MQPVJ XXZLIXPXPXF9KYEREFSKCPKYIIKPZVLHUTDFQKKVVBBN9ATTLPCNPJDWDEVIYYLGPZGCWXOBDXMLJC 9VO9QXTTBLAXTTBFUAROYEGQIVB9MJWJKXJMCUPTWAUGFZBTZCSJVRBGMYXTVBDDS9MYUJCPZ9YDWW QNIPUAIJXXSNLKUBSCOIJPCLEFPOXFJREXQCUVUMKSDOVQGGHRNILCO9GNCLWFM9APMNMWYASHXQAY BEXF9QRIHIBHYEJOYHRQJAOKAQ9AJJFQ9WEIWIJOTZATIBOXQLBMIJU9PCGBLVDDVFP9CFFSXTDUXM EGOOFXWRTLFGV9XXMYWEMGQEEEDBTIJ9OJOXFAPFQXCDAXOUDMLVYRMRLUDBETOLRJQAEDDLNVIRQJ UBZBO9CCFDHIX9MSQCWYAXJVWHCUPTRSXJDESISQPRKZAFKFRULCGVRSBLVFOPEYLEE99JD9SEBALQ INPDAZHFAB9RNBH9AZWIJOTLBZVIEJIAYGMC9AZGNFWGRSWAXTYSXVROVNKCOQQIWGPNQZKHUNODGY ADPYLZZZUQRTJRTODOUKAOITNOMWNGHJBBA99QUMBHRENGBHTH9KHUAOXBVIVDVYYZMSEYSJWIOGGX ZVRGN999EEGQMCOYVJQRIRROMPCQBLDYIGQO9AMORPYFSSUGACOJXGAQSPDY9YWRRPESNXXBDQ9OZO XVIOMLGTSWAMKMTDRSPGJKGBXQIVNRJRFRYEZ9VJDLHIKPSKMYC9YEGHFDS9SGVDHRIXBEMLFIINOH VPXIFAZCJKBHVMQZEVWCOSNWQRDYWVAIBLSCBGESJUIBWZECPUCAYAWMTQKRMCHONIPKJYYTEGZCJY CT9ABRWTJLRQXKMWY9GWZMHYZNWPXULNZAPVQLPMYQZCYNEPOCGOHBJUZLZDPIXVHLDMQYJUUBEDXX PXFLNRGIPWBRNQQZJSGSJTTYHIGGFAWJVXWL9THTPWOOHTNQWCNYOYZXALHAZXVMIZE9WMQUDCHDJM Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

29

IBWKTYH9AC9AFOT9DPCADCV9ZWUTE9QNOMSZPTZDJLJZCJGHXUNBJFUBJWQUEZDMHXGBPTNSPZBR9T GSKVOHMOQSWPGFLSWNESFKSAZY9HHERAXALZCABFYPOVLAHMIHVDBGKUMDXC9WHHTIRYHZVWNXSVQU WCR9M9RAGMFEZZKZ9XEOQGOSLFQCHHOKLDSA9QCMDGCGMRYJZLBVIFOLBIJPROKMHOYTBTJIWUZWJM CTKCJKKTR9LCVYPVJI9AHGI9JOWMIWZAGMLDFJA9WU9QAMEFGABIBEZNNAL9OXSBFLOEHKDGHWFQSH MPLYFCNXAAZYJLMQDEYRGL9QKCEUEJ9LLVUOINVSZZQHCIKPAGMT9CAYIIMTTBCPKWTYHOJIIY9GYN PAJNUJ9BKYYXSV9JSPEXYMCFAIKTGNRSQGUNIYZCRT9FOWENSZQPD9ALUPYYAVICHVYELYFPUYDTWU SWNIYFXPX9MICCCOOZIWRNJIDALWGWRATGLJXNAYTNIZWQ9YTVDBOFZRKO9CFWRPAQQRXTPACOWCPR LYRYSJARRKSQPR9TCFXDVIXLP9XVL99ERRDSOHBFJDJQQGGGCZNDQ9NYCTQJWVZIAELCRBJJFDMCNZ U9FIZRPGNURTXOCDSQGXTQHKHUECGWFUUYS9J9NYQ9U9P9UUP9YMZHWWWCIASCFLCMSKTELZWUGCDE 9YOKVOVKTAYPHDF9ZCCQAYPJIJNGSHUIHHCOSSOOBUDOKE9CJZGYSSGNCQJVBEFTZFJ9SQUHOASKRR GBSHWKBCBWBTJHOGQ9WOMQFHWJVEG9NYX9KWBTCAIXNXHEBDIOFO9ALYMFGRICLCKKLG9FOBOX9PDW NQRGHBKHGKKRLWTBEQMCWQRLHAVYYZDIIPKVQTHYTWQMTOACXZOQCDTJTBAAUWXSGJF9PNQIJ9AJRU MUVCPWYVYVARKR9RKGOUHHNKNVGGPDDLGKPQNOYHNKAVVKCXWXOQPZNSLATUJT9AUWRMPPSWHSTTYD FAQDXOCYTZHOYYGAIM9CELMZ9AZPWB9MJXGHOKDNNSZVUDAGXTJJSSZCPZVPZBYNNTUQABSXQWZCHD QSLGK9UOHCFKBIBNETK99999999999999999999999999999999999999999999999999999999999 9999999999999999999999NOXDXXKUDWLOFJLIPQIBRBMGDYCPGDNLQOLQS99EQYKBIU9VHCJVIPFU YCQDNY9APGEVYLCENJIOBLWNB999999999XKBRHUD99C99999999NKZKEKWLDKMJCI9N9XQOLWEPAY WSH9999999999999999999999999KDDTGZLIPBNZKMLTOLOXQVNGLASESDQVPTXALEKRMIOHQLUHD9 ELQDBQETS9QFGTYOYWLNTSKKMVJAUXSIROUICDOXKSYZTDPEDKOQENTJOWJONDEWROCEJIEWFWLUAA CVSJFTMCHHXJBJRKAAPUDXXVXFWP9X9999IROUICDOXKSYZTDPEDKOQENTJOWJONDEWROCEJIEWFWL UAACVSJFTMCHHXJBJRKAAPUDXXVXFWP9X9999'] } stringified = json.dumps(command) headers = { 'content-type': 'application/json', 'X-IOTA-API-Version': '1' } request = urllib2.Request(url="http://localhost:14265", data=stringified, head ers=headers) returnData = urllib2.urlopen(request).read() jsonData = json.loads(returnData) print jsonData Salida: Sin salida.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

30

DIRECTRICES PARA EXCHANGES Introducción La siguiente es una colección de recursos que están destinados a ayudar a los Exchanges para acelerar su integración con IOTA. Esta es una combinación de pautas útiles, desafíos comunes que enfrenta la Integración y código de ejemplo para ciertos flujos de trabajo. En el momento de redactar este informe, la Fundación IOTA está trabajando en un "Hub IXI", que se ocupa de parte de la complejidad relacionada con la administración de insumos para exchanges, carteras, faucets y otros servicios.

Generación segura de una seed Las seed son lo principal que debe almacenarse de forma segura, ya que la misma se utiliza para derivar claves privadas y, por lo tanto, para firmar transacciones.

Las seed en IOTA consisten en 81 Trytes ('9, A-Z'), que es equivalente a una seguridad de 384 bits. ($27$ caracteres válidos, $81$ de estos seleccionados al azar: $\log_2(27^{81})\approx 384$) Dejamos que los exchanges generen sus seed de forma segura. La mayoría de los lenguajes de programación tienen un PRNG suficientemente seguro criptográficamente (basado principalmente en /dev/urandom) que se puede usar para generar seed automáticamente. Los exchanges también pueden usar sus propias implementaciones para tomar entropía adicional (Generador de seed de ejemplo) o usar hardware RNG. Ejemplos



Shell #Linux `cat /dev/urandom |tr -dc A-Z9|head -c${1:-81}` #Mac `cat /dev/urandom |LC_ALL=C tr -dc 'A-Z9' | fold -w 81 | head -n 1`

Generando direcciones de depósito de usuario Al generar una dirección, tiene la opción de elegir entre 3 modelos de seguridad: 1: seguridad de 81-trit (baja) 2: seguridad de 162-trit (medio) 3: seguridad de 243-trit (alta) Aconsejamos a los exchange que utilicen la seguridad de nivel 3 (243-trit) para todas las direcciones que se generan para hot-wallets,cold storage y direcciones multifirma (multisignature addresses). Por razones de eficiencia, el nivel de seguridad 2 para los depósitos del usuario es suficiente.

Además de eso, cuando se trata de direcciones que se utilizan para back-end (reorganización interna de saldos) y front-end (depósitos de usuarios), recomendamos a los exchange siempre generar y aplicar checksums de direcciones. Esto es especialmente importante para las funciones relacionadas con el usuario (por ejemplo, extracción de procesamiento), ya que los usuarios a veces cometen el error de entregar la dirección incorrecta. Compruebe las funciones de utilidad respectivas addChecksum, isAddress y isValidChecksum

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

31



JavaScript iota.api.getNewAddress(seed, {index: 0 , total: 1, security: 3, checksum: true}, function(e, address) { console.log(address) // Graba una dirección generada en la base de datos })

Generación y gestión de direcciones de depósito Para los exchanges es importante que a cada usuario se le asigne una dirección única para cada depósito. Esto evita la reutilización de direcciones y garantiza que todos los fondos de los usuarios sean seguros. Por eso, aconsejamos exchanges para generar y asignar una seed única a cada usuario y rastrear cuidadosamente si los índices clave ya se usaron como entrada para una transacción previa (es decir, eliminados) y, por lo tanto, ya no se deben usar.

Si los exchange no pueden generar y almacenar una nueva seed para cada usuario y en su lugar prefieren usar una única seed (o múltiples) para las direcciones de depósito, recomendamos usar una base de datos relacional y asignar cuidadosamente un índice clave único a un usuario para cada depósito. Antes de generar una dirección, se debe consultar la tabla de índices clave asignados y gastados para garantizar que se asigne el índice clave correcto a un usuario.

Tenga en cuenta que este enfoque presenta problemas de simultaneidad difíciles, y los exchanges deberán resolverlo (por ejemplo, la atomicidad de estos controles y marcar índices clave de utilizados).

Estado

Descripción

Asignado

La clave fue asignada a un usuario.

Gastado

El índice clave con la dirección respectiva ya se utilizó en una transacción anterior y, como tal, ya no se debe usar

Notificaciones de depósito de usuario Después de cada depósito exitoso, debe enviar los tokens a su cold-wallet y generar una nueva dirección disponible a disposición de los usuarios para realizar un nuevo depósito. Para fines de seguridad adicional, puede usar el campo de etiqueta para identificar a los usuarios y sus depósitos. El campo de tag permite almacenar un valor único de 27 trytes.

Una vez que un usuario ha realizado una transacción a la dirección de depósito, debe esperar hasta que la transacción se confirme oficialmente. Hay dos formas de verificar si se confirmó un depósito: 1. A través de getBalances Probablemente, la forma más directa de saber si un depósito fue exitoso es verificar cuál es el saldo de una dirección con la llamada a la API getBalances. Requisito previo de esto es que tenga una dirección de depósito única para cada usuario individual. Puede llamar continuamente a getBalances con la dirección de depósito como entrada para determinar si una dirección tiene un saldo confirmado o no.

2. A través de findTransactions Continuamente llame a findTransactions en la dirección de depósito. Una vez que hay una transacción, obtenga su bundle hash (a través de utils.transactionObjects), busque todas las transacciones con el mismo bundle hash, obtenga la tail transaction (transacción de cola) correcta y luego invoque getInclusionState` en esa transacción.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

32

Sweeping (barrido) de dirección de depósito de usuario a las direcciones internas de un exchange ¿Qué son los sweeping?

Los sweeping (barrido) son transferencias de direcciones de depósito de usuario a cold storage (almacenamiento en frio) o hot wallet. Le permiten acreditar de forma segura a los usuarios, después de mover los fondos de sus direcciones de depósito. Los sweeping se pueden enviar periódicamente después de escanear direcciones para mantener el balance. ¿Por qué son importantes los sweeping? / ¿Cuándo debería acreditar a los usuarios?

Los sweeping son cruciales para que los fondos de los usuarios esten seguros, ya que solo es seguro mantener los fondos en direcciones no utilizadas.

En caso de que un usuario deposite en una dirección ya barrida (swept), un atacante podría tratar de falsificar una firma y mover los fondos fuera de esta dirección si el exchange ya ha desaparecido antes. Por lo tanto, los fondos deben llevarse a su cold storage o hot wallet periódicamente.

Acreditaciones de saldo solo se deben realizar después de confirmar las transacciones de barrido, y los fondos deben estar en su poder.

Debe informarle absolutamente al usuario del riesgo de pérdida total si lo envía a una dirección de depósito proporcionada por un exchange ya utilizada. ¿Cómo realizar barridos?

En este ejemplo, definimos las direcciones y los metadatos utilizados para crear transferencias sweep y acreditar a los usuarios.

Determine las entradas de sweep correctas 1. Escanee las direcciones de depósito para mantener el equilibrio El primer paso es determinar un conjunto de direcciones de depósito, obtener sus saldos con iota.api.getBalances() y filtrar las direcciones vacías.



JavaScript const addresses = [ 'ZRMBFCFLJSEIHYSXGDMOJOCORBWSSGJDJMVZGWUYGXTJYUJQELKOXNWOYBYTMYEIHP9PPPKWDEVOY JPZH', 'TXPETAIGWJGETC9Y9FKKLHIBZHO9KQESOHZBKEQBEAKJJKDQCSD9CRPKSZIXIGTPMLBVYXLHNNDMZ FTSH' ] // Metadata de la dirección // los hashes representan cualquier seep no resuelto const metadata = [ {security: 2, keyIndex: 1, user: 'Chris', hashes: []}, {security: 3, keyIndex: 2, user: 'Dom', hashes: ['']} ] iota.api.getBalances(addresses, 100, (err, res) => { if (err) { // handle error console.log(err) return }

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

33

// Convertir balances a Int balances = res.balances.map(balance => parseInt(balance)) // Construye objetos sweep const sweeps = metadata.map((data, i) => { address: addresses[i], security: metadata[i].security, keyIndex: metadata[i].keyIndex, hashes: metadata[i].hashes, balance: balances[i] }) // No realizer sweep en direcciones con balance 0 sweeps.filter(sweep => sweep.balance > 0) // Verificar los sweep actuales relaciondos a cada direccion de deposito // [...] }) 2. Verificar si las direcciones de depósito se usaron en barridos (sweeps) no resueltos Para determinar si los barridos previos de cualquier dirección de depósito están en curso, utilizamos isReattachable() en los hashes de transacción de cola barridos.



JavaScript // Obtiene el primer hash de la cola de cada dirección const hashes = [] sweeps.forEach(sweep => hashes.push(sweep.hashes[0])) // Verifica que los sweeps actuals sean relaciones a cada direccion iota.api.isReattachable({hashes: hashes}, (err, res) => { if (err) { // handle error console.log(err) return } // No realiza sweep a las direcciones que fueron usadas como entrada en sweep pendientes sweeps = sweeps.filter(sweep => { const index = hashes.indexOf(hash => hash === sweep.hashes[0]) if (index === -1) { return true } return !res[index]; }) // Constructor de entradas const inputs = sweeps.map(sweep => { Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

34

address: sweep.address, security: sweep.security, keyIndex: sweep.keyIndex, balance: sweep.balance }) // Envia una transferencia sweep // [...] }) Advertencia Si alguna dirección se ha barrido (sweep) previamente, no la barra de nuevo, a menos que se hayan confirmado las transferencias de barrido anteriores.

Envío de transferencias A continuación, use sendTransfer() y proporcione las direcciones seleccionadas como entradas para mover su saldo a una dirección propiedad de un exchange no utilizada para gastos. En este ejemplo agregamos las entradas asignadas a diferentes usuarios en una sola transacción, mejorando el rendimiento al reducir la cantidad de Prueba de Trabajo.



JavaScript // Definir una dirección no usada

propiedad de exchange como salida del sweep

// Asegúrese de que ninguna otra transferencia use esta dirección como entrada const destinationAddress = 'KTLACMXXOJYIIEYJJYSUXXOJUPSVNLQHZSSLWSBOSPALSDAZQNPZBPNMCFZDVS9RGJRKQHBDEZZGG WUQE' // Definir opciones pasando entradas y dirección del resto const options = { inputs: inputs, // La dirección restante siempre debe ser una dirección no utilizada y propiedad del exchange cuando se envían transferencias de sweep. // En este ejemplo simplemente usamos `destinationAddress` address: destinationAddress } // Sumar todos los saldos ya barridos (swept balances) const totalValue = sweeps.reduce((sum, sweep) => sum + sweep.balance, 0) // Definir transferencias usando la dirección de destino y la suma de saldos de entrada como el valor const transfers = [{ 'address': destinationAddress, 'value': totalValue, 'message': '', 'tag': '' Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

35

}] // Enviar transferencia y obtener el tail hash iota.api.sendTransfer(seed, 4, 14, transfers, options, (err, transactions) => { if (err) { // handle error console.log(err) return } // Extraer el tail transaction hash de la respuesta const tailHash = transactions[0].hash console.log(tailHash) // El tail hash se usa para que las direcciones de la whitelisting sean barridas y para verificar la confirmación del barrido inputs.forEach(input => { const index = metadata.indexOf(data => data.address === input.address) // Actualizar el ultimo sweep de la transaction tail hash metadata[index].hashes[0] = tailHash }) metadata.push(tailHash) }) Atención Si bien la agregación de barridos mejora el rendimiento, se recomienda mantener el tamaño del paquete limitado a 10 transacciones en promedio para tener confirmaciones más rápidas. Esto se logra al agregar 4 entradas en un paquete en promedio.

Advertencia Todas las direcciones de entrada pasadas a una sola llamada a sendTransfer() deben generarse desde la misma seed. Es posible que desee almacenar en caché las direcciones que pertenecen a una seed junto con su índice de clave porque la generación de direcciones es computacionalmente costosa.

Advertencia Asegúrese de proporcionar el nivel de seguridad correcto y el índice de clave para cada entrada.

Advertencia Espere a que las transferencias de barrido confirmen antes de gastar sus productos.

Advertencia Defina siempre una dirección sin usar del exchange. Idealmente, la dirección restante debe ser la misma que la dirección de salida. ¿Cómo puedo/debo acreditar a los usuarios?

Comprobando barridos (sweeps) confirmados El último paso para garantizar el depósito fue seguro para direcciones de exchanges es verificar los estados de inclusión de las transacciones de barrido (sweep). Haga uso de getLatestInclusion() y pase los hashes de transacción de cola (tail transaction). El resultado determina qué transacciones son confirmadas y aceptadas por la red.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

36



JavaScript // Obtener los tail hashes, obtenidos por `sendTrasnfer()`, desde los metadatos const hashes = metadata.map(data => data.hashes) .reduce((hashes, hash) => hashes.concat(hash), []) // Verificar los estados de inclusion iota.api.getLatestInclusion(hashes, (err, states) => { if (err) { // handle error console.log(err) return } states.forEach((confirmed, i) => { if (confirmed) { console.log('Transaction with tail hash:', hashes[i], 'confirmed') // credit he user // [...] } }) })

Atención: Es posible que deba volver a conectar los barridos que permanecen sin confirmar después de un cierto período de tiempo. Consulte la guía de reinserciones de transacciones para obtener información detalladas.

Advertencia: Proceda a acreditar solo las transacciones confirmadas.

Acreditando a los usuarios Los barridos de las direcciones que pertenecen a diferentes usuarios se pueden agregar y enviar con una sola llamada a sendTransfer() para un mejor rendimiento, como se muestra anteriormente, pero deben acreditarse con cuidado. Para acreditar al usuario, busque el paquete de la transferencia de barrido con getBundle() pasando el tail hash transaction. Luego examine cada transacción en el bundle de valor negativo y crédito según el valor y la dirección.



JavaScript iota.api.getLatestInclusion(hashes, (err, states) => { if (err) { // handle error console.log(err) return } states.forEach((confirmed, i) => { Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

37

if (confirmed) { // Obtener bundle por el tail hash iota.api.getBundle(hashes[i], (err, bundle) => { if (err) { // handle error console.log(err) return } // Verificar direccion y valor para cada transaccion con saldo negative a acreditar al usuario bundle.filter(tx => tx.value < 0) .forEach(tx => { // obtener index de la dirección de la transacción en el array de direcciónes const j = addresses.findIndex(address => address === tx.address) if (j !== -1) { // Buscar al usuario que deposito a la direccion barrida (sweep) const user = metadata[j].user // Obtener el valor absolute del sweep const value = Math.abs(tx.value) // Acredita al ‘usuario’ con el ‘valor’ console.log("credit " + user + " with " + value) } }) }) } }) }) Atención: Solo tenemos que verificar el tail hash transaction con getLatestInclusion().

Los paquetes son conjuntos atómicos de transacciones, ya que dichas transacciones en el paquete están todas confirmadas o pendientes.

Advertencia: Otros enfoques sobre la acreditación de sweeps agregados pueden dar lugar a créditos incorrectos; por ejemplo, basar el crédito en getBalances() antes del sweep, tiene un problema de tiempo de comprobación de tiempo de uso, si un usuario ha depositado (con éxito) mientras construía el sweep.

Retiro de procesamiento y monitoreo Cómo seleccionar entradas Todas las direcciones de entrada, utilizadas para transferir tokens, no deben tener transacciones entrantes pendientes, como una medida estricta para evitar la reutilización de claves privadas. Asegúrese de que no se transfiera ningún valor a las entradas, y todas las transacciones entrantes anteriores se confirmen, en el momento en que envía una transferencia.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

38

Envío de transacciones de retiro



JavaScript // Seed de la entrada const seed = 'SEED' // Transferir array representado por dos diferentes retiros const transfers = [ { // Dirección de quien recibe address: 'DE9ZKMZB9YAECNDQD9XUFWDUEAFZTQGCOFTCIZBMXJTV9QILCVDVAINKCWNCMEDLLYNOBWXNNFDME TWJA', // Valor enviado value: 70, message: '', tag: '' }, { address: 'TOJSCSKDSRCLCBEBEWGRBLYLVLPUZVCVMLUKJJAPSQIAVGAKXDQXRYD9JWDHSRPONTDCVBGNGEJDV 9FFT', value: 80, message: '', tag: '' } ] // Inputs array, used to fund the transfer const inputs = [ { address: 'ZKUQPWZPBWGPMIJQBDRUVOOIGJTJHTPVQZ9TCJAOVKIMNSVUDBXNXQLBLPLQTBJXHPC9EFOUZANZK GUQU', keyIndex: 0, security: 2, balance: 100, }, { address: 'MHSLCATNTDJBZIKDY9N9YCLSQKUSYZIRXGNDHOOQGIOFDRLRLFJDDSZIKTCZVJYATVCQWUXYXCHBJ E9DW', keyIndex: 1, security: 2, balance: 90 } ] // Exchange owned remainder address to send the remainder to. // In this example it's 40 (100 + 90 - 80 - 70 = 190 - 150 = 40)

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

39

const remainderAddress = 'EL9RESSAIDSYMEEVXLUMOPNIRJSHYMTXIGJWSSWTPXNMAZIKWTX9RAUTJGVMKLBSLZCAYUAMUGA9A WIZU' // Construct options object, passed to `sendTransfer()` const options = { inputs: inputs, address: remainderAddress } const depth = 4 const minWeightMagnitude = 14 // Keep track of withdrawal tail transaction hashes to check confirmation status const withdrawalHashes = [] iota.api.sendTransfer(seed, depth, minWeightMagnitude, transfers, options, (err, transactions) => { if (err) { console.log(err) // Handle error... return } // Push obtained tail hash to withdrawals array withdrawalHashes.push(transactions[0].hash) // Save hash to persistent database... // [...] }) Confirmación de monitoreo y reinscripciones Puede controlar las transacciones de retiro y notificar a los usuarios una vez que se hayan confirmado las transacciones de retiro. El siguiente ejemplo utiliza getLatestInclusion() para verificar transacciones confirmadas.



JavaScript const withdrawalHashes = [ 'LP9QHGHQCB9O9VDRZVJILKVVGFVCNFRYDHTSHNAXZSWNEZCKAHXCXDE9QGYVVMQXXHDK ESWGM9SHN9999', 'POQUUPVAAUOJXBXLJKRZRDAFTXOHHR9UEFF9DKJSYTGMROVNNZRKILYRKHKYFBIXOGAH TEGSNYPIT9999' ] // Check inclusion states iota.api.getLatestInclusion(withdrawalHashes, (err, states) => { if (err) { // handle error console.log(err) return Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

40

} states.forEach((confirmed, i) => { if (confirmed) { console.log('Withdrawal transaction with tail hash:', withdrawalHashes[i], 'confirmed') // Remove transaction hash from pending withdrawals list... // [...] } }) }) Además, puede volver a adjuntar paquetes que están pendientes después de un período de tiempo determinado. La guía de reattachaments de transacciones contiene los ejemplos de códigos relevantes.

Reasignaciones de transacciones Reasignaciones de transacciones Debido a la naturaleza única del Tangle, podría ser necesario reproducir un bundle para confirmarlo. La biblioteca javascript proporciona dos métodos para ejecutar apropiadamente las reinscripciones, isRettachable() para determinar si la reinserción es posible y replayBundle() para ejecutar la repetición.

Comprobando si se requiere volver a colocarlo Para determinar si debe volver a conectar las transacciones pendientes, utilice el método isReAttachable() y pase los hash tail transactions. El resultado de isReattachable() devolverá falso si las entradas utilizadas en el bundle tienen saldo cero o insuficiente.



JavaScript iota.api.isReattachable({hashes: hashes}, (err, res) => { if (err) { console.log(err) return } res.forEach((isReattachable, i) => { console.log(isReattachable) if (isReattachable) { // Reattach // [...] } }) }) Volver a conectar una transferencia Para volver a adjuntar un bundle, utilizamos isReattachable() pasando los hash transactions tail de las transferencias reutilizables. Una vez que se realiza una broadcast, debe obtener el hash transaction tail que es útil para determinar la confirmación.



JavaScript res.forEach((isReattachable, i) => { console.log(isReattachable) if (isReattachable) {

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

41

// Reattach iota.api.replayBundle(hashes[i], (err, txs) => { // Get the tail transaction hash const tailHash = txs[0].hash // Keep track of tail hash to check for confirmation // [...] }) } }) Advertencia Es importante realizar un seguimiento de todos los hash de transacción de cola, incluido el de volver a vincular, para determinar el estado de confirmación con getLatestInclusion ().

Generación de direcciones multisig seguras (para hot wallets y cold storage) En caso de que quiera leer sobre cómo funcionan las firmas múltiples en IOTA, haga clic aquí. Para los exchanges que tienen la intención de configurar el cold storage o hot wallet, le recomendamos que configure las direcciones de multi-sign para su almacenamiento en frío, basándose exclusivamente en la biblioteca Javascript de iota.lib.js.

La belleza de IOTA es que puede hacer uso de todas las funciones de criptografía, incluidas las más delicadas para firmar y generar direcciones, sin tener que instalar el cliente Core. Esto significa que puede generar de manera segura direcciones con varias firmas en un entorno fuera de línea seguro (por ejemplo, una computadora portátil que nunca estuvo conectada a Internet). Lo principal que debe almacenarse de forma segura es la seed, ya que se está utilizando para derivar claves privadas y, por lo tanto, para firmar transacciones.

Al generar una dirección de firma múltiple fuera de línea o en línea, lo que debe hacer principalmente es compartir el compendio de claves en el orden correcto y generar la firma múltiple de esa manera. Hemos implementado funciones de validación para que pueda asegurarse de que la dirección de firma múltiple generada sea correcta. Compartir resúmenes de claves es seguro (no puede derivar una clave privada del compendio de claves).

Advertencia Cabe señalar que es de suma importancia garantizar una gestión adecuada del índice clave.

Advertencia Debido a que IOTA utiliza firmas únicas, nunca debe volver a utilizar las claves, por lo tanto, debe estar seguro de los índices clave que ya se han utilizado como parte de una firma única o múltiple, y nunca debe volver a utilizarlos.

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

42

RESUMEN IOTA externaliza una gran parte de la funcionalidad (hash y firma) al lado del cliente por razones de seguridad. El núcleo de IOTA está ahí para ser la puerta de entrada a la red de IOTA, mientras que las bibliotecas están ahí para hacer hashing en general, firmar transacciones y proporcionar una API funcional para los desarrolladores.

La biblioteca más madura es la biblioteca Javascript, seguida de Java y Python. Le sugerimos que use una de estas bibliotecas para el hackathon.

Lenguaje

Link

Madurez

Javascript

https://github.com/iotaledger/iota.lib.js

Alta

Python

https://github.com/iotaledger/iota.lib.py

Buena

Java

https://github.com/pinpong/iota.lib.java/

Buena

Fuente IOTA: https://iota.readme.io/v1.2.0/docs/getting-started

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Traducido por Ing. Agustín Moyano moyanoa@gmail.com

Volver al Índice

43