Bitcoin Cryptocurrency Application with Node.js + NoSQL

Llevo unos meses siguiendo temas relacionados con las criptomonedas como Bitcoin y estoy muy fascinado con todo lo que está pasando.

Como desarrollador de aplicaciones web, uno de los temas que más me interesan es el de los intercambios de criptomonedas y cómo crearlos. De entrada, estas aplicaciones parecen ser herramientas para gestionar cuentas, convertir Bitcoin a una moneda fiduciaria como el USD y viceversa, y transferir Bitcoin a otras personas, pero ¿son más?

Vamos a ver algunos ejemplos con Node.js y la base de datos NoSQL, Couchbaseque trata temas relacionados con las bolsas de criptomonedas.

Actualizaciones sobre temas relacionados:

Descargo de responsabilidad: No soy un experto en criptodivisas, ni he participado en ningún desarrollo en torno a servicios financieros o intercambios. Soy un entusiasta de la materia y cualquier cosa obtenida de este artículo debe ser debidamente probado y utilizado bajo su propio riesgo.

Para llevar

Hay algunas cosas que obtendrás y que no obtendrás de este artículo en particular. Por ejemplo, vamos a empezar con las cosas que no obtendrá de este artículo:

No configuraremos ningún servicio bancario o de tarjeta de crédito para transferir monedas fiduciarias como el USD.
No emitiremos ninguna transacción firmada a la red Bitcoin, finalizando una transferencia.

Dicho esto, he aquí algunas cosas que puede esperar aprender en este artículo:

Crearemos un monedero determinista jerárquico (HD) que puede generar una cantidad ilimitada de claves para una semilla dada, cada una representando un monedero de usuario.
Crearemos cuentas de usuario cada una con monederos basados en la semilla maestra.
Crearemos transacciones que representen depósitos, retiradas y transferencias de fondos de la bolsa, sin trabajar realmente con una moneda fiduciaria.
Buscaremos saldos en la red Bitcoin.
Crearemos transacciones firmadas que se difundirán en la red Bitcoin.

Hay muchas cosas que veremos en este artículo que se pueden hacer mucho mejor. Si has encontrado algo que se pueda mejorar, compártelo en los comentarios. Como ya he dicho, no soy un experto en el tema, solo un aficionado.

Requisitos del proyecto

Hay algunos requisitos que deben cumplirse para tener éxito con este proyecto:

Debes tener Node.js 6+ instalado y configurado.
Debes tener Couchbase 5.1+ instalado y configurado con un Bucket y un perfil RBAC listo para funcionar.

El punto principal es que no voy a ir a través de cómo obtener Couchbase en marcha y funcionando. No es un proceso difícil, pero necesitarás un Bucket configurado con una cuenta de aplicación y un índice para realizar consultas con N1QL.

Creación de una aplicación Node.js con dependencias

Vamos a crear una nueva aplicación Node.js y descargar las dependencias antes de empezar a añadir cualquier lógica. Crea un directorio de proyecto en algún lugar de tu ordenador y ejecuta los siguientes comandos desde un CLI dentro de ese directorio:

npm init -y
npm install couchbase --save
npm install express --save
npm install body-parser --save
npm install joi --save
npm install request request-promise --save
npm install uuid --save
npm install bitcore-lib --save
npm install bitcore-mnemonic --save

npm init -y

npm instale couchbase --guardar

npm instale express --guardar

npm instale cuerpo-analizador --guardar

npm instale joi --guardar

npm instale solicitar solicitar-promesa --guardar

npm instale uuid --guardar

npm instale bitcore-lib --guardar

npm instale bitcore-mnemotécnico --guardar

Sé que podría haber hecho todas las instalaciones de dependencias en una sola línea, pero quería que fueran claras de leer. Entonces, ¿qué estamos haciendo en los comandos anteriores?

En primer lugar, vamos a inicializar un nuevo proyecto Node.js creando un archivo paquete.json archivo. A continuación, vamos a descargar nuestras dependencias y añadirlos a la paquete.json a través de --guardar bandera.

Para este ejemplo utilizaremos Express Framework. El sitio express, body-parsery joi son todos relevantes para aceptar y validar datos de petición. Dado que nos comunicaremos con nodos Bitcoin públicos, utilizaremos el paquete solicitar y solicitud-promesa paquete para envolver promesas. El muy popular bitcore-lib nos permitirá crear monederos y firmar transacciones mientras que el paquete bitcore-mnemónico nos permitirá generar una semilla que podremos utilizar para nuestras claves de monedero HD. Finalmente, couchbase y uuid se utilizará para trabajar con nuestra base de datos.

Ahora probablemente queramos estructurar mejor nuestro proyecto. Añade los siguientes directorios y archivos dentro del directorio de tu proyecto si no existen ya:

package.json
config.json
app.js
routes
    account.js
    transaction.js
    utility.js
classes
    helper.js

paquete.json

config.json

aplicación.js

rutas

cuenta.js

transacción.js

utilidad.js

clases

ayudante.js

Todos nuestros puntos finales de API se dividirán en categorías y se colocarán en cada archivo de enrutamiento apropiado. No tenemos que hacer esto, pero hace que nuestro proyecto sea un poco más limpio. Para eliminar una tonelada de Bitcoin y la lógica de base de datos fuera de nuestras rutas, vamos a añadir todo lo que no es la validación de datos en nuestra clases/helper.js expediente. La dirección config.json tendrá toda la información de nuestra base de datos, así como nuestra semilla mnemotécnica. En un escenario realista, este archivo debería ser tratado como oro y recibir toda la protección posible. La dirección app.js tendrá toda nuestra configuración y lógica de arranque para conectar nuestras rutas, conectarse a la base de datos, etc.

Por comodidad, vamos a añadir una dependencia más a nuestro proyecto y configurarlo:

npm install nodemon --save-dev

1	npm instale nodemon --guardar-dev

En nodemon nos permitirá recargar en caliente nuestro proyecto cada vez que cambiemos un archivo. No es un requisito, pero nos puede ahorrar algo de tiempo mientras estamos construyendo.

Abra el paquete.json y añada la siguiente secuencia de comandos:

...
"scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "./node_modules/nodemon/bin/nodemon.js app.js"
},
...

...

"scripts": {

"test": "echo "Error: no se ha especificado ninguna prueba" && exit 1",

"inicio": "./node_modules/nodemon/bin/nodemon.js app.js"

...

En este punto podemos iniciar el proceso de desarrollo de nuestra aplicación.

Desarrollo de la base de datos y la lógica Bitcoin

A la hora de desarrollar nuestra aplicación, antes de empezar a preocuparnos por los puntos finales de la API, queremos crear nuestra base de datos y la lógica relacionada con Bitcoin.

Vamos a pasar nuestro tiempo en el proyecto de clases/helper.js . Ábralo e incluya lo siguiente:

const Couchbase = require("couchbase");
const Request = require("request-promise");
const UUID = require("uuid");
const Bitcore = require("bitcore-lib");

class Helper {

    constructor(host, bucket, username, password, seed) {
        this.cluster = new Couchbase.Cluster("couchbase://" + host);
        this.cluster.authenticate(username, password);
        this.bucket = this.cluster.openBucket(bucket);
        this.master = seed;
    }

    createKeyPair(account) { }

    getWalletBalance(addresses) { }

    getAddressBalance(address) { }

    getAddressUtxo(address) { }

    insert(data, id = UUID.v4()) { }

    createAccount(data) { }

    addAddress(account) { }

    getAccountBalance(account) { }

    getMasterAddresses() { }

    getMasterKeyPairs() { }

    getMasterAddressWithMinimum(addresses, amount) { }

    getMasterChangeAddress() { }

    getAddresses(account) { }

    getPrivateKeyFromAddress(account, address) { }

    createTransactionFromAccount(account, source, destination, amount) { }

    createTransactionFromMaster(account, destination, amount) { }

}

module.exports = Helper;

const Couchbase = requiere("couchbase");

const Solicitar = requiere("solicitud-promesa");

const UUID = requiere("uuid");

const Bitcore = requiere("bitcore-lib");

clase Ayudante {

constructor(host, cubo, nombre de usuario, contraseña, semilla) {

este.grupo = nuevo Couchbase.Grupo("couchbase://" + host);

este.grupo.autentifique(nombre de usuario, contraseña);

este.cubo = este.grupo.openBucket(cubo);

este.maestro = semilla;

}

createKeyPair(cuenta) { }

getWalletBalance(direcciones) { }

getAddressBalance(dirección) { }

getAddressUtxo(dirección) { }

insertar(datos, id = UUID.v4()) { }

crearCuenta(datos) { }

addAddress(cuenta) { }

getAccountBalance(cuenta) { }

getMasterAddresses() { }

getMasterKeyPairs() { }

getDirecciónMaestraConMínimo(direcciones, importe) { }

getMasterChangeAddress() { }

getAddresses(cuenta) { }

getPrivateKeyFromAddress(cuenta, dirección) { }

createTransactionFromAccount(cuenta, fuente, destino, importe) { }

createTransactionFromMaster(cuenta, destino, importe) { }

}

módulo.exportaciones = Ayudante;

Vamos a pasar esta clase como un singleton para nuestra aplicación. En el constructor establecemos una conexión con nuestro clúster de base de datos, abrimos un Bucket y nos autenticamos. El Bucket abierto se utilizará a lo largo de esta clase de ayuda.

Acabemos con la lógica de Bitcoin antes que la de la base de datos.

Si no estás familiarizado con los monederos HD, son esencialmente un monedero derivado de una única semilla. Usando la semilla puedes derivar hijos y esos hijos pueden tener hijos, y así sucesivamente.

createKeyPair(account) {
    var account = this.master.deriveChild(account);
    var key = account.deriveChild(Math.random() * 10000 + 1);
    return { "secret": key.privateKey.toWIF().toString(), "address": key.privateKey.toAddress().toString() }
}

createKeyPair(cuenta) {

var cuenta = este.maestro.deriveChild(cuenta);

var clave = cuenta.deriveChild(Matemáticas.al azar() * 10000 + 1);

devolver { "secreto": clave.privateKey.toWIF().toString(), "dirección": clave.privateKey.toAddress().toString() }

}

En maestro variable en el createKeyPair representa la clave semilla de nivel superior. Cada cuenta de usuario será un hijo directo de esa clave, de ahí que estemos derivando un hijo basado en una función cuenta valor. En cuenta es un número de persona y cada cuenta creada obtendrá un número incremental. Sin embargo, no vamos a generar claves de cuenta y darlo por terminado. En su lugar, cada clave de cuenta tendrá 10.000 posibles claves privadas y públicas en caso de que no quieran usar la misma clave más de una vez. Una vez que hemos generado una clave al azar, la devolvemos.

Del mismo modo, tenemos un getMasterChangeAddress como la siguiente:

getMasterChangeAddress() {
    var account = this.master.deriveChild(0);
    var key = account.deriveChild(Math.random() * 10 + 1);
    return { "secret": key.privateKey.toWIF().toString(), "address": key.privateKey.toAddress().toString() }
}

getMasterChangeAddress() {

var cuenta = este.maestro.deriveChild(0);

var clave = cuenta.deriveChild(Matemáticas.al azar() * 10 + 1);

devolver { "secreto": clave.privateKey.toWIF().toString(), "dirección": clave.privateKey.toAddress().toString() }

}

Cuando empecemos a crear cuentas, empezarán en uno, dejando cero para el intercambio o la aplicación web, o como quieras llamarlo. También estamos asignando 10 posibles direcciones a esta cuenta. Estas direcciones harán dos cosas posibles. La primera es que guardarán Bitcoin para transferir a otras cuentas y la segunda es que recibirán pagos restantes, también conocido como el cambio. Recuerde, en una transacción Bitcoin, todo el producto de la transacción no gastado (UTXO) debe ser gastado, incluso si es menor que la cantidad deseada. Esto significa que la cantidad deseada se envía al destino y el resto se devuelve a una de estas 10 direcciones.

¿Hay otras formas o formas mejores de hacerlo? Por supuesto, pero ésta servirá para el ejemplo.

Para obtener el saldo de cualquier dirección que utilicemos o generemos utilizando la semilla HD, podemos utilizar un explorador público de Bitcoin:

getAddressBalance(address) {
    return Request("https://insight.bitpay.com/api/addr/" + address);
}

getAddressBalance(dirección) {

devolver Solicitar("https://insight.bitpay.com/api/addr/" + dirección);

}

La función anterior tomará una dirección y obtendrá el saldo tanto en formato decimal como en satoshis. En adelante, el valor satoshi es el único valor relevante para nosotros. Si tenemos X número de direcciones para una cuenta dada, podemos obtener el saldo total utilizando una función como esta:

getWalletBalance(addresses) {
    var promises = [];
    for(var i = 0; i < addresses.length; i++) {
        promises.push(Request("https://insight.bitpay.com/api/addr/" + addresses[i]));
    }
    return Promise.all(promises).then(result => {
        var balance = result.reduce((a, b) => a + JSON.parse(b).balanceSat, 0);
        return new Promise((resolve, reject) => {
            resolve({ "balance": balance });
        });
    });
}

getWalletBalance(direcciones) {

var promete = [];

para(var i = 0; i < direcciones.longitud; i++) {

promete.pulse(Solicitar("https://insight.bitpay.com/api/addr/" + direcciones[i]));

}

devolver Promesa.todos(promete).entonces(resultado => {

var saldo = resultado.reducir((a, b) => a + JSON.analizar(b).balanceSat, 0);

devolver nuevo Promesa((resolver, rechace) => {

resolver({ "equilibrio": saldo });

});

}

En el getWalletBalance función estamos haciendo una solicitud para cada dirección y cuando todos han completado, podemos añadir los saldos y devolverlos.

Se necesita algo más que el saldo de una dirección para poder transferir criptomoneda. En su lugar, necesitamos conocer la salida de transacción no gastada (UTXO) para una dirección dada. Esto se puede encontrar utilizando la misma API de BitPay:

getAddressUtxo(address) {
    return Request("https://insight.bitpay.com/api/addr/" + address + "/utxo").then(utxo => {
        return new Promise((resolve, reject) => {
            if(JSON.parse(utxo).length == 0) {
                reject({ "message": "There are no unspent transactions available." });
            }
            resolve(JSON.parse(utxo));
        });
    });
}

getAddressUtxo(dirección) {

devolver Solicitar("https://insight.bitpay.com/api/addr/" + dirección + "/utxo").entonces(utxo => {

devolver nuevo Promesa((resolver, rechace) => {

si(JSON.analizar(utxo).longitud == 0) {

rechace({ "mensaje": "No hay transacciones no gastadas disponibles". });

}

resolver(JSON.analizar(utxo));

});

}

Si no hay salida de transacción no gastada, significa que no hay nada que podamos transferir y deberíamos lanzar un error en su lugar. Tener suficiente para transferir es otra historia.

Por ejemplo, podríamos hacer algo así:

getMasterAddressWithMinimum(addresses, amount) {
    var promises = [];
    for(var i = 0; i < addresses.length; i++) {
        promises.push(Request("https://insight.bitpay.com/api/addr/" + addresses[i]));
    }
    return Promise.all(promises).then(result => {
        for(var i = 0; i < result.length; i++) {
            if(result[i].balanceSat >= amount) {
                return resolve({ "address": result[i].addrStr });
            }
        }
        reject({ "message": "Not enough funds in exchange" });
    });
}

getDirecciónMaestraConMínimo(direcciones, importe) {

var promete = [];

para(var i = 0; i < direcciones.longitud; i++) {

promete.pulse(Solicitar("https://insight.bitpay.com/api/addr/" + direcciones[i]));

}

devolver Promesa.todos(promete).entonces(resultado => {

para(var i = 0; i < resultado.longitud; i++) {

si(resultado[i].balanceSat >= importe) {

devolver resolver({ "dirección": resultado[i].addrStr });

}

rechace({ "mensaje": "No hay fondos suficientes a cambio" });

});

}

En la función anterior, estamos tomando una lista de direcciones y comprobando cuál de ellas tiene una cantidad superior al umbral que proporcionamos. Si ninguna de ellas tiene saldo suficiente, probablemente deberíamos transmitir ese mensaje.

La última función relacionada con la utilidad es algo que ya hemos visto:

getMasterKeyPairs() {
    var keypairs = [];
    var key;
    var account = this.master.deriveChild(0);
    for(var i = 1; i <= 10; i++) {
        key = account.deriveChild(i);
        keypairs.push({ "secret": key.privateKey.toWIF().toString(), "address": key.privateKey.toAddress().toString() });
    }
    return keypairs;
}

getMasterKeyPairs() {

var pares de claves = [];

var clave;

var cuenta = este.maestro.deriveChild(0);

para(var i = 1; i <= 10; i++) {

clave = cuenta.deriveChild(i);

pares de claves.pulse({ "secreto": clave.privateKey.toWIF().toString(), "dirección": clave.privateKey.toAddress().toString() });

}

devolver pares de claves;

}

La función anterior nos obtendrá todas las claves maestras, que serán útiles para firmar y comprobar el valor.

Sólo para reiterar, estoy usando un valor finito para el número de claves que se generan. Usted puede o no puede querer hacer lo mismo, depende de usted.

Ahora vamos a sumergirnos en algo de lógica NoSQL para almacenar los datos de nuestra aplicación.

En este momento no hay datos en nuestra base de datos. El primer paso lógico podría ser crear algunos datos. Aunque no es particularmente difícil de forma independiente, podemos crear una función como esta:

insert(data, id = UUID.v4()) {
    return new Promise((resolve, reject) => {
        this.bucket.insert(id, data, (error, result) => {
            if(error) {
                reject({ "code": error.code, "message": error.message });
            }
            data.id = id;
            resolve(data);
        });
    });
}

insertar(datos, id = UUID.v4()) {

devolver nuevo Promesa((resolver, rechace) => {

este.cubo.insertar(id, datos, (error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

datos.id = id;

resolver(datos);

});

}

Esencialmente, estamos aceptando un objeto y un id para ser utilizado como una clave de documento. Si no se proporciona una clave de documento, la generaremos automáticamente. Cuando todo esté dicho y hecho, devolveremos lo que fue creado incluyendo el id en la respuesta.

Digamos que queremos crear una cuenta de usuario. Podemos hacer lo siguiente:

createAccount(data) {
    return new Promise((resolve, reject) => {
        this.bucket.counter("accounts::total", 1, { "initial": 1 }, (error, result) => {
            if(error) {
                reject({ "code": error.code, "message": error.message });
            }
            data.account = result.value;
            this.insert(data).then(result => {
                resolve(result);
            }, error => {
                reject(error);
            });
        });
    });
}

crearCuenta(datos) {

devolver nuevo Promesa((resolver, rechace) => {

este.cubo.contador("cuentas::total", 1, { "inicial": 1 }, (error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

datos.cuenta = resultado.valor;

este.insertar(datos).entonces(resultado => {

resolver(resultado);

}, error => {

rechace(error);

});

}

Recuerde, las cuentas son manejadas por un valor numérico auto incremental para este ejemplo. Podemos crear valores incrementales utilizando un contador en Couchbase. Si el contador no existe, lo inicializaremos a 1 y lo incrementaremos en cada siguiente llamada. Recuerda, 0 está reservado para claves de aplicación.

Después de obtener el valor de nuestro contador, lo añadimos al objeto pasado y llamamos a nuestra función de inserción, que en este caso genera un identificador único para nosotros.

Todavía no lo hemos visto porque no tenemos ningún endpoint, pero vamos a suponer que cuando creamos una cuenta, no tiene información de dirección, sólo un identificador de cuenta. Podríamos querer añadir una dirección para el usuario:

addAddress(account) {
    return new Promise((resolve, reject) => {
        this.bucket.get(account, (error, result) => {
            if(error) {
                reject({ "code": error.code, "message": error.message });
            }
            var keypair = this.createKeyPair(result.value.account);
            this.bucket.mutateIn(account).arrayAppend("addresses", keypair, true).execute((error, result) => {
                if(error) {
                    reject({ "code": error.code, "message": error.message });
                }
                resolve({ "address": keypair.address });
            });
        });
    });
}

addAddress(cuenta) {

devolver nuevo Promesa((resolver, rechace) => {

este.cubo.consiga(cuenta, (error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

var par de claves = este.createKeyPair(resultado.valor.cuenta);

este.cubo.mutateIn(cuenta).arrayAppend("direcciones", par de claves, verdadero).ejecutar((error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

resolver({ "dirección": par de claves.dirección });

});

}

Al añadir una dirección, primero obtenemos el usuario por el id del documento. Cuando se recupera el documento, obtenemos el valor numérico de la cuenta y creamos un nuevo par de claves de nuestras 10.000 opciones. Utilizando un subdocumento podemos añadir el par de claves al documento de usuario sin tener que descargar el documento ni manipularlo.

Hay que tener en cuenta algo muy serio sobre lo que acabamos de hacer.

Estoy almacenando la clave privada sin cifrar y la dirección pública en el documento de usuario. Esto es un gran no-no para la producción. ¿Recuerdas todas esas historias que has leído sobre gente a la que le han robado sus claves? En realidad, querríamos cifrar los datos antes de insertarlos. Podemos hacerlo usando la librería crypto de Node.js, o si estamos usando Couchbase Server 5.5, el SDK de Node.js para Couchbase ofrece encriptación. Sin embargo, no lo exploraremos aquí.

Bien, ya tenemos los datos de las cuentas y las direcciones en la base de datos. Vamos a consultar esos datos:

getAddresses(account) {
    var statement, params;
    if(account) {
        statement = "SELECT VALUE addresses.address FROM " + this.bucket._name + " AS account USE KEYS $id UNNEST account.addresses as addresses";
        params = { "id": account };
    } else {
        statement = "SELECT VALUE addresses.address FROM " + this.bucket._name + " AS account UNNEST account.addresses as addresses WHERE account.type = 'account'";
    }
    var query = Couchbase.N1qlQuery.fromString(statement);
    return new Promise((resolve, reject) => {
        this.bucket.query(query, params, (error, result) => {
            if(error) {
                reject({ "code": error.code, "message": error.message });
            }
            resolve(result);
        });
    });
}

getAddresses(cuenta) {

var declaración, parámetros;

si(cuenta) {

declaración = "SELECT VALUE direcciones.dirección FROM" + este.cubo.Nombre + " AS account USE KEYS $id UNNEST account.addresses as addresses";

parámetros = { "id": cuenta };

} si no {

declaración = "SELECT VALUE direcciones.dirección FROM" + este.cubo.Nombre + " AS account UNNEST account.addresses as addresses WHERE account.type = 'account'";

}

var consulta = Couchbase.N1qlQuery.fromString(declaración);

devolver nuevo Promesa((resolver, rechace) => {

este.cubo.consulta(consulta, parámetros, (error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

resolver(resultado);

});

}

Lo anterior getAddresses puede hacer una de dos cosas. Si se proporcionó una cuenta, utilizaremos una consulta N1QL para obtener todas las direcciones de esa cuenta en particular. Si no se proporcionó ninguna cuenta, obtendremos todas las direcciones de todas las cuentas de la base de datos. En ambos casos, sólo obtendremos las direcciones públicas, nada confidencial. Usando una consulta N1QL parametrizada, podemos devolver los resultados de la base de datos al cliente.

Algo a tener en cuenta en nuestra consulta.

Estamos almacenando nuestras direcciones en un array en los documentos de usuario. Utilizando un UNNEST podemos aplanar esas direcciones y hacer que la respuesta sea más atractiva.

Supongamos ahora que tenemos una dirección y queremos obtener la clave privada correspondiente. Podríamos hacer lo siguiente:

getPrivateKeyFromAddress(account, address) {
    var statement = "SELECT VALUE keypairs.secret FROM " + this.bucket._name + " AS account USE KEYS $account UNNEST account.addresses AS keypairs WHERE keypairs.address = $address";
    var query = Couchbase.N1qlQuery.fromString(statement);
    return new Promise((resolve, reject) => {
        this.bucket.query(query, { "account": account, "address": address }, (error, result) => {
            if(error) {
                reject({ "code": error.code, "message": error.message });
            }
            resolve({ "secret": result[0] });
        });
    });
}

getPrivateKeyFromAddress(cuenta, dirección) {

var declaración = "SELECT VALUE keypairs.secret FROM " + este.cubo.Nombre + " AS account USE KEYS $account UNNEST account.addresses AS keypairs WHERE keypairs.address = $address";

var consulta = Couchbase.N1qlQuery.fromString(declaración);

devolver nuevo Promesa((resolver, rechace) => {

este.cubo.consulta(consulta, { "cuenta": cuenta, "dirección": dirección }, (error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

resolver({ "secreto": resultado[0] });

});

}

Dada una cuenta concreta, creamos una consulta similar a la que vimos anteriormente. Esta vez, después de UNNESThacemos un DONDE para obtener resultados sólo para la dirección coincidente. Si quisiéramos podríamos haber hecho una operación de array en su lugar. Con Couchbase y N1QL, hay muchas maneras de resolver un problema.

Vamos a cambiar un poco de marcha aquí. Hasta ahora hemos hecho operaciones orientadas a cuentas en nuestra base de datos NoSQL. Otro aspecto importante son las transacciones. Por ejemplo, tal vez el usuario X deposita algunos USD moneda para BTC y el usuario Y hace una retirada. Necesitamos almacenar y consultar la información de esa transacción.

Las funciones del punto final de la API guardarán los datos de la transacción, pero aún podremos consultarlos.

getAccountBalance(account) {
    var statement = "SELECT SUM(tx.satoshis) AS balance FROM " + this.bucket._name + " AS tx WHERE tx.type = 'transaction' AND tx.account = $account";
    var query = Couchbase.N1qlQuery.fromString(statement);
    return new Promise((resolve, reject) => {
        this.bucket.query(query, { "account": account }, (error, result) => {
            if(error) {
                reject({ "code": error.code, "message": error.message });
            }
            resolve({ "balance": result[0].balance });
        });
    });
}

getAccountBalance(cuenta) {

var declaración = "SELECT SUM(tx.satoshis) AS balance FROM " + este.cubo.Nombre + " AS tx WHERE tx.type = 'transaction' AND tx.account = $account";

var consulta = Couchbase.N1qlQuery.fromString(declaración);

devolver nuevo Promesa((resolver, rechace) => {

este.cubo.consulta(consulta, { "cuenta": cuenta }, (error, resultado) => {

si(error) {

rechace({ "código": error.código, "mensaje": error.mensaje });

}

resolver({ "equilibrio": resultado[0].saldo });

});

}

Dada una cuenta, queremos obtener el saldo de la cuenta de un usuario concreto.

Espera un segundo, demos un paso atrás porque ¿no habíamos creado ya algunas funciones de saldo de cuenta? Técnicamente sí, pero esas funciones eran para comprobar el saldo del monedero, no el saldo de la cuenta.

Aquí es donde parte de mi experiencia se convierte en zona gris. Cada vez que transfieres Bitcoin, hay una comisión implicada, y a veces es bastante cara. Cuando haces un depósito, no es rentable transferir dinero a tu monedero porque te cobrarían una tasa de minero. Luego se le cobraría por retirar e incluso transferir de nuevo. En ese momento ya ha perdido la mayor parte de su Bitcoin.

En su lugar, creo que las bolsas tienen una cuenta de haberes similar a una cuenta del mercado monetario bursátil. Hay un registro del dinero que deberías tener en tu cuenta, pero técnicamente no está en un monedero. Cuando quieres transferir, estás transfiriendo desde la dirección de la aplicación, no desde tu dirección de usuario. Cuando usted retira, sólo se está restando.

De nuevo, no sé si realmente funciona así, pero es como yo lo haría para evitar comisiones por doquier.

Volviendo a nuestro getAccountBalance función. Tomamos una suma de cada transacción. Los depósitos tienen un valor positivo, mientras que las transferencias y las retiradas tienen un valor negativo. La suma de esta información debería darte un número exacto, excluyendo el saldo de tu monedero. Más adelante obtendremos una cuenta con el saldo del monedero.

Dado lo poco que sabemos sobre los saldos de las cuentas, podemos intentar crear una transacción desde nuestro monedero:

createTransactionFromAccount(account, source, destination, amount) {
    return new Promise((resolve, reject) => {
        this.getAddressBalance(source).then(sourceAddress => {
            if(sourceAddress.balanceSat < amount) {
                return reject({ "message": "Not enough funds in account." });
            }
            this.getPrivateKeyFromAddress(account, source).then(keypair => {
                this.getAddressUtxo(source).then(utxo => {
                    var transaction = new Bitcore.Transaction();
                    for(var i = 0; i < utxo.length; i++) {
                        transaction.from(utxo[i]);
                    }
                    transaction.to(destination, amount);
                    this.addAddress(account).then(change => {
                        transaction.change(change.address);
                        transaction.sign(keypair.secret);
                        resolve(transaction);
                    }, error => reject(error));
                }, error => reject(error));
            }, error => reject(error));
        }, error => reject(error));
    });
}

createTransactionFromAccount(cuenta, fuente, destino, importe) {

devolver nuevo Promesa((resolver, rechace) => {

este.getAddressBalance(fuente).entonces(sourceAddress => {

si(sourceAddress.balanceSat < importe) {

devolver rechace({ "mensaje": "No hay fondos suficientes en la cuenta". });

}

este.getPrivateKeyFromAddress(cuenta, fuente).entonces(par de claves => {

este.getAddressUtxo(fuente).entonces(utxo => {

var transacción = nuevo Bitcore.Transacción();

para(var i = 0; i < utxo.longitud; i++) {

transacción.de(utxo[i]);

}

transacción.a(destino, importe);

este.addAddress(cuenta).entonces(cambiar => {

transacción.cambiar(cambiar.dirección);

transacción.firmar(par de claves.secreto);

resolver(transacción);

}, error => rechace(error));

});

}

Si se nos proporciona una dirección de origen, una dirección de destino y una cantidad, podemos crear y firmar una transacción que posteriormente se emitirá en la red Bitcoin.

Primero obtenemos el saldo de la dirección de origen en cuestión. Necesitamos asegurarnos de que tiene suficiente UTXO para cumplir con la expectativa de cantidad enviada. Tenga en cuenta que en este ejemplo, estamos haciendo transacciones de una sola dirección. Si quisieras complicarte, podrías enviar desde múltiples direcciones en una sola transacción. No vamos a hacer eso aquí. Si nuestra única dirección tiene fondos suficientes, obtenemos la clave privada para ella y los datos UTXO. Con los datos UTXO podemos crear una transacción Bitcoin, aplicar la dirección de destino y una dirección de cambio, luego firmar la transacción usando nuestra clave privada. La respuesta puede ser difundida.

Del mismo modo, supongamos que queremos transferir Bitcoin desde nuestra cuenta de haberes:

createTransactionFromMaster(account, destination, amount) {
    return new Promise((resolve, reject) => {
        this.getAccountBalance(account).then(accountBalance => {
            if(accountBalance.balance < amount) {
                reject({ "message": "Not enough funds in account." });
            }
            var mKeyPairs = this.getMasterKeyPairs();
            var masterAddresses = mKeyPairs.map(a => a.address);
            this.getMasterAddressWithMinimum(masterAddresses, amount).then(funds => {
                this.getAddressUtxo(funds.address).then(utxo => {
                    var transaction = new Bitcore.Transaction();
                    for(var i = 0; i < utxo.length; i++) {
                        transaction.from(utxo[i]);
                    }
                    transaction.to(destination, amount);
                    var change = helper.getMasterChangeAddress();
                    transaction.change(change.address);
                    for(var j = 0; j < mKeyPairs.length; j ++) {
                        if(mKeyPairs[j].address == funds.address) {
                            transaction.sign(mKeyPairs[j].secret);
                        }
                    }
                    var tx = {
                        account: account,
                        satoshis: (amount * -1),
                        timestamp: (new Date()).getTime(),
                        status: "transfer",
                        type: "transaction"
                    };
                    this.insert(tx).then(result => {
                        resolve(transaction);
                    }, error => reject(error));
                }, error => reject(error));
            }, error => reject(error));
        }, error => reject(error));
    });
}

createTransactionFromMaster(cuenta, destino, importe) {

devolver nuevo Promesa((resolver, rechace) => {

este.getAccountBalance(cuenta).entonces(accountBalance => {

si(accountBalance.saldo < importe) {

rechace({ "mensaje": "No hay fondos suficientes en la cuenta". });

}

var mKeyPairs = este.getMasterKeyPairs();

var direcciones maestras = mKeyPairs.mapa(a => a.dirección);

este.getDirecciónMaestraConMínimo(direcciones maestras, importe).entonces(fondos => {

este.getAddressUtxo(fondos.dirección).entonces(utxo => {

var transacción = nuevo Bitcore.Transacción();

para(var i = 0; i < utxo.longitud; i++) {

transacción.de(utxo[i]);

}

transacción.a(destino, importe);

var cambiar = ayudante.getMasterChangeAddress();

transacción.cambiar(cambiar.dirección);

para(var j = 0; j < mKeyPairs.longitud; j ++) {

si(mKeyPairs[j].dirección == fondos.dirección) {

transacción.firmar(mKeyPairs[j].secreto);

}

var tx = {

cuenta: cuenta,

satoshis: (importe * -1),

marca de tiempo: (nuevo Fecha()).getTime(),

estado: "transferencia",

tipo: "transacción"

};

este.insertar(tx).entonces(resultado => {

resolver(transacción);

}, error => rechace(error));

});

}

Suponemos que nuestras direcciones de intercambio se han cargado con una cantidad insana de Bitcoin para satisfacer la demanda.

El primer paso es asegurarnos de que tenemos fondos en nuestra cuenta de haberes. Podemos ejecutar esa consulta que suma cada una de nuestras transacciones para obtener un número válido. Si tenemos suficiente, podemos obtener nuestros 10 pares de claves maestras y las direcciones. Tenemos que comprobar qué dirección tiene fondos suficientes para enviar. Recuerde, las transacciones de una sola dirección aquí, cuando podría haber más.

Si una dirección tiene fondos suficientes, obtenemos los datos UTXO y comenzamos a realizar una transacción. Esta vez, en lugar de nuestra cartera como dirección de origen, utilizamos la cartera del intercambio. Después de obtener una transacción firmada, queremos crear una transacción en nuestra base de datos para restar el valor que estamos transfiriendo.

Antes de pasar a los puntos finales de la API, quiero reiterar algunas cosas:

Supongo que los intercambios populares tienen una cuenta de retención para evitar las tasas impuestas a las direcciones de los monederos.
En este ejemplo estamos utilizando transacciones de una sola dirección, en lugar de agregar las que tenemos.
No estoy cifrando los datos clave de los documentos de la cuenta, cuando debería hacerlo.
No estoy emitiendo ninguna transacción, sólo creándolas.

Ahora vamos a centrarnos en nuestros puntos finales de la API, la parte sencilla.

Diseño de puntos finales de API RESTful con Express Framework

Recuerde, como configuramos al principio, nuestros puntos finales se dividirán en tres archivos que actúan como agrupaciones. Empezaremos con el grupo más pequeño y simple de endpoints, que son más para utilidad que otra cosa.

Abra el archivo rutas/utilidad.js e incluya lo siguiente:

const Bitcore = require("bitcore-lib");
const Mnemonic = require("bitcore-mnemonic");

module.exports = (app) => {

    app.get("/mnemonic", (request, response) => {
        response.send({
            "mnemonic": (new Mnemonic(Mnemonic.Words.ENGLISH)).toString()
        });
    });

    app.get("/balance/value", (request, response) => {
        Request("https://api.coinmarketcap.com/v1/ticker/bitcoin/").then(market => {
            response.send({ "value": "$" + (JSON.parse(market)[0].price_usd * request.query.balance).toFixed(2) });
        }, error => {
            response.status(500).send(error);
        });
    });

}

const Bitcore = requiere("bitcore-lib");

const Mnemotecnia = requiere("bitcore-mnemonic");

módulo.exportaciones = (aplicación) => {

aplicación.consiga("/mnemónico", (solicitar, respuesta) => {

respuesta.enviar({

"mnemotécnico": (nuevo Mnemotecnia(Mnemotecnia.Palabras.INGLÉS)).toString()

});

aplicación.consiga("/balance/valor", (solicitar, respuesta) => {

Solicitar("https://api.coinmarketcap.com/v1/ticker/bitcoin/").entonces(mercado => {

respuesta.enviar({ "valor": "$" + (JSON.analizar(mercado)[0].precio_usd * solicitar.consulta.saldo).toFixed(2) });

}, error => {

respuesta.estado(500).enviar(error);

});

}

Aquí tenemos dos puntos finales, uno para generar semillas mnemónicas y el otro para obtener el valor fiat de un saldo Bitcoin. Ninguno de los dos son realmente necesarios, pero en el primer lanzamiento, podría ser bueno generar un valor semilla para guardarlo más tarde en nuestro archivo de configuración.

Ahora abra el proyecto rutas/cuenta.js para que podamos manejar la información de la cuenta:

const Request = require("request-promise");
const Joi = require("joi");
const helper = require("../app").helper;

module.exports = (app) => {

    app.post("/account", (request, response) => { });

    app.put("/account/address/:id", (request, response) => { });

    app.get("/account/addresses/:id", (request, response) => { });

    app.get("/addresses", (request, response) => { });

    app.get("/account/balance/:id", (request, response) => { });

    app.get("/address/balance/:id", (request, response) => { });

}

const Solicitar = requiere("solicitud-promesa");

const Joi = requiere("joi");

const ayudante = requiere("../app").ayudante;

módulo.exportaciones = (aplicación) => {

aplicación.Correo electrónico:("/cuenta", (solicitar, respuesta) => { });

aplicación.poner("/cuenta/dirección/:id", (solicitar, respuesta) => { });

aplicación.consiga("/cuenta/direcciones/:id", (solicitar, respuesta) => { });

aplicación.consiga("/direcciones", (solicitar, respuesta) => { });

aplicación.consiga("/cuenta/saldo/:id", (solicitar, respuesta) => { });

aplicación.consiga("/dirección/saldo/:id", (solicitar, respuesta) => { });

}

Tenga en cuenta que estamos tirando de la clase de ayuda de la app.js que aún no hemos empezado. Sólo tienes que ir con él por ahora y tendrá sentido más tarde, aunque no es nada especial.

A la hora de crear cuentas, disponemos de lo siguiente:

app.post("/account", (request, response) => {
    var model = Joi.object().keys({
        firstname: Joi.string().required(),
        lastname: Joi.string().required(),
        type: Joi.string().forbidden().default("account")
    });
    Joi.validate(request.body, model, { stripUnknown: true }, (error, value) => {
        if(error) {
            return response.status(500).send(error);
        }
        helper.createAccount(value).then(result => {
            response.send(value);
        }, error => {
            response.status(500).send(error);
        });
    });
});

aplicación.Correo electrónico:("/cuenta", (solicitar, respuesta) => {

var modelo = Joi.objeto().llaves({

nombre: Joi.cadena().obligatorio(),

apellido: Joi.cadena().obligatorio(),

tipo: Joi.cadena().prohibido().por defecto("cuenta")

});

Joi.valide(solicitar.cuerpo, modelo, { stripUnknown: verdadero }, (error, valor) => {

si(error) {

devolver respuesta.estado(500).enviar(error);

}

ayudante.crearCuenta(valor).entonces(resultado => {

respuesta.enviar(valor);

}, error => {

respuesta.estado(500).enviar(error);

});

Usando Joi podemos validar el cuerpo de la petición y lanzar errores si no es correcto. Asumiendo que el cuerpo de la petición es correcto, podemos llamar a nuestro crearCuenta para guardar una nueva cuenta en la base de datos.

Con una cuenta creada, podemos añadir algunas direcciones:

app.put("/account/address/:id", (request, response) => {
    helper.addAddress(request.params.id).then(result => {
        response.send(result);
    }, error => {
        return response.status(500).send(error);
    });
});

aplicación.poner("/cuenta/dirección/:id", (solicitar, respuesta) => {

ayudante.addAddress(solicitar.parámetros.id).entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

devolver respuesta.estado(500).enviar(error);

});

Utilizando el identificador de cuenta que se pasó, podemos llamar a nuestro addAddress para utilizar una operación de subdocumento en nuestro documento.

No está tan mal, ¿verdad?

Para obtener todas las direcciones de una cuenta en particular, podríamos tener algo como lo siguiente:

app.get("/account/addresses/:id", (request, response) => {
    helper.getAddresses(request.params.id).then(result => {
        response.send(result);
    }, error => {
        response.status(500).send(error);
    });
});

aplicación.consiga("/cuenta/direcciones/:id", (solicitar, respuesta) => {

ayudante.getAddresses(solicitar.parámetros.id).entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

respuesta.estado(500).enviar(error);

});

Alternativamente, si no proporcionamos un id, podemos obtener todas las direcciones de todas las cuentas utilizando la siguiente función endpoint:

app.get("/addresses", (request, response) => {
    helper.getAddresses().then(result => {
        response.send(result);
    }, error => {
        response.status(500).send(error);
    });
});

aplicación.consiga("/direcciones", (solicitar, respuesta) => {

ayudante.getAddresses().entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

respuesta.estado(500).enviar(error);

});

Ahora probablemente la función más complicada. Digamos que queremos obtener el saldo de nuestra cuenta, que incluye la cuenta de explotación, así como cada una de nuestras direcciones de cartera. Podemos hacer lo siguiente:

app.get("/account/balance/:id", (request, response) => {
    helper.getAddresses(request.params.id).then(addresses => helper.getWalletBalance(addresses)).then(balance => {
        helper.getAccountBalance(request.params.id).then(result => {
            response.send({ "balance": balance.balance + result.balance });
        }, error => {
            response.status(500).send({ "code": error.code, "message": error.message });
        });
    }, error => {
        response.status(500).send({ "code": error.code, "message": error.message });
    });
});

aplicación.consiga("/cuenta/saldo/:id", (solicitar, respuesta) => {

ayudante.getAddresses(solicitar.parámetros.id).entonces(direcciones => ayudante.getWalletBalance(direcciones)).entonces(saldo => {

ayudante.getAccountBalance(solicitar.parámetros.id).entonces(resultado => {

respuesta.enviar({ "equilibrio": saldo.saldo + resultado.saldo });

}, error => {

respuesta.estado(500).enviar({ "código": error.código, "mensaje": error.mensaje });

});

}, error => {

respuesta.estado(500).enviar({ "código": error.código, "mensaje": error.mensaje });

});

Lo anterior llamará a nuestras dos funciones para obtener el balance, y sumará los resultados para obtener un balance masivo.

Los puntos finales de las cuentas no eran especialmente interesantes. La creación de transacciones es un poco más emocionante.

Abra el archivo rutas/transacción.js e incluya lo siguiente:

const Request = require("request-promise");
const Joi = require("joi");
const Bitcore = require("bitcore-lib");
const helper = require("../app").helper;

module.exports = (app) => {

    app.post("/withdraw", (request, response) => { });

    app.post("/deposit", (request, response) => { });

    app.post("/transfer", (request, response) => { });

}

const Solicitar = requiere("solicitud-promesa");

const Joi = requiere("joi");

const Bitcore = requiere("bitcore-lib");

const ayudante = requiere("../app").ayudante;

módulo.exportaciones = (aplicación) => {

aplicación.Correo electrónico:("/retirada", (solicitar, respuesta) => { });

aplicación.Correo electrónico:("/depósito", (solicitar, respuesta) => { });

aplicación.Correo electrónico:("/transferencia", (solicitar, respuesta) => { });

}

Tenemos tres tipos diferentes de transacción. Podemos depositar moneda fiduciaria por Bitcoin, retirar Bitcoin por moneda fiduciaria y transferir Bitcoin a nuevas direcciones de monedero.

Echemos un vistazo al punto final de depósito:

app.post("/deposit", (request, response) => {
    var model = Joi.object().keys({
        usd: Joi.number().required(),
        id: Joi.string().required()
    });
    Joi.validate(request.body, model, { stripUnknown: true }, (error, value) => {
        if(error) {
            return response.status(500).send(error);
        }
        Request("https://api.coinmarketcap.com/v1/ticker/bitcoin/").then(market => {
            var btc = value.usd / JSON.parse(market)[0].price_usd;
            var transaction = {
                account: value.id,
                usd: value.usd,
                satoshis: Bitcore.Unit.fromBTC(btc).toSatoshis(),
                timestamp: (new Date()).getTime(),
                status: "deposit",
                type: "transaction"
            };
            helper.insert(transaction).then(result => {
                response.send(result);
            }, error => {
                response.status(500).send(error);
            });
        }, error => {
            response.status(500).send(error);
        });
    });
});

aplicación.Correo electrónico:("/depósito", (solicitar, respuesta) => {

var modelo = Joi.objeto().llaves({

usd: Joi.número().obligatorio(),

id: Joi.cadena().obligatorio()

});

Joi.valide(solicitar.cuerpo, modelo, { stripUnknown: verdadero }, (error, valor) => {

si(error) {

devolver respuesta.estado(500).enviar(error);

}

Solicitar("https://api.coinmarketcap.com/v1/ticker/bitcoin/").entonces(mercado => {

var btc = valor.usd / JSON.analizar(mercado)[0].precio_usd;

var transacción = {

cuenta: valor.id,

usd: valor.usd,

satoshis: Bitcore.Unidad.deBTC(btc).toSatoshis(),

marca de tiempo: (nuevo Fecha()).getTime(),

estado: "depósito",

tipo: "transacción"

};

ayudante.insertar(transacción).entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

respuesta.estado(500).enviar(error);

});

}, error => {

respuesta.estado(500).enviar(error);

});

Después de validar la entrada, comprobamos el valor actual de Bitcoin en USD con CoinMarketCap. Utilizando los datos de la respuesta, podemos calcular cuántos Bitcoin deberíamos obtener en función de la cantidad depositada en USD.

Después de crear una transacción en la base de datos, podemos guardarla y, como es un número positivo, volverá como saldo positivo al consultarla.

Ahora digamos que queremos retirar dinero de nuestro Bitcoin:

app.post("/withdraw", (request, response) => {
    var model = Joi.object().keys({
        satoshis: Joi.number().required(),
        id: Joi.string().required()
    });
    Joi.validate(request.body, model, { stripUnknown: true }, (error, value) => {
        if(error) {
            return response.status(500).send(error);
        }
        helper.getAccountBalance(value.id).then(result => {
            if(result.balance == null || (result.balance - value.satoshis) < 0) {
                return response.status(500).send({ "message": "There are not `" + value.satoshis + "` satoshis available for withdrawal" });
            }
            Request("https://api.coinmarketcap.com/v1/ticker/bitcoin/").then(market => {
                var usd = (Bitcore.Unit.fromSatoshis(value.satoshis).toBTC() * JSON.parse(market)[0].price_usd).toFixed(2);
                var transaction = {
                    account: value.id,
                    satoshis: (value.satoshis * -1),
                    usd: parseFloat(usd),
                    timestamp: (new Date()).getTime(),
                    status: "withdrawal",
                    type: "transaction"
                };
                helper.insert(transaction).then(result => {
                    response.send(result);
                }, error => {
                    response.status(500).send(error);
                });
            }, error => {
                response.status(500).send(error);
            });
        }, error => {
            return response.status(500).send(error);
        });
    });
});

aplicación.Correo electrónico:("/retirada", (solicitar, respuesta) => {

var modelo = Joi.objeto().llaves({

satoshis: Joi.número().obligatorio(),

id: Joi.cadena().obligatorio()

});

Joi.valide(solicitar.cuerpo, modelo, { stripUnknown: verdadero }, (error, valor) => {

si(error) {

devolver respuesta.estado(500).enviar(error);

}

ayudante.getAccountBalance(valor.id).entonces(resultado => {

si(resultado.saldo == null || (resultado.saldo - valor.satoshis) < 0) {

devolver respuesta.estado(500).enviar({ "mensaje": "No hay `" + valor.satoshis + "` satoshis disponibles para retirar" });

}

Solicitar("https://api.coinmarketcap.com/v1/ticker/bitcoin/").entonces(mercado => {

var usd = (Bitcore.Unidad.deSatoshis(valor.satoshis).toBTC() * JSON.analizar(mercado)[0].precio_usd).toFixed(2);

var transacción = {

cuenta: valor.id,

satoshis: (valor.satoshis * -1),

usd: parseFloat(usd),

marca de tiempo: (nuevo Fecha()).getTime(),

estado: "retirada",

tipo: "transacción"

};

ayudante.insertar(transacción).entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

respuesta.estado(500).enviar(error);

});

}, error => {

respuesta.estado(500).enviar(error);

});

}, error => {

devolver respuesta.estado(500).enviar(error);

});

Aquí ocurren eventos similares. Después de validar el cuerpo de la solicitud, obtenemos el saldo de nuestra cuenta y nos aseguramos de que la cantidad que estamos retirando es menor o igual a nuestro saldo. Si lo es, podemos hacer otra conversión basada en el precio actual de CoinMarketCap. Crearemos una transacción usando un valor negativo y la guardaremos en la base de datos.

En ambos casos estamos confiando en CoinMarketCap que ha tenido controversia negativa en el pasado. Es posible que desee elegir un recurso diferente para las conversiones.

Por último, tenemos las transferencias:

app.post("/transfer", (request, response) => {
    var model = Joi.object().keys({
        amount: Joi.number().required(),
        sourceaddress: Joi.string().optional(),
        destinationaddress: Joi.string().required(),
        id: Joi.string().required()
    });
    Joi.validate(request.body, model, { stripUnknown: true }, (error, value) => {
        if(error) {
            return response.status(500).send(error);
        }
        if(value.sourceaddress) {
            helper.createTransactionFromAccount(value.id, value.sourceaddress, value.destinationaddress, value.amount).then(result => {
                response.send(result);
            }, error => {
                response.status(500).send(error);
            });
        } else {
            helper.createTransactionFromMaster(value.id, value.destinationaddress, value.amount).then(result => {
                response.send(result);
            }, error => {
                response.status(500).send(error);
            });
        }
    });
});

aplicación.Correo electrónico:("/transferencia", (solicitar, respuesta) => {

var modelo = Joi.objeto().llaves({

importe: Joi.número().obligatorio(),

dirección de origen: Joi.cadena().opcional(),

dirección de destino: Joi.cadena().obligatorio(),

id: Joi.cadena().obligatorio()

});

Joi.valide(solicitar.cuerpo, modelo, { stripUnknown: verdadero }, (error, valor) => {

si(error) {

devolver respuesta.estado(500).enviar(error);

}

si(valor.dirección de origen) {

ayudante.createTransactionFromAccount(valor.id, valor.dirección de origen, valor.dirección de destino, valor.importe).entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

respuesta.estado(500).enviar(error);

});

} si no {

ayudante.createTransactionFromMaster(valor.id, valor.dirección de destino, valor.importe).entonces(resultado => {

respuesta.enviar(resultado);

}, error => {

respuesta.estado(500).enviar(error);

});

}

});

Si la solicitud contiene una dirección de origen, vamos a transferir desde nuestro propio monedero, de lo contrario vamos a transferir desde el monedero que gestiona la bolsa.

Todo esto se basa en funciones que habíamos creado previamente.

Con los puntos finales fuera del camino, podemos centrarnos en bootstrapping nuestra aplicación y llegar a una conclusión.

Arranque de la aplicación Express Framework

En este momento tenemos dos archivos que permanecen intactos por el ejemplo. No hemos añadido una configuración o lógica de manejo para arrancar nuestros endpoints.

Abra el archivo config.json e incluya algo como lo siguiente:

{
    "mnemonic": "manage inspire agent october potato thought hospital trim shoulder round tired kangaroo",
    "host": "localhost",
    "bucket": "bitbase",
    "username": "bitbase",
    "password": "123456"
}

{

"mnemotécnico": "manage inspire agent october potato thought hospital trim shoulder round tired kangaroo",

"anfitrión": "localhost",

"cubo": "bitbase",

"nombre de usuario": "bitbase",

"contraseña": "123456"

}

Recuerde que este archivo es increíblemente sensible. Considera bloquearlo o incluso utilizar un enfoque diferente. Si la semilla está expuesta, cada clave privada para todas las cuentas de usuario y la cuenta de intercambio se puede obtener con cero esfuerzo.

Ahora abra el proyecto app.js e incluya lo siguiente:

const Express = require("express");
const BodyParser = require("body-parser");
const Bitcore = require("bitcore-lib");
const Mnemonic = require("bitcore-mnemonic");
const Config = require("./config");
const Helper = require("./classes/helper");

var app = Express();

app.use(BodyParser.json());
app.use(BodyParser.urlencoded({ extended: true }));

var mnemonic = new Mnemonic(Config.mnemonic);
var master = new Bitcore.HDPrivateKey(mnemonic.toHDPrivateKey());

module.exports.helper = new Helper(Config.host, Config.bucket, Config.username, Config.password, master);

require("./routes/account.js")(app);
require("./routes/transaction.js")(app);
require("./routes/utility.js")(app);

var server = app.listen(3000, () => {
    console.log("Listening at :" + server.address().port + "...");
});

const Express = requiere("express");

const BodyParser = requiere("body-parser");

const Bitcore = requiere("bitcore-lib");

const Mnemotecnia = requiere("bitcore-mnemonic");

const Configurar = requiere("./config");

const Ayudante = requiere("./classes/helper");

var aplicación = Express();

aplicación.utilice(BodyParser.json());

aplicación.utilice(BodyParser.urlencoded({ ampliado: verdadero }));

var mnemotécnico = nuevo Mnemotecnia(Configurar.mnemotécnico);

var maestro = nuevo Bitcore.HDPrivateKey(mnemotécnico.toHDPrivateKey());

módulo.exportaciones.ayudante = nuevo Ayudante(Configurar.host, Configurar.cubo, Configurar.nombre de usuario, Configurar.contraseña, maestro);

requiere("./rutas/cuenta.js")(aplicación);

requiere("./routes/transaction.js")(aplicación);

requiere("./routes/utility.js")(aplicación);

var servidor = aplicación.escuche(3000, () => {

consola.registro("Escuchando en :" + servidor.dirección().puerto + "...");

});

Lo que estamos haciendo es inicializar Express, cargar la información de configuración y enlazar nuestras rutas. La página módulo.exports.helper es nuestro singleton que se utilizará en todos los demás archivos JavaScript.

Conclusión

Acaba de ver cómo empezar a crear su propia bolsa de criptomonedas usando Node.js y Couchbase como base de datos NoSQL. Cubrimos mucho, desde la generación de carteras HD hasta la creación de endpoints con lógica de base de datos compleja.

Sin embargo, no me cansaré de repetirlo. Soy un entusiasta de la criptomoneda y no tengo experiencia real en el espacio financiero. Las cosas que he compartido deberían funcionar, pero se pueden hacer mucho mejor. No se olvide de cifrar sus claves y mantener su semilla segura. Pruebe su trabajo y sepa en lo que se está metiendo.

Si desea descargar este proyecto, consúltelo en GitHub. Si quieres compartir tu visión, experiencia, etc., sobre el tema, por favor, hazlo en los comentarios. La comunidad puede trabajar para crear algo grande.

Si eres un fan de Golang, he creado un proyecto similar en un tutorial anterior.

Nic Raboy, Defensor del Desarrollador, Couchbase

3 Comentarios

Aliaksey Kandratsenka (alias Aliaksei Kandratsenka) marzo 28, 2018 a 7:38 pm

IMHO bitcoin exchange es una elección bastante sub-óptima para un artículo sobre Couchbase. Cualquier cosa que toque dinero necesita una "D" fiable en ACID (es decir, con 4 o más nueves como mínimo). No creo que Couchbase lo tenga (piensa en nodos muriendo y auto-failover ocurriendo y gente perdiendo dinero). Otro problema es la consistencia. El código de arriba tiene una carrera entre la comprobación del saldo y el ahorro de la transacción de retirada, lo que lo pone de manifiesto con bastante claridad.

Otro problema es que comprobar el saldo es O(N) en número de transacciones de la cuenta. Las vistas materializadas de CouchDB pueden hacer la búsqueda del saldo de la cuenta en O(log N), pero por supuesto esto sigue siendo muy lento log N. AFAIK ningún índice niql es capaz de eso.

IMHO este artículo termina destacando las debilidades de couchbase. Es decir, porque couchbase no es adecuado como backend de intercambio de bitcoin. Un artículo como este podría ser ideal para algo como CockroachDB o cloud spanner.

Inicia sesión para responder
1. Nic Raboy, Defensor del Desarrollador, Couchbase marzo 29, 2018 a 8:32 am
  
  No lo he demostrado en este artículo, pero puedes definir tus propios requisitos de durabilidad a través del SDK. Si te preocupa la consistencia y perder dinero, puedes cambiar la configuración para responder sólo después de que haya persistido en disco o sólo después de que se haya replicado X número de veces.
  
  https://developer.couchbase.com/documentation/server/current/sdk/durability.html
  
  A la hora de consultar, puedes establecer la coherencia de la consulta. Si quieres, puedes esperar a que se actualice el índice.
  
  https://developer.couchbase.com/documentation/server/current/indexes/performance-consistency.html
  
  Entiendo tu punto de vista, pero no creo que sea un problema tan grave como crees.
  
  Gracias por compartir tu opinión :-)
  
  Inicia sesión para responder
Nic Raboy, Defensor del Desarrollador, Couchbase abril 6, 2018 a 8:38 am

Lo siento, lo tenía privado. Ahora es público.

Inicia sesión para responder

Dejar una respuesta Cancelar respuesta

Lo siento, debes estar conectado para publicar un comentario.

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Todos los mensajes

Desarrollo de una aplicación de criptomoneda Bitcoin con Node.js y NoSQL

Para llevar

Requisitos del proyecto

Creación de una aplicación Node.js con dependencias

Desarrollo de la base de datos y la lógica Bitcoin

Diseño de puntos finales de API RESTful con Express Framework

Arranque de la aplicación Express Framework

Conclusión

Autor

Publicado por Nic Raboy, Defensor del Desarrollador, Couchbase

3 Comentarios

Dejar una respuesta Cancelar respuesta