¿Significa Ardor la muerte de Nxt?

El proceso de toma de instantáneas ha terminado y los activos (ARDR) ya han sido repartidos. La cantidad de NXT en una cuenta ya no influye en el número total de tokens de forja ARDR que recibirás una vez que la red Ardor entre en funcionamiento. Ver caer el precio de NXT estos últimos meses debería dar una buena pista para todo el mundo. Ya no hay ninguna razón para mantener NXT. Ardor y sus child chains son el futuro. ¡Abran paso!

¿De verdad? Yo no lo creo.

make-way

¿Seguirá Nxt el mismo camino en 2017?

1. Ardor no será presentado hasta el tercer trimestre de 2017

La reciente distribución de “Ardor” solo es un activo que determinará el número total de tokens ARDR que vas a obtener una vez la plataforma Ardor entre en acción. Ahora mismo no es algo real ni lo será a corto plazo.

La testnet de Ardor se espera sea lanzada durante el primer trimestre de 2017 y la puesta en marcha de la red principal está prevista para el tercer trimestre de 2017. ¿Por qué no usar Nxt hasta entonces? Sigue siendo seguro, totalmente funcional y, además, es la base de muchos activos y monedas que son negociados en múltiples casas de intercambio.

2. Nxt todavía recibirá soporte

El equipo de desarrollo de Nxt ha prometido dar soporte a la plataforma Nxt, durante un año, como mínimo, tras el lanzamiento de la red Ardor. Estamos hablando de un software que va a ser mantenido al día, como mínimo, hasta finales de 2018. Y después de eso, desarrolladores con una dosis de motivación pueden adoptar el proyecto y mantenerlo.

Aunque no se agregasen nuevas características, lo cual es una posibilidad, el software sigue siendo funcional y ha demostrado ser fiable durante estos últimos tres años. Algunos activos y monedas se moverán a la plataforma Ardor, pero otros continuarán utilizando la plataforma Nxt 1.0.

Muchas altcoins no son evolucionadas o no tienen actualizaciones importantes y, a pesar de eso, todavía se siguen comprando y vendiendo de forma activa.

3. La toma de instantáneas para Ignis beneficiará Nxt

En el tercer trimestre de 2017, tendrá lugar la instantánea para la distribución de Ignis, la primera child chain de Ardor, y probablemente atraerá a una gran cantidad de especuladores. Ardor es el combustible de la red, pero Ignis es la primera moneda con todas las características que nos gustan de Nxt: votación, mezclado de moneda, alias,…

Esta segunda instantánea será una buena oportunidad para que la gente aprenda acerca de Nxt y atraer a nuevos usuarios.

look

Intentando adivinar el valor futuro de las criptomonedas

Sin embargo, la caída del precio NXT puede ser más rápida que el aumento. Después de la instantánea, lo más probable es que vuelva a caer de nuevo. “Cuánto” es la pregunta.

4. Jerulida está observando

Jelurida nace con el objetivo de proteger la propiedad intelectual del código de Nxt. Para tener éxito comercial necesita que Nxt tenga éxito. Tener un equipo trabajando a tiempo completo para mejorar y proteger Nxt tendría sentido para su futuro.

Durante la sesión de Preguntas y Respuetas tras la creación de Jelurida, se planteó la siguiente pregunta:

> @josenxt
> ¿Veremos en los próximos 6 meses otra gran sorpresa (como la de Jelurida) que se está gestando actualmente entre bastidores?

> @jean-luc
> Espero que incluso más pronto

Esperemos que beneficie a Nxt.

5. Las aplicaciones actuales seguirán siendo funcionales

La API de Nxt es muy estable y fácil de usar. Muchos desarrolladores han construido sus propias aplicaciones basadas en Nxt (MyNxt, SuperNET, nxtportal, Nxter.org, Nxt3D…). Incluso aunque la API de Ardor terminase siendo muy parecida a la de Nxt (lo que no es seguro), requerirá un cierto trabajo antes de que tales aplicaciones puedan trasladarse a Ardor (si es que deciden trasladarlas). Pero, ellos seguirán trabajando en la plataforma Nxt 1.0, sin importar lo que suceda.

Nxt tiene un gran ecosistema y llevará algún tiempo para que Ardor lo alcance, aún incluso después del lanzamiento.

6. Un NXT barato significa transacciones más baratas

Nxt siempre ha utilizado las tarifas de transacción de 1 NXT para la mayoría de las operaciones. En junio de 2016, cuando 1 NXT valía 13.000 Satoshi, una tarifa de transacción costaba alrededor de 8 céntimos de euro por transacción (aún entonces más barato que Bitcoin, por cierto). Ahora, estando casi a 1000 Satoshi, estos honorarios valen solamente 0,6 céntimos. Es básicamente gratis.

Aquellos que consideran que NXT es una moneda se sentirán decepcionados. Aquellos que ven a Nxt como una plataforma de intercambio de activos, discusiones o hosting distribuido, estarán contentos.

Un mezclado de monedas cuesta 12NXT, o 0,07€ al cambio. ¿No es un buen momento para anonimizar algunas monedas o activos? ¿Qué tal lanzar ese activo que estabas pensando? La emisión de un activo sólo cuesta 1000 NXT o alrededor de 6€, a día de hoy.

nicholas

El futuro es brillante

Lectura recomendada: http://test.nxter.org/es/desarrolladores/

Mientras que haya un puñado de personas manteniendo y forjando Nxt, la red va a ser funcional.

Recuerde que para todas aquellas personas que venden sus NXT siempre hay compradores que piensan que vale la pena comprarlos.

Este post de opinión fue enviado por mart_e: NXT-XZ53-H97E-6FK5-9RHAS

¿Quieres que se publique tu entrada de blog en nxter.org? Póngase en contacto con nosotros y haga que su voz sea escuchada.

Cervezas, apuestas y la blockchain de Nxt

Supongamos que tienes un grupo de amigos con los que te reúnes un un bar de deportes para tomar una cerveza, ver eventos deportivos y hacer apuestas. Pues es posible hacer apuestas utilizando la blockchain de Nxt utilizando una sencilla aplicación Python que lo automatice todo.

En mi primer artículo presenté los conceptos básicos de la blockchain. Tal y como vimos, el principal valor de la cadena de bloques es la inmutabilidad de los datos contenidos en las transacciones almacenadas en cada bloque, a partir de los cuales se construye la blockchain.

Hoy quería mostrar como construir una aplicación de apuestas en python de manera sencilla pero funcional. Para esta aplicación es básico que los datos sean inmutables, pero en caso de que sea necesario que una apuesta se pueda cancelar, se puede modificar la app para incluir esta funcionalidad adicional.

Prerrequisitos:
NRS (Software de Referencia Nxt) 1.10.2: https://bitbucket.org/JeanLucPicard/nxt/downloads/Python 3 (o Python 2 con una ligera modificación). Una cerveza o dos (opcional).

Lógica de la aplicación

Un usuario emite una apuesta (transfiere una determinada cantidad de monedas NXT) a la cuenta de apuestas y le añade un adjunto público y sin encriptar. En el adjunto se debería incluir el identificador de la apuesta, dos puntos, y un número indicando su elección en la apuesta correspondiente. Pongamos un ejemplo: el bar de eventos deportivos crea una porra sobre qué equipo saldrá victorioso en un partido de fútbol. Le asigna un Identificador (ID) al partido, por ejemplo “30”.

Las opciones son:
“1” – gana el equipo de casa “2” – gana el equipo visitante. “3” – empatan.

Para apostar que gana el equipo de casa, el jugador debería enviar una transacción con una determinada cantidad de NXT, adjuntando un mensaje público sin encriptar (para que sea auditable) con el siguiente contenido 30:1

Cuando llegue el momento, el gestor de la apuesta ejecuta la app para localizar a los ganadores y realizar los pagos. El gestor puede quedarse una pequeña comisión por el servicio prestado.

Implementación

El servidor Nxt recibe las peticiones en el puerto 7876. Si por defecto lo ejecutas en el mismo equipo en el que ejecutas el código python debes enviar tus peticiones a http://127.0.0.1:7876/nxt

Para nuestra app necesitaremos importar unos pocos módulos y escribir la función para hacer consultas que se usará unas cuantas veces en la ejecución de la app.

import sys, json, re

def sendQuery(Query):
  from urllib import parse, request
  params = parse.urlencode(Query)
  headers = {"Content-type": "application/x-www-form-urlencoded", 
"Accept": "text/plain"}
  req = request.Request("http://127.0.0.1:7876/nxt", 
params.encode('utf-8'))
  response = request.urlopen(req)
  return response.read()
	
myAccount = "NXT-AAAA-BBBB-CCCC-DDDDD"
totalAmount = 0
serviceFee = 0.05
players = []
secretPhrase = "bla bla bla"

La función devuelve una cadena JSON que necesita ser decodificado, con transacciones y adjuntos que necesitan ser analizados. También se inician unas determinadas variables

A continuación debes pedirle a la cuenta con las apuestas que busque en todas las transacciones entrantes.

Esta es la solicitud que puedes enviar al servidor Nxt para ejecutar esto:Query = {‘requestType’: ‘getBlockchainTransactions’,

'account': myAccount, 'type': '0', 'subtype': '0', 'executedOnly': 'true'}

decode JSON and load it to a variable for further processing.

output = sendQuery(Query)
data = json.loads(output.decode('utf-8'))

Puesto que ahora ya contamos con todos los datos, ejecutamos un loop en la tabla para deshacernos de las transacciones que no necesitamos. Por ejemplo, no necesitamos procesar las transacciones salientes, así que continuamos nuestro loop desde el siguiente objeto

for i in data['transactions']:
  txAmount = i['amountNQT']
  txSender = i['senderRS']
  if txSender == myAccount:
      continue
  txRecipient = i['recipientRS']
  if txRecipient != myAccount:
      continue

A continuación extraemos los adjuntos, nos aseguramos de que no están encriptados y quitamos los espacios en blanco

  line = i['attachment']['message']
  lineIsText = i['attachment']['messageIsText']
  if line.strip() != "" and lineIsText == True:
    line = line.strip()

El siguiente paso es hacer concordar el mensaje enviado con la expresión regular. Tiene que satisfacer el formato “Número:Número”, el primer número puede contener hasta 3 dígitos.

    matchLine = re.match(r'(\d{1,3}:\d{1})(.*)', line, re.M|re.I)

Si el mensaje adjunto tiene un formato correcto, continuamos analizando…

La aplicación para las apuestas acepta hasta un máximo de 3 argumentos en la línea de comandos: identificador de juego, el número elegido que ha ganado, y un tercer parámetro opcional entre comillas para mostrar la combinación ganadora en el mensaje con el pago.

Por ejemplo, el anfitrión de la apuesta debe ejecutarlo del siguiente modo:

python3 bet.py 30 1 “El equipo local gana”

La aplicación analizará las transacciones con id 30 y premiará a los jugadores que eligieron ‘1’.
El tercer argumento se podría omitir: python3 bet.py 30 1

A continuación debemos calcular la cantidad de dinero que ha recibido nuestro, haciendo un listado diccionario de jugadores que adivinaron el número correcto, y calculando la suma total de dinero a distribuir una vez que el anfitrión ha recibido su comisión opcional.

    if matchLine:
      if matchLine.group(1).split(':')[0] == sys.argv[1]:
        totalAmount += int(txAmount)
        if matchLine.group(1).split(':')[1] == sys.argv[2]:
          d = {txSender: matchLine.group(1).split(':')[1], 
'amount': txAmount}
          players.append(dict(d))
afterFee = float(totalAmount - totalAmount * serviceFee)

Tenemos ganadores en la lista ‘players’ de los diccionarios, tenemos dinero para distribuir en el apartado ‘afterFee’, ahora dinos los pagos de premios procesados.

sumCorrect = 0
for i in players:
  for key in i:
    if i[key] == sys.argv[2]:
      sumCorrect += float(i['amount'])
for i in players:
  for key in i:
    if i[key] == sys.argv[2]:
      t = float(i['amount']) * (afterFee / sumCorrect)
      if t > afterFee:
        strSendAmount = str(int(afterFee))
      else:
        strSendAmount = str(int(t))
      if len(sys.argv) > 3:
        reply = sys.argv[3]
      else:
        reply = sys.argv[2]
      message = "Payout for correct bet in poll " 
+ sys.argv[1] + "; your reply: " + reply
      Query = {'requestType': 'sendMoney', 'recipient': key, 
      'amountNQT': strSendAmount, 'secretPhrase': secretPhrase, 
      'feeNQT': '100000000', 'deadline': '1440', 'broadcast': 'true', 
'message': message, 'messageIsText': 'true', 'messageIsPrunable': 'true'}
      sendQuery(Query)

No es necesario decir que la app se puede optimizar para procesar errores, cancelar apuestas u, opcionalmente, permitir otros parámetros en los mensajes adjuntos. Los mensajes adjuntos se pueden emitir desde el cliente Nxt (NRS) o desde un monedero online que permita enviar adjuntos

Para realizar transacciones en la blockchain de Nxt necesitas monedas NXT, que puedes adquirir directamente cambiando Bitcoin por Nxt o participando en el proyecto del “Nodo afortunado” ejecutando un nodo público de Nxt (Nxt server).

Para saber como participar en el proyecto del “Nodo afortunado”, por favor visita https://nxtforum.org.

Hay más de un centenar de llamadas API que se pueden solicitar al servidor Nxt. Una lista completa de parámetros obligatorios y opcionales así como ejemplos está disponible en https://nxtwiki.org/wiki/The_Nxt_API.

¡Salud!

blockchain-betting

Lotería en la Blockchain de Nxt programada en Golang

En mi primer artículo hice una introducción teórica de la blockchain, de lo que puede aportar para tu proyecto de software y los conceptos básicos para interactuar con la blockchain de Nxt en PHP.

Hoy voy a presentar un pequeño programa de lotería escrito en Go.

Requisitos previos:
Golang (testado con Go 1.6.2)
NRS 1.10.1 (https://bitbucket.org/JeanLucPicard/nxt/downloads/)

Este programa es completamente funcional y ejecuta un sorteo de lotería todos los domingos [1]. Originalmente fue escrito en PHP, las dos fuentes están disponibles para su descarga desde el Data Cloud de Nxt [2].

Lógica de la aplicación

Los boletos enviados por los usuarios en mensajes adjuntos son el suministro de datos para esta aplicación.

Un jugador de la lotería envía 10 NXT a la cuenta de la lotería adjuntando un mensaje público no encriptado con una secuencia de 5 números, entre el 0 y el 30, separados por comas. El mensaje adjunto tiene que ser público para que las recompensas sean auditables usando la blockchain.

La app hace una llamada al servidor NXT para que le proporcione todas las transacciones desde la cuenta de la lotería, clasificándola y seleccionando únicamente las transacciones válidas para así crear un trozo de mapa (conjunto multidimensional en PHP) de todas las cuentas de los jugadores y de sus cadenas de números.Esto también calcula la suma total, de Nxt, a pagar a los jugadores calculando la suma total de todos los boletos validados.

La app, una vez que ha recibido todos los datos válidos, ejecuta 3 rondas de lotería. Cada una de esas rondas recibe una porción, de la suma total disponible para los pagos, a repartir entre los ganadores. En la ronda de 5, la aplicación encuentra los usuario que han adivinado correctamente los 5 números y envía las recompensas. En la ronda 4, la aplicación hace lo mismo para los usuarios que han adivinado 4 números, el monto restante de los boletos participantes es ahora menor que la del ganador(es) de la ronda 5. Se repite lo mismo para la ronda 3.

Esta es la esencia de como funciona la aplicación.

Un poco más sobre el funcionamiento interno

Para cada una de las tres rondas, la lotería genera secuencias de 5 números y las compara con las cadenas de números de los boletos hasta que encuentra uno o más ganadores. Se puede decir que la lotería “fuerza” encontrar una secuencia ganadora del boleto(s).

Con un número limitado de usuarios esto parece ser la única manera sensata para ejecutar una lotería y no tener que recoger y guardar un premio gordo durante meses y/o años.

Vamos a echar un vistazo a la función que genera la secuencia de los 5 números y devuelve una matriz de ellos a la función de llamada. Esta función se invoca un promedio de cientos de miles de veces para encontrar la secuencia de 5 números en una de las entradas cuando tenemos un número muy limitado de participantes. Se tarda una fracción de segundo. En PHP se necesita un poquito más de tiempo (uno o dos segundos), aunque el rendimiento de PHP 7 es realmente bueno.

func genFive(seed string) [5]int {
   var r [5]int
   seedInt, _ := strconv.Atoi(seed)
   d := false
   for a := offset; a < offset+5; a++ { 
      rand.Seed(int64(seedInt + offset)) 
      var dup [31]int 
      d = false 
      r[0] = rand.Intn(31) 
      r[1] = rand.Intn(31) 
      r[2] = rand.Intn(31) 
      r[3] = rand.Intn(31) 
      r[4] = rand.Intn(31) 
      for _, v := range r { 
         dup[v]++ 
      } 
      for k, _ := range dup { 
         if dup[k] > 1 {
            d = true
         }
      }
      offset = offset + 5
      if d == false {
         return r
      }
   }
   return r
}

Una característica importante de la lotería en la blockchain es que tiene que ser completamente transparente.
Todo el mundo debe poder validar que los resultados de la lotería no han sido alterados. Una solución lógica y simple a esto es generar secuencias de números con una semilla determinista.

El problema con las semillas deterministas es que, si se sabe de antemano, las secuencias de números se puede predecir y , a se podría llegar a hacer trampas en la lotería. Para hacer frente a este problema volvemos de nuevo a la Blockchain de NXT, para encontrar una fuente de semilla con la función getSeed().

func getSeed() (string, string) {
 type BlockchainStatus struct {
    NumberOfBlocks int `json:"numberOfBlocks"`
 }
 var status BlockchainStatus
 if seedBlockOutput, b := 
sendQuery("requestType=getBlockchainStatus", 
true); 
b != false { if err := 
json.Unmarshal([]byte(seedBlockOutput), &status); 
err != nil {
     fmt.Println(err)
   }
  }
 seedBlockHeight := 
strconv.Itoa(status.NumberOfBlocks - 11)

 type BlockId struct {
  Block string `json:"block"`
 }
 var block BlockId
 if seedBlockId, b := 
sendQuery("requestType=getBlockId&height="
+seedBlockHeight, true); b != false {
if err := json.Unmarshal([]byte(seedBlockId), 
&block); err != nil {
         fmt.Println(err)
    }
  }
 seed := block.Block[len(block.Block)-5:]
 return seed, seedBlockHeight
}

La app se ejecuta cada domingo a las 18:00 UTC.

Lo primero que esto hace en la función getSeed() es ir a buscar la identificación del bloque que se generó 10 bloques antes del inicio de la aplicación (como se puede ver en la copia local de la blockchain en el nodo de la lotería) y obtener los últimos 5 dígitos de la ID del bloque como semilla. Debido a la latencia de la red y las reorganizaciones ocasionales de la blockchain (de 1 a 3 bloques) el nodo de la lotería puede que no vea la misma información que los otros nodos. El número 10 para obtener el bloque de la semilla fue escogido por la razón que debemos estar razonablemente seguros que este bloque no será reorganizado.

Puede afirmarse que existe la posibilidad teórica de que pueda predecirse el identificador del bloque. En mi opinión, las posibilidades de que esto suceda son muy bajas, pero dejo a los lectores que lo debatan y decidan por ellos mismos.

Ahora que la App tiene su propia semilla, puede realizar su función de manera que los usuarios no necesiten confiar en el organizador de la lotería.

El código fuente “Go” no incluye la rutina de verificación de los resultados anteriores.
El código fuente “PHP” lo tiene, es totalmente funcional y se puede utilizar para verificar, de manera independiente, todos los resultados anteriores con las semillas deterministas de la blockchain.

Para “Go” yo uso la función de enviar y retornar solicitudes al servidor Nxt.

func sendQuery(Query string, Active bool) 
(output string, b bool) {
   output = ""
   b = false
   if Active == false {
      output = "Function disabled"
      return
   }
   body := strings.NewReader(Query)
   req, err := http.NewRequest("POST", 
"http://127.0.0.1:7876/nxt", body)
   if err != nil {
      output = fmt.Sprintf("%s", err)
      return
   }
   req.Header.Set("Content-Type", 
"application/x-www-form-urlencoded")

   resp, err := http.DefaultClient.Do(req)
   if err != nil {
      output = fmt.Sprintf("%s", err)
      return
   }
   bo, err := ioutil.ReadAll(resp.Body)
   defer resp.Body.Close()
   output = fmt.Sprintf("%s", bo)
   match, _ := 
regexp.MatchString(".*errorDescription.*", 
output)
   if match == true {
      fileHandle, _ := 
os.OpenFile("./error.log", os.O_APPEND, 0666)
      writer := bufio.NewWriter(fileHandle)
      defer fileHandle.Close()
      fmt.Fprintln(writer, output)
      writer.Flush()
      return
   }
   b = true
   return
}

Los resultados son recibidos como una cadena JSON y necesitan estar ordenados con una estructura apropiada.

validPlayers := make([]map[string]string, 0)

lotteryAccount := "NXT-YXC4-RB92-F6MQ-2ZRA6"

type Attachment struct {
   Message       string `json:"message"`
   MessageIsText bool   `json:"messageIsText"`
}

type Transaction struct {
   Timestamp   int        `json:"timestamp"`
   AmountNQT   string     `json:"amountNQT"`
   ID          string     `json:"transaction"`
   SenderRS    string     `json:"senderRS"`
   RecipientRS string     `json:"recipientRS"`
   Attached    Attachment `json:"attachment"`
}

type Response struct {
   Transactions []Transaction 
`json:"transactions"`
}
Query := 
"requestType=getBlockchainTransactions&account=" +
lotteryAccount + 
"&type=0&subtype=0&executedOnly=true"

if v, a := sendQuery(Query, true); a == true {
   var transactions Response
   if err := json.Unmarshal([]byte(v), 
&transactions); err != nil {
      fmt.Println(err)
   }

 p := 0
 for k, _ := range transactions.Transactions {
    // code to check tickets for validity.
    // if transaction satisfies all criteria 
    // add it to the slice of valid tickets.
		
    validPlayers = append(validPlayers, 
make(map[string]string))
    validPlayers[p][txSender] = lotteryNumbers
    p++
			
   }
}

Ahora que “validPlayers” tiene todas las entradas correctas podemos iniciar el juego.

process() recibe un número entero (5, 4, o 3) y otros parámetros, incluyendo validPlayers y ejecuta tres rondas de la lotería. Se hace una llamada a la función getWinners(), que se llama genFive() para generar secuencias de números hasta que se encuentre al menos un ganador. getWinners() devuelve los resultados a process() y este es el encargado de: enviar la recompensa, eliminar el boleto ganador y devolver las entradas restantes a main() para rondas posteriores. Hay una función auxiliar denominada preparePlayers() que recrea validPlayers sin los espacios vacíos liberados por las entradas eliminadas.

Animo a todos los programadores que programen en el blockchain NXT. Es muy sencillo gracias al enlace API de todas sus funcionalidades del núcleo. https://nxtwiki.org/wiki/The_Nxt_API

Mi próxima aplicación será probablemente una aplicación de votación, con registros de votos inmutables y guardados en la blockchain. ¿Cree usted que una aplicación como esta puede resultar útil en el mundo moderno? Por cierto, Nxt tiene incorporado su propio sistema de votación. Es muy fácil olvidar lo que Nxt tiene, porque dispone de muchas características que son accesibles a través de la API, que se encuentra amablemente programada por los desarrolladores del núcleo de Nxt para favorecer su uso. Puedes ‘mínar’ tus primeras monedas NXT para enviar las transacciones al proyecto del nodo de la suerte que se ejecuta en un nodo público, acude a nxtforum.org y encontrarás la manera.
Por favor, dejen sus sugerencias y comentarios.

 


1. Lotería en nxtforum.org.

2. Para acceder al Nxt Data Cloud (Nube de datos de Nxt), descargue e instale el NRS (Nxt Reference Software 1.10.1) y busque la palabra clave lottery. Puedes descargar el código fuente desde cualquier servidor Nxt con las API abierta, por ejemplo:

Go-> http://23.94.134.161:7876/nxt?requestType=downloadTaggedData&transaction=7872865106538381099&retrieve=true PHP: http://23.94.134.161:7876/nxt?requestType=downloadTaggedData&transaction=13031806327722095646&retrieve=true

DE VUELTA AL POST.

Programando en la Blockchain de Nxt por diversión y para obtener ganancias

Las cadenas de bloques o blockchains son útiles para múltiples aplicaciones, permitiendo llegar a una audiencia global y reforzando la infraestructura interna de una compañía. Una blockchain es una base de datos distribuida, dónde una copia de esta cadena de bloques está almacenada en cada uno de los nodos de una red entre pares (red peer-to-peer o p2p). Esta redundancia extrema podría ser considerada ineficiente pero, por favor, déjame que te explique brevemente un poco de teoría sobre las blockchains.

Puesto que cada nodo valida todas las transacciones almacenadas en la blockchain y dado que las transacciones pasadas no pueden ser deshechas ni alteradas como sucede en los tradicionales Sistemas de Gestión de Bases de Datos Relacionales (RDBMS por sus siglas en inglés), esta redundancia convierte a la blockchain en “inmutable”, siendo este uno de los grandes valores de las cadenas de bloques. La inmutabilidad de la información es algo que las bases de datos tradicionales no pueden proporcionar. Puede que necesites, o no, esta inmutabilidad de los datos, así como una una confirmación, sin tener que confiar en terceros, de que los datos no han sido alterados.

En este tutorial presupongo que esto es lo que necesitas.

Una de las cadenas de bloques más versátiles y flexibles es la blockchain de Nxt (https://nxt.org). Cuenta con más de un centenar de llamadas API https://nxtwiki.org/wiki/The_Nxt_API.

En esta ocasión te voy a mostrarlos conceptos básicos para programas en la blockchain de Nxt. Sólo voy a usar dos llamadas API en este tutorial. Dado que existen más de un centenar de llamadas API posibles, las oportunidades para los programadores no tienen límite.

Lógica de aplicación

Un cliente de una compañía o un empleado de una organización sube un archivo a través de un formulario web.

El archivo es renombrado para dotarlo de un nombre único y es almacenado en algún lugar del servidor.

Un año más tarde el cliente / empleado necesita verificar, usando la blockchain de Nxt, que el archivo no ha sido alterado. Por ejemplo, esto puede ser necesario por motivos legales. No tiene porque ser sólamente archivos. A los memorandos internos de la compañía se les puede aplicar un algoritmo hash y ser incorporados a la base de datos, para poder ser verificados en una futura auditoría.

Nxt nos permite enviar y almacenar mensajes arbitrarios (M.A.) en su cadena de bloques.

Cada transacción en la blockchain acarrea una tasa o fee. Si el tamaño de la transacción es grande, podría ser caro. Afortunadamente Nxt tiene un subtipo de M.A. llamado mensaje podable. Estos mensajes son “podados” o eliminados pasados 90 días, lo que los hace más baratos. También sería posible recuperar estos mensajes pasados 90 días a partir de los Nodos de Archivo.

El tamaño máximo de un mensaje arbitrario en la blockchain de Nxt es de aproximadamente 42Kb, el tamaño de un bloque. Un mensaje podable de 1KB cuesta 1 NXT (0,03$). 1KB es suficiente para almacenar el hash de un archivo y este será nuestro coste final para almacenar permanentemente un hash en la inmutable y distribuida cadena de bloques de Nxt.

Tan pronto cómo el cliente sube el archivo yo creo un hash del tipo SHA256 del archivo y lo almaceno este hash en la base de datos del servidor de la organización. Por sencillez yo he elegido SQlite, pero puedes usar Mysql, Postgresql, Oracle. Usaré la extensión Objetos de Datos de PHP (PDO por sus siglas en inglés) para acceder a la base de datos SQlite en PHP.

Cuando no utilizamos la base de datos inmutable (blockchain), el archivo puede ser modificado, almacenarse en la base de datos el nuevo hash del archivo modificado, haciendo difícil demostrar que el archivo era el mismo que en un principio.

La blockchain viene al rescate

Cada mensaje podable se puede recuperar desde los nodos de archivo. Cada registro de la blockchain es inmutable. Puedes estar seguro de que el hash del archivo que subiste hace un año será el mismo cuando lo descargues de la cadena de bloques. Todo lo que necesitas hacer es compararlo con el hash del RBDMS interno de la organización.

Prerrequisitos:

PHP con curl, json y algún tipo de extensión de la base de datos (yo uso sqlite3). Un servidor web es opcional, puedes utilizar php-cli. Java 8 (Oracle o OpenJDK para ejecutar Nxt). Software de Referencia Nxt: https://nxtforum.org/nrs-releases/nrs-v1-10-1/.

Instala el Software de Referencia Nxt (NRS por sus siglas en inglés. Dependiendo del contexto se le llama indistintamente Cliente Nxt o Servidor Nxt) y crea una cuenta. Dótala con unas pocas monedas. Puedes intercambiar Bitcoin por Nxt en un servicio de exchange como https://shapeshift.io o intercámbialas directamente con otros usuarios en https://nxtforum.org. También es posible “minar” algunos NXT gratis como recompensa por tener un nodo: http://test.nxter.org/the-forging-bounty-lottery-campaign-will-pay-5-million-in-rewards-to-forgers-and-nxt-nodes/.

Primero creamos una base de datos sencilla para nuestra aplicación, nada extraordinario, si necesitas almacenar más información puedes añadir más columnas. A mí me gusta utilizar el navegador de bases de datos (DB browser) para SQLite de http://sqlitebrowser.org.

Vamos a crear una base de datos vacía llamada ‘files.db’ y la guardamos en /home/lurker10/phptutorial/files.db

Usando el DB browser para SQLite crea la siguiente tabla:

CREATE TABLE "files" (
`id` INTEGER PRIMARY KEY AUTOINCREMENT,
`txid` TEXT,
`hash` TEXT,
`uploadtime` TEXT,
`filename` TEXT
)

‘txid’ es el campo para almacenar el id de la transacción que recibimos de Nxt cuando la transacción es aceptada. Es único. ‘hash’ es el hash sha256 del archivo.

En este tutorial me voy a saltar la parte del código de subida de archivos para hacerlo más breve.

Vamos a suponer que el archivo ya ha sido subido y almacenado en el servidor web. Definimos la variable para la ubicación del archivo en el código:

$uploadDir = "/home/lurker10/phptutorial/tmp/";
$fileName = "copy12345.tar";

Por defecto, el servidor Nxt recibe las solicitudes API en el puerto 7876. Si lo estás ejecutando en la misma máquina que tu código php, tu código debe enviar solicitudes a http://127.0.0.1:7876/nxt

Las otras variables importantes son la contraseña de la cuenta de Nxt que has creado y dotado de fondos previamente, así como la cuenta del receptor.

Puedes enviarte un mensaje a ti mismo, puesto que el receptor puede ser tu misma cuenta.

$host = "http://127.0.0.1:7876/nxt";
$secretPhrase = "tu contraseña";
$recipientID = "NXT-XXXX-XXXX-XXXX-XXXXX";

La siguiente parte del código es la función que envía la consulta usando curl en una solicitud POST.

Para hacer una solicitud debemos definir las variables $payload y $payload_string y después alimentarlas para sendRequest(). Es posible ejecutar el Nxt Server sobre HTTPS y usar curl para verificar el certificado SSL, pero para hacer esta app más sencilla hemos desactivado la verificación SSL en la conexión curl.

Otro punto de interés es la descripción de $error, con descodificado json desde la respuesta del servidor.

Si hay un problema con la solicitud (“No hay fondos suficientes” en tu cuenta cuando el saldo es cero), tienes que añadir una rutina para el manejo de los errores. Voy a omitir esto también. Para esta app asumo que el servidor responde como corresponde, y devuelve la respuesta a la aplicación para su posterior procesado.

function sendRequest($host, $payload, $payload_string) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $host);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT_MS, 10000);
curl_setopt($ch, CURLOPT_TIMEOUT_MS, 10000);
curl_setopt($ch, CURLOPT_POST, count($payload));
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload_string);
$output = curl_exec($ch);
$curl_error = curl_error($ch);
curl_close($ch);
$errorDescription = trim(@json_decode($output)->errorDescription);
if ($errorDescription != "") { // perform error handling; return false; }
return $output;
}

Puesto que este archivo ya ha sido subido, creo un hash a sha256 del archivo y su marca de tiempo (timestamp):

$fileHash = hash_file("sha256", $uploadDir.$fileName);
$txTime = time();

Usaré PDO para trabajar con la base de datos.

Abre la base de datos e inserta una nueva entrada.

No sabemos el txid (identificador de transacción) hasta que hablamos con el servidor Nxt, que nos lo puede dar cuando la transacción ha sido aceptada en la red Nxt, así que por el momento insertar null para el txid.

$pdo = new PDO('sqlite:/home/lurker10/phptutorial/files.db');
$sql = "INSERT INTO files (txid, hash, uploadtime, filename)
VALUES (null, '$fileHash', '$txTime', '$fileName')";
$result = $pdo->exec($sql);

A continuación una solicitud para el envío al servidor Nxt.

Esta solicitud en particular es “sendMessage”. Puedes encontrar muchas más solicitudes con las que interactuar con la blockchain y sus parámetros obligatorios y opcionales en:

https://nxtwiki.org/wiki/The_Nxt_API.

Como ya he dicho antes, la fee por transacción es de 1NXT. 1 NXT = 100,000,000 NQT (nanoquantos).

1 NQTes la unidad más pequeña con la que se puede denominar a Nxt, similar a 1 satoshi en Bitcon.

El servidor Nxt acepta la fee en NQT, así que pagamos exactamente 100 millones de NQT (0,03$).

El parámetro “broadcast” se puede cambiar a false, en cuyo caso recibirás  ‘transactionBytes’ en la respuesta, que puede ser emitida a la red más adelante usando la petición ‘broadcastTransaction’. Pero en esta ocasión lo he fijado en ‘true’  para emitir la transacción instantáneamente.

Recuerda dotar de urlencode() al mensaje. Yo inserto el nombre de archivo en el mensaje separado del hash con una columna.

$payload = array(
"requestType" => "sendMessage",
"recipient" => $recipientID,
"secretPhrase" => urlencode($secretPhrase),
"feeNQT" => 100000000,
"deadline" => 1440,
"broadcast" => "true",
"message" => urlencode($fileName . ":" . $fileHash),
"messageIsPrunable" => "true"
);
$payload_string = "";
foreach ($payload as $key => $value) {
$payload_string .= $key . "=" . $value . "&";
}
rtrim($payload_string, "&");

Envía la petición al servidor NXT usando la función sendRequest():

$output = sendRequest($host, $payload, $payload_string);

y decodifica la respuesta JSON del servidor para obtener el identificador de la transacción:

if ($output != false) {
$txId = json_decode($output)->transaction;
}

Ahora que tenemos una respuesta positiva de la transacción aceptada y su ID es conocido, vamos a actualizar el registro en la base de datos local:

$lastId = $pdo->lastInsertId();
$sql = "UPDATE files SET txid = '$txId' where id = '$lastId'";
$result = $pdo->exec($sql);

Opcionalmente podemos proporcionar estos links a los clientes para consultas futuras y para demostrar que el hash ha sido subido:

echo "NXT Transaction ID: " . $txId . ",
JSON response";
echo "

Usa estos links para verificar el hash Sha256 del archivo guardado en tu base de datos local en lugar de un registro permanente en la blockchain de Nxt:

" . $fileHash;

Opcionalmente puedes enviarles por email a los clientes el $txId que podrán utilizar en un futuro para verificar el hash o, de algún otro modo más, proporcionales información acerca de como en un futuro recuperar información del hash de la base de datos propia y compararla con el hash almacenado en la blockchain, por el timestamp o por otro criterio.

Esta app no incluye autenticación del usuario. Normalmente el cliente o usuario de un servicio de intranet será capaz de ver sus archivos después de haberse autentificado en el sitio.

Esta aplicación también asume que la aplicación de verificación está fuera del alcance del que mantiene la base de datos interna, para evitar engaños en los datos de los resultados de verificación.

Ahora el registro es almacenado en la base de datos de la compañía. Muestra el registro de la base de datos para confirmar que se encuentra allí:

$sth = $pdo->prepare("SELECT id, txid, hash, uploadtime, filename FROM files ORDER BY id DESC");
$sth->execute();
$result = $sth->fetch(PDO::FETCH_OBJ);
if ($result != false) {
var_dump($result);
}

La aplicación de verificación

Para usar la verificación por hash el cliente tiene que tener el ID de la transacción en la blockchain de Nxt aprobada por ellos cuando la transacción fue enviada a la blockchain de Nxt.

Supongamos que el cliente la tiene, almacenada en el email o recuperada de algún otro modo. Aquí está:

$txId = "111111111111111111";

Vamos a ver lo que nuestra base de datos propia tiene para el hash del archivo. Busca y guarda en $hashInDb.

$pdo = new PDO('sqlite:/home/lurker10/phptutorial/files.db');
$sth = $pdo->prepare("SELECT hash FROM files where txid = '$txId'");
$sth->execute();
$result = $sth->fetch(PDO::FETCH_OBJ);
if ($result != false) {
$hashInDb = $result->hash;
}

Envía una petición al servidor NXT y busca toda la información almacenada en la blockchain de Nxt para transacciones con ese ID.

$payload = array (
"requestType" => "getTransaction",
"transaction" => $txId
);
$payload_string = "";
foreach ($payload as $key => $value) {
$payload_string .= $key . "=" . $value . "&";
}
rtrim($payload_string, "&");

$output = sendRequest($host, $payload, $payload_string);

Decodifica la respuesta JSON y extrae el campo añadido dónde se almacena el hash.

En la primera parte de la app nosotros almacenamos el nombre del archivo separado del hash con una columna. Ahora extraemos sólo la porción correspondiente al hash del mensaje arbitrario

$attachmentPlainData = json_decode($output)->attachment->message;
$hashInBlockchain = explode(":", $attachmentPlainData)[1];

Y compara lo que tenemos en la base de datos de la compañía con lo que fue almacenado hace 1 año en la blockchain de Nxt:

if ($hashInDb == $hashInBlockchain)
echo "Hashes are identical";
else
echo "Hashes are not identical";

NXT-crypto-developer

Cómo mercadear una organización descentralizada de código abierto

nxt-evildave

Por: Dave ‘EvilDave’ Pearce

Orígenes de la Fundación Nxt….

Una de las grandes fortalezas de Nxt, y de la comunidad Nxt en general, es que siempre se ha pretendido, desde el inicio del concepto de Nxt en adelante, que Nxt sea una comunidad fuertemente descentralizada.

El libro “La estrella de mar y la araña” de Ori Brafma, refleja una guía de gran utilidad sobre los principios básicos de una organización descentralizada.  https://en.wikipedia.org/wiki/The_Starfish_and_the_Spider

Una organización descentralizada puede estar bien para ciertas aplicaciones (como por ejemplo un movimiento activista) pero, para un sistema de software que necesita interactuar con la comunidad empresarial en general, ¿cómo puede la descentralización trabajar de manera efectiva?

Este asunto afloró desde los inicios del desarrollo de Nxt, dando lugar a más profundas preguntas:

  • Nxt es un brillante sistema que permite la construcción de aplicaciones de negocios, pero, ¿cómo conseguir que un negocio se ponga  en contacto con un movimiento descentralizado como la comunidad Nxt?
  • ¿Cómo establece una empresa un acuerdo legal con Nxt? o ¿recibe apoyo?
  • ¿Cómo puede Nxt promocionarse para los negocios o como puede Nxt llevar a cabo una campaña de PR?

Las respuestas a todo lo anterior llevó a la puesta en marcha de la Fundación Nxt que (si volvemos a la analogía de la “Estrella de mar”), puede ser visto como un órgano especializado para Nxt; una pierna extra para la estrella de mar.

forkpay-banner3

La Fundación fue creada para actuar como una subsección del ecosistema Nxt. Es responsable de la vinculación de la comunidad de código abierto descentralizada de Nxt, con la corriente principal del mundo de los negocios y las finanzas centralizadas. En efecto actúa como puerta de enlace entre el mundo de la criptografía descentralizada y las principales corrientes de negocios, finanzas y gobierno.

La fundación se inició (informalmente) por un grupo de veteranos de la joven comunidad Nxt  a mediados del 2014. El personal involucrado fue: Tai ‘Tai Zen’ Duong, David ‘EvilDave’ Pearce, Bas ‘Damelon’ Wisselink, Dirk ‘LocoMB’ Reuter y Ian ‘Chanc3r’ Ravenscroft. Como corresponde a un organizativo descentralizado, los miembros fundadores iniciales representaban una amplia gama de puntos de vista y poseían una amplia gama de habilidades.

Este grupo se reunió por primera vez, en la vida real, como representantes de Nxt en la innovadora conferencia Bitcoin 2014 celebrada en Ámsterdam y, funcionaron tan bien juntos que decidieron continuar bajo el informal estandarte de la Fundación Nxt.

En un principio, simplemente el pequeño grupo estaba pensado para ser un punto de contacto para las empresas, la Fundación Nxt ha demostrado ser muy útil para Nxt, y comenzó a evolucionar hacia una unidad de negocio en toda regla, con muchas más responsabilidades.

La Fundación fue registrada e incorporada, a inicios de 2015, como una empresa sin fines de lucro en los Países Bajos (Holanda), bajo el título de ‘Stichting Nxt/Nxt Foundation’ con el objetivo de apoyar la expansión y el desarrollo de Nxt.

Desde entonces, la Fundación Nxt ha seguido funcionando como punto de contacto para las empresas que deseen trabajar con Nxt. También ha asumido otras responsabilidades: la compra y mantenimiento de software esencial; tales como los certificados SSL y la firma de código, licencias de hosting y desarrollo para sitios relacionados con el núcleo de Nxt.

Más recientemente, la Fundación identificó algunas áreas que necesitaban ser mejoradas dentro Nxt y, puso en marcha el proyecto de Tennessee para hacer frente a esas áreas.

Entrando a Tennessee…

Hacia mediados de 2015, se hizo cada vez más evidente que Nxt necesitaba cambiar para satisfacer las demandas del, tan volátil, mercado de las criptomonedas. Muchos de los jugadores principales fueron entrando en el mercado, trayendo con ellos, desde la corriente del mundo de los negocios / finanzas, un enfoque más profesional para la gestión de los proyectos y un enfoque mucho más agresivo para las campañas de marketing y relaciones públicas.

Un proyecto descentralizado (y algo insuficientemente financiado) que requería un trabajo voluntario, como Nxt, no puede competir, a nivel de igualdad, con las campañas profesionales de marketing y de relaciones públicas empleadas por una nueva ola de proyectos relacionados con criptomonedas.

Los proyectos individuales basados en Nxt, usualmente con un grupo de pequeños líderes o un jefe de proyecto ya definido, pueden elegir por si mismos si siguen o no esta tendencia, o cómo responder a los cambios del mercado pero, para el núcleo Nxt (y, en general, para la comunidad Nxt) tenía que encontrarse una solución  para hacer frente a esta situación.

El proyecto Tennessee fue propuesto de esta manera: la Fundación Nxt analizó y explicó a la comunidad la situación actual del mercado y pidió una donación para un fondo administrativo de la Fundación – configurado exclusivamente para profesionalizar y mejorar dos elementos básicos del proyecto Nxt (CORE): Marketing / PR y la experiencia del usuario. El presupuesto estimado para ejecutar Tennessee durante un año (sobre la base de dos empleados a tiempo parcial) fue aproximadamente de  $ 70 mil, equivalente a 10 millones de NXT.

tnsse-crowdfunding-nxt

Esta suma se consiguió a través de crowdfunding (utilizando el Sistema Monetario Nxt) durante un periodo de 2 semanas y Tennessee se puso en marcha a principios de Noviembre de 2015.

TNSSE existe oficialmente desde hace menos de 4 semanas y hasta el momento dispone de:

Sueldos estipulados para las dos principales personas de Tennessee (trabajadores a tiempo parcial) durante los próximos 12 meses, asegurando que, durante ese tiempo habrá una presencia coherente de marketing / PR para Nxt.

Contrato con John Mcleod, consultor de contactos en los medios de comunicación (media contact consultant), con sede en Reino Unido. El contrato es inicialmente de 3 meses, pero con la posibilidad de extender ese periodo. La función de John es buscar y cultivar, de manera proactiva, la corriente principal (mainstream) y los principales medios de comunicación sobre criptomonedas, para Tenessee y Nxt.

Con la ayuda de John, Tennessee ha creado y publicado 2 los artículos sobre los aspectos de Nxt durante la última semana:

https://news.bitcoin.com/interview-nxt-foundations-dave-pearce/

http://allcoinsnews.com/2015/11/21/nxt-foundation-positions-platform-to-entirely-replace-legacy-banking-systems/

También hizo una entrevista de radio:
https://www.mixcloud.com/Resonance/password-18-11-15/

Estas tres piezas son sólo el comienzo de la campaña en los medios de comunicación. TNSSE permite a Nxt construir relaciones de más largo plazo con los medios de comunicación, y estas relaciones darán lugar a más información periódica sobre Nxt, apareciendo en los principales medios de comunicación criptográficos.

Tennessee, también ha iniciado el proyecto de revisión de la presencia de Nxt en la web, www.nxt.org será el primer sitio web en ser actualizado usando, como contratista externo, a Farla Webmedia.

La nueva web www.nxt.org contará con un rasgo importante: un sistema de asistencia fácil de usar, proporcionando a Nxt una ventaja única sobre todos los demás criptoproyectos.

La Fundación Nxt junto al proyecto Tennessee, ha comenzado a trabajar en una estrategia de asistencia a la conferencia, para el año siguiente. Una conferencia centrada en las propuestas de Nxt para la primera mitad de 2016 y la presencia de Nxt en el próximo evento d10e, en Ámsterdam.

http://www.d10e.org/#amsterdam

Así que, volviendo a la pregunta inicial: ¿cómo una comunidad descentralizada puede promocionarse al mundo exterior?

Nxt ha demostrado, con la creación de la Fundación Nxt y posteriormente con el proyecto Tennessee, que los sistemas especializados creados de forma orgánica pueden configurarse para cumplir con esta función específica, sin sacrificar nada de franqueza ni descentralización que otorga a la comunidad Nxt un alto grado de  flexibilidad y fuerza.

El valor de 10 NXT

Introducción

Quizás se preguntan cuál es el valor de 10 NXT. Este artículo se propone contestar a esta pregunta. Pero empecemos con un pequeño dialogo:

“¿Cual es el valor de 10 €?”, pregunta un profesor a sus alumnos. “10 €, ¡por supuesto!”, responde enseguida uno de ellos.

“Pues intenta explicarte sin utilizar 10 €.” El estudiante reflexiona y contesta finalmente, sin convicción: “¿Diez veces 1 €?” Pero el profesor todavía no está satisfecho: “Entonces, ¿cuál es el valor de 1 €?” Otro alumno propone: “10 € tiene como valor lo que se puede comprar con esta cantidad de euros.”

Esta conversación ilustra el error que hace la mayoría de la gente cuando se trata de entender cuál es el valor de sus bienes o de sus ingresos. Demuestra también con pocas palabras de qué modo la gente percibe el valor de una unidad monetaria como el euro: el valor de 1 € solo sería la cantidad de bienes o de servicios que se puede obtener con 1 € (en otras palabras: su poder adquisitivo).

Pero alguien podría preguntar: ¿cómo medir el valor de 1 €? Une respuesta simplista sería: se mide a la cantidad de bienes o de servicios que permite comprar. Une definición más elaborada, pero igual de inadecuada (porque resulta también de varias definiciones artificiales), implica tipo de cambio, bonos de tesorería y reservas de divisas. El valor de 1 €, como para cualquier divisa, depende por consiguiente de factores alejados de la vida cotidiana. Como lo veremos en la sección siguiente, es difícil entender el valor real del euro a diario a pesar del hecho que cada uno de nosotros lo utiliza todos los días.

 1. Bienes y servicios

Uno de los problemas relacionados con la utilización de bienes et de servicios para cuantificar el valor de una divisa es la falta de posibilidad de intercambio: mientras una moneda de 1 € se puede cambiar con cualquiera moneda de 1 €, los bienes y servicios (aun si tienen el mismo valor) no son espontáneamente intercambiables. Esta falta de intercambiabilidad hace imposible la comparación, por ejemplo, de diez botellas de cerveza (que costaron 10 €) con, digamos, cinco barras de pan (que costaron también 10 €). De hecho, estamos frente al mismo problema que el encontrado por los estadísticos cuando han tenido que elegir entre los bienes de consumo que debían incluir en la cesta de la compra media del consumidor a fin de seguir la evolución del costo de la vida de un país.

Lo que pasa es que la utilización de cifras crea una ilusión de estabilidad para cosas que en realidad no lo son. La gente por lo tanto entiende difícilmente cual es el valor real de 10 € o la de “cinco barras de pan”, los cuales, en realidad, son igual de imprecisos el uno como el otro: un billete de euros, aun si es intercambiable, no tiene ningún valor intrínseco. En cambio, los bienes adquiribles con unos billetes de euros, aun si tampoco tienen algún valor intrínseco, no son intercambiables y por tanto no pueden servir de base para la evaluación de cualquier valor.

La falta de precisión puede ser atribuida a la falta de herramientas de medida para determinar de manera reproducible el valor de algo, sin tener en cuenta el lugar, el momento, ni por quien ha sido comprado o vendido. Su mejor aproximación es el precio del mercado expresado en moneda local. Sin embargo, el precio del mercado no siempre refleja su valor real.

Aun siendo un indicador de valor importante, el precio del mercado solo indica el importe mínimo que la gente está dispuesta a pagar, y no el importe máximo (en otras palabras, su voluntad de pagar). Además, a causa de factores exteriores, las infravaloraciones o las sobrevaloraciones son siempre posibles. Los precios a corto plazo, por ejemplo, pueden ser inferiores o superiores a la media de largo plazo.

La necesidad de tener herramientas de medida, como dicho antes, es evidente. Cuando por ejemplo se entra en una tienda y se pregunta por el precio de un producto, la respuesta será diferente según que la tienda esté ubicada en América del Norte o en Asia (independientemente del tipo de conversión). Si volvemos diez años más tarde, los precios habrán cambiado también. Además, las empresas ajustan sus precios en función de las necesidades de sus socios o de sus clientes caso por caso.

Por eso, preguntarse cómo los precios están creados y cómo evolucionan tiene plena legitimidad. Da lugar a un estudio permanente que supera el tema de este artículo. Los precios son el fruto de una interacción social, de consideraciones políticas, de emociones e incluso de adelantos tecnológicos. En la última parte de este articulo, hablaremos del valor del NXT.

 2. Transacciones

Cuando se utiliza la plataforma NXT, solo se necesitan unos NXT. Se pueden comprar bienes o servicios en la plataforma NXT (Marketplace), se pueden comprar activos en la bolsa de intercambio de activos (Asset Exchange), se pueden comprar marcas, votar, y aún más. Y para hacer eso lo único que se necesita son unos NXT. Estas fichas son la moneda por defecto de la plataforma económica NXT. Con esos NXT, se pueden comprar unos cuantos productos relacionados con la plataforma NXT, el contenido puesto a disposición por otros usuarios, así como bienes y servicios. Sin embargo, el valor de 10 NXT es tan impreciso como el de 10 €.

En cambio existe otro elemento importante para determinar cuál es el valor de 1 NXT. Los NXT no solo sirven para adquirir bienes y servicios, pero también para pagar los costes de transacción. Las transacciones son los objetos los más básicos que se pueden comprar con NXT. En la plataforma NXT están, y siempre estarán, en todas partes. A la hora de redactar estas líneas, hacer una transacción cuesta 1 NXT en la mayoría de los casos.

Por lo tanto, el valor de 10 NXT corresponde a la posibilidad de comprar diez transacciones estándar, como las que hemos descrito más arriba. Significa que por n NXT contenidos en su cartera, se puede hace n transacciones en la red.

Podemos describir un experimento para evaluar el precio de una transacción en NXT. El precio de una transacción-en otras palabras, los “gastos de transacción”-tiene un valor mínimo de tal manera que permite a la red de aceptar la transacción. Este precio esta codificado dentro mismo del contrato social vigente en la red NXT, y su implementación se encuentra en este depósito. Este experimento puede ser reproducido independientemente de quién es usted y del lugar donde se encuentra. Este coste puede ser modificado en el futuro pero solo si la red acepta el cambio. En este sentido, el importe de los costes de transacción mínimos es el precio más justo y más transparente que está disponible. No guarda relación alguna con usted o su ubicación geográfica.

Gracias a esta herramienta, ahora podemos evaluar el valor de un bien o de un servicio en términos de transacciones. Cuando pagamos 25 NXT a alguien para una prestación, le damos la oportunidad de hacer veinticinco transacciones mas, mientras nosotros podremos hacer veinticinco transacciones menos que antes.

Analizando el cálculo del importe mínimo de los costes de transacción, aparece una correlación entre esos gastos y el tamaño de la transacción. Sin embargo, la correlación no se aplicará, como es actualmente el caso, mientras el coeficiente correspondiente esté puesto a cero. Es probable que en las futuras versiones del protocolo NXT la red decida aumentar este coeficiente a fin de reflejar mejor el coste actual de verificación y de propagación de ciertos tipos de transacciones dentro de la red. Pero lo cierto es que le proceso de definición del precio es visible, averiguable y idéntico para todos los usuarios de NXT. Hay miles de maneras para ponerse de acuerdo en cuanto a esos coeficientes y a otras constantes que entran en el cálculo de los gastos de transacción. Hablaremos de eso en un próximo artículo.

 Conclusión

Como cada NXT representa la posibilidad de comprar exactamente una transacción estándar, tenemos un instrumento de trabajo preciso para medir el valor de un bien o un servicio. En vez de preguntar cuánto cuesta algo, deberíamos preguntarnos cuánto nos cuesta en términos de cantidad de transacciones. Del mismo modo, el vendedor, en vez de solo preguntarse cuántos NXT se ganaría en cambio de la venta de un bien o un servicio, podría ver sus beneficios en NXT como una manera de aumentar el nombre de transacciones que se le permitirá hacer en el futuro.

Por lo tanto, el valor de 10 NXT es igual a la posibilidad de llevar a cabo diez transacciones diferentes, así como a los bienes y servicios que se obtienen en cambio.

[Traducido por Caracalla]