Node.js和NoSQL开发比特币加密货币应用程序(上)

我一直在跟踪比特币之类的加密货币相关主题有几个月了,我对所发生的一切都非常着迷。

作为一名Web应用程序开发人员,我一直特别感兴趣的一个主题是加密货币交易以及如何制作它们。从前端看,这些应用程序似乎是用于管理帐户,将比特币转换为美元等法定货币以及将比特币转账给其他人的工具,但它们能做更多吗?

我们将看一些Node.js和NoSQL数据库Couchbase的例子,它们涵盖了以加密货币交易为模型的主题。

免责声明:我不是加密货币专家,也没有参与金融服务或交易所的任何开发。我是这个主题的狂热爱好者,从本文中获得的任何内容都应该经过适当的测试和使用,风险自负。

the take-Away

你将从这篇特定文章中获得那些内容,将无法获得那些内容呢?让我们从你不会从本文中得到的东西开始:

  • 我们不会配置任何银行或信用卡服务来交易美元等法定货币。
  • 我们不会将任何已签名的交易广播到比特币网络,最终确定转账。

也就是说,以下是你可以期待在本文中学习的一些内容:

  • 我们将创建一个分层确定性(HD,hierarchical deterministic)钱包,它可以为给定的种子生成无限量的密钥,每个密钥代表一个用户钱包。
  • 我们将根据主种子创建每个包含钱包的用户帐户。
  • 我们将创建代表交易所存款,取款和资金转账的交易,而不实际使用法定货币。
  • 我们将从比特币网络中查找余额。
  • 我们将创建在比特币网络上广播的签名交易。

我们将在本文中看到许多可以更好地完成的事情。如果你发现了可以改进的内容,请务必在评论中分享。就像我说的那样,我不是这个主题的专家,只是一个粉丝。

项目要求

为了成功完成这个项目,必须满足一些要求:

  • 你必须安装并配置Node.js 6+。
  • 你必须安装Couchbase 5.1+并配置Bucket和RBAC配置文件。

重点是我将不会介绍如何启动和运行Couchbase。这不是一个困难的过程,但是你需要一个Bucket设置一个应用程序帐户和一个用N1QL查询索引。

创建具有依赖关系的Node.js应用程序

在开始添加任何逻辑之前,我们将创建一个新的Node.js应用程序并下载依赖项。在计算机上的某个位置创建项目目录,并从该目录中的CLI执行以下命令:

1
2
3
4
5
6
7
8
9
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

我知道我可以在一行中完成所有的依赖安装,但我想让它们清楚地阅读。那么我们在上面的命令中做了什么?

首先,我们通过创建package.json文件来初始化一个新的Node.js项目。然后我们下载我们的依赖项并通过--save标志将它们添加到package.json文件中。

对于此示例,我们将使用Express Frameworkexpressbody-parserjoi包都与接受和验证请求数据相关。因为我们将与公共比特币节点进行通信,所以我们将使用requestrequest-promise包。非常受欢迎的bitcore-lib软件包将允许我们创建钱包并签署交易,而bitcore-mnemonic软件包将允许我们生成可用于我们的HD钱包密钥的种子。最后,couchbaseuuid将用于处理我们的数据库。

现在我们可能想要更好地构建我们的项目。在项目目录中添加以下目录和文件(如果它们尚不存在):

1
2
3
4
5
6
7
8
9
package.json
config.json
app.js
routes
account.js
transaction.js
utility.js
classes
helper.js

我们所有的API端点都将分为几类,并放在每个适当的路由文件中。我们不必这样做,但为了使我们的项目更干净一点。我们去删除大量的比特币和数据库逻辑,我们将把所有非数据验证的内容添加到我们的classes/helper.js文件中。config.json文件将包含我们所有的数据库信息以及我们的助记符种子。在一个现实的场景中,这个文件应该被视为黄金般重要,并获得尽可能多的保护。app.js文件将具有我们所有的配置和引导逻辑,用于连接我们的路由,连接到数据库等。

为方便起见,我们将为项目添加一个依赖项并进行设置:

1
npm install nodemon --save-dev

nodemon包将允许我们每次更改文件时热重新加载项目。这不是一个必须的要求,但可以为我们节省一些时间。

打开package.json文件并添加以下脚本以实现它:

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

我们可以在此时开始我们的应用程序的开发过程。

开发数据库和比特币逻辑

在开发我们的应用程序时,在我们开始担心API端点之前,我们想要创建我们的数据库和比特币相关的逻辑。

我们将把时间花在项目的classes/helper.js文件中。打开它并包含以下内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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;

我们将把这个类作为我们应用程序的singleton来发送。在constructor方法中,我们建立与数据库集群的连接,打开Bucket并进行身份验证。打开的Bucket将在整个helper类中使用。

让我们在完成数据库逻辑之前跳出比特币逻辑。

如果你不熟悉HD钱包,它们本质上是一个由单个种子衍生而来的钱包。使用种子,你可以得到children,那些children可以再有children,等等。

1
2
3
4
5
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函数中的master变量表示顶级种子密钥。每个用户帐户都是该密钥的直接子项,因此我们根据account值派生子项。account值是人员编号,创建的每个帐户都将获得增量编号。但是,我们不会生成帐户密钥并将其称为一天。相反,每个帐户密钥将有10,000个可能的私钥和公钥,以防他们不想多次使用同一个密钥。一旦我们随机生成了一个密钥,我们就会返回它。

同样,我们有一个getMasterChangeAddress函数,如下所示:

1
2
3
4
5
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() }
}

当我们开始创建帐户时,它们将从一开始,为交易或Web应用程序留下零,或者你想要调用它。我们还为此帐户分配了10个可能的地址。这些地址将做两件事。第一个是他们将比特币发送到其他账户,第二个是他们将收到剩余款项,也就是所谓的变更。请记住,在比特币交易中,必须花费所有未花费的交易输出(UTXO),即使它小于期望的金额。这意味着所需的金额将被发送到目的地,剩余部分将被发送回这10个地址中的一个。

还有其他方法或更好的方法吗?当然,但这个将适用于这个例子。

为了获得我们使用或使用HD种子生成的任何地址的余额,我们可以使用公共比特币资源管理器:

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

上面的函数将采用一个地址并以十进制格式和satoshis获得余额。展望未来,satoshi价值是我们唯一的相关价值。如果我们有给定帐户的X个地址,我们可以使用如下函数获得总余额:

1
2
3
4
5
6
7
8
9
10
11
12
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函数中,我们正在为每个地址发出请求,当它们全部完成时,我们可以添加余额并返回它们。

能够传输加密货币需要的不仅仅是地址余额。相反,我们需要知道给定地址的未花费的交易输出(UTXO)。这可以使用BitPay中的相同API找到:

1
2
3
4
5
6
7
8
9
10
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));
});
});
}

如果没有未使用的交易输出,则意味着我们无法传输任何内容,而是应该抛出错误。足够的发送代表的是一个不同的意思。

例如,我们可以这样做:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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" });
});
}

在上面的函数中,我们将获取一个地址列表并检查哪个地址的数量大于我们提供的阈值。如果他们都没有足够的余额,我们应该发送这个消息。

最终的实用程序相关功能,我们已经看到了一些:

1
2
3
4
5
6
7
8
9
10
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;
}

上面的函数将为我们提供所有主密钥,这对于签名和检查值非常有用。

重申一下,我使用有限值来生成多少个键。你可能会也可能不想这样做,这取决于你。

现在让我们深入研究一些用于存储应用程序数据的NoSQL逻辑。

截至目前,我们的数据库中没有数据。第一个逻辑步骤可能是创建一些数据。虽然独立并不是特别困难,但我们可以创建这样的函数:

1
2
3
4
5
6
7
8
9
10
11
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);
});
});
}

基本上,我们接受一个对象和一个id用作文档密钥。如果未提供文档密钥,我们将自动生成它。完成所有操作后,我们将返回创建的内容,包括响应中的id

所以我们假设我们要创建一个用户帐户。我们可以做到以下几点:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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);
});
});
});
}

请记住,帐户由此示例的自动递增数值驱动。我们可以使用Couchbase中的counter创建递增值。如果计数器不存在,我们将其初始化为1并在每次下一次调用时递增。请记住,0是为应用程序密钥保留的。

在我们得到计数器值之后,我们将它添加到传递的对象并调用我们的insert函数,在这种情况下为我们生成一个唯一的id

我们还没有看到它,因为我们没有任何端点,但我们假设在创建帐户时,它没有地址信息,只有帐户标识符。我们可能想为用户添加地址:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 });
});
});
});
}

添加地址时,我们首先按文档ID获取用户。检索文档后,我们获取数字帐户值并创建10,000个选项的新密钥对。使用子文档操作,我们可以将密钥对添加到用户文档,而无需下载文档或对其进行操作。

关于我们刚刚做了什么非常严肃的事情。

我将未加密的私钥和公共地址存储在用户文档中。这对生产来说是一个很大的禁忌。还记得你读过的所有关于人们钥匙被盗的地方的故事吗?实际上,我们希望在插入数据之前加密数据。我们可以通过使用Node.js加密库来实现,或者如果我们使用Couchbase Server 5.5,Couchbase的Node.js SDK会提供加密。我们不会在这里探讨它。

好的,我们现在已经在数据库中获得了帐户数据和地址。让我们查询该数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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函数可以做两件事之一。如果提供了帐户,我们将使用N1QL查询来获取该特定帐户的所有地址。如果未提供帐户,我们将获取数据库中每个帐户的所有地址。在这两种情况下,我们只获取公共地址,没有任何敏感信息。使用参数化的N1QL查询,我们可以将数据库结果返回给客户端。

我们的查询中需要注意的事项。

我们将地址存储在用户文档中的数组中。使用UNNEST运算符,我们可以展平这些地址并使响应更具吸引力。

现在假设我们有一个地址,我们想获得相应的私钥。 我们可能会做以下事情:

1
2
3
4
5
6
7
8
9
10
11
12
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] });
});
});
}

给定一个特定的帐户,我们创建一个类似于我们之前看到的查询。这次,在我们UNNEST,我们执行WHERE条件,仅为匹配地址提供结果。如果我们想要我们可以做一个数组操作。使用Couchbase和N1QL,有很多方法可以解决问题。

======================================================================

分享一些以太坊、EOS、比特币等区块链相关的交互式在线编程实战教程:

  • java以太坊开发教程,主要是针对java和android程序员进行区块链以太坊开发的web3j详解。
  • python以太坊,主要是针对python工程师使用web3.py进行区块链以太坊开发的详解。
  • php以太坊,主要是介绍使用php进行智能合约开发交互,进行账号创建、交易、转账、代币开发以及过滤器和交易等内容。
  • 以太坊入门教程,主要介绍智能合约与dapp应用开发,适合入门。
  • 以太坊开发进阶教程,主要是介绍使用node.js、mongodb、区块链、ipfs实现去中心化电商DApp实战,适合进阶。
  • C#以太坊,主要讲解如何使用C#开发基于.Net的以太坊应用,包括账户管理、状态与交易、智能合约开发与交互、过滤器和交易等。
  • EOS教程,本课程帮助你快速入门EOS区块链去中心化应用的开发,内容涵盖EOS工具链、账户与钱包、发行代币、智能合约开发与部署、使用代码与智能合约交互等核心知识点,最后综合运用各知识点完成一个便签DApp的开发。
  • java比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Java代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Java工程师不可多得的比特币开发学习课程。
  • php比特币开发教程,本课程面向初学者,内容即涵盖比特币的核心概念,例如区块链存储、去中心化共识机制、密钥与脚本、交易与UTXO等,同时也详细讲解如何在Php代码中集成比特币支持功能,例如创建地址、管理钱包、构造裸交易等,是Php工程师不可多得的比特币开发学习课程。
  • tendermint区块链开发详解,本课程适合希望使用tendermint进行区块链开发的工程师,课程内容即包括tendermint应用开发模型中的核心概念,例如ABCI接口、默克尔树、多版本状态库等,也包括代币发行等丰富的实操代码,是go语言工程师快速入门区块链开发的最佳选择。

汇智网原创翻译,转载请标明出处。这里是原文Node.js和NoSQL开发比特币加密货币应用程序