Chainlink对接Cosmos区块链

青旅半醒 2022-08-29 05:48 118阅读 0赞

区块链预言机（Oracle）是一种第三方去中心化数据服务，可以为智能合约和区块链提供链外数据。 预言机在封闭、确定性的区块链系统与现实世界之间搭建了一座桥梁。

区块链预言机的主要问题是，它不是区块链共识机制的组成部分，因此没有区块链的公共基础设施提供 的基本安全保证。[Chainlink][]是目前的行业标准，提供了一个鲁棒的解决方案。

[Cosmos][]是构建多资产的、PoS共识的自定义区块链的一个出色的开源框架。 每个Cosmos程序都运行在PoS共识引擎[Tendermint Core][]之上。

自定义区块链意味着Cosmos没有采用以太坊那样的虚拟机区块链范式，即使用状态机运行智能合约， 虽然你也可以利用Ethermint让自定义区块链支持智能合约。

Chainlink目前广泛地用于以太坊智能合约，整个过程大致如下：

1.  你的智能合约与预言机合约智能合约进行交易，该合约会触发一个事件
2.  链下的chainlink节点通过订阅预言机事件就可以在交易时得到通知。
3.  当合约事件被记录下来时，它会执行一些链下的操作，并调用预言机合约函数并传入所执行工作的结果。
4.  最后，预言机合约会调用你的合约上的回调方法并传入收到的链下数据。

从这个描述中，我们可以清楚地看到，智能合约是整个过程中的关键。你的智能合约不与任何链下API 或资源 通信 - 仅与另一个智能合约交互。

那么，基于cosmos的自定义区块链，在没有智能合约的情况下，如何实现预言机呢？老实说我不确定。 我知道的唯一类似的项目，是Kava区块链在其系统中[集成了Chainlink价格预言机][Chainlink 1]。 他们使用一个可以发布链上价格数据的预言机白名单。当Kava平台用户想要价格数据时，他们可以查询保存的 所有价格数据或预言机发布的所有价格的中间价。

据我所知，Chainlink也在尝试建立一个模块，完成类似的功能。

在我不得不考虑这个问题的一小段时间里，我想出了两个解决方案。我相信有更好的方法来解决这个技术问题， 所以请随时使本文的评论部分成为集思广益的创意中心。

## 1、解决方案 1 ##

一种解决方案是，预言机运营商在自定义区块链上创建一个钱包。然后，它使用 WebSocket来监听涉及 该地址的交易。当它记录到此类交易时，就执行一些链下操作，一旦完成，就将交易发送到上一笔交易的来源地址。

它将允许按需启动预言机请求，预言机将能够执行任何工作——而不仅仅是发布价格数据。

目前，这可以利用Chainlink预言机完成。预言机运营商可以在区块链上注册钱包，并使用 [外部启动器][Link 3] 和[外部适配器][Link 4]提供服务。

![Diagram of first solution][]

## 2、解决方案 2 ##

第二个更可靠的选择是在Cosmos上创建一个预言机区块链，这将作为Chainlink节点和Cosmos 生态系统之间的通信点。它将Chainlink的所有 API 暴露在用Cosmos构建的每一个区块链中。我们甚至 可以在预言机区块链中构建安全机制，以验证链外数据的完整性。

听起来对Cosmos生态系统来说这是一件非常有价值的事情， 那么应该怎么实现？

预言机区块链使用前面提出的第一个解决方案，这意味着预言机将使用WebSockets订阅来自其他Cosmos 区块链上来自预言机区块链上的交易事件。这些事件包含的信息，允许预言机节点确定它必须执行什么工作。 成功执行后，从预言机区块链向客户端区块链提交一个交易。

最近推出的[链间通信协议 （IBC）][_IBC]使上述方案 变得可行。简言之，IBC是一个允许Cosmos区块链之间端到端、可靠和经过验证的通信的协议。任何Cosmos区块链 都能够执行与预言机区块链通信的协议。

![Diagram of second solution][]

显然，我不会在本文中实施这第二个解决方案，因为它需要大量的规划、架构和编程，并且会让你失去继续读下去的兴趣。 但是，从长远来看，我确实计划将此成为现实，因此，如果你有兴趣，请留意我的更新或与我保持联系。

我们将在以下段落中实施第一个解决方案：创建一个Cosmos区块链，并使用Chainlink从互联网上获取随机报价。

为了保持这篇文章的合理长度，我们将代码编写的尽可能简洁。不过还是有相当多的步骤和代码需要我们完成。 我知道这很复杂，但这将是值得的。

我们必须：

*  在Cosmos上创建一个简单但有效的区块链，能够存储并检索随机报价。虽然除了作为示例外，它不是很有用。
 *  创建Chainlink外部启动器，该启动器将监听区块链上的交易并触发预言机。
 *  创建Chainlink外部适配器，该适配器将从公共 API 中获取随机报价并将其发布回我们的区块链。

现在是时候卷起袖子，戴上安全帽去上班了！

## 3、创建区块链 ##

我实现了一个最小功能的区块链，用于预言机报价请求和报价创建。下面，我将展示如何从头开始的基本知识， 但不会解释如何构建整个示例应用程序，因为这不是本文的重点。

如果你想直接上手代码，可以点击[此处][Link 5]查看 GitHub仓库：

让我们开始创建Cosmos区块链。最简单的方法是使用starport工具，你可以[GitHub][]安装。

打开终端运行：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
</pre> </td> 
   <td> <pre>starport app github.com/lajosdeme/linktest
</pre> </td> 
  </tr> 
 </tbody> 
</table>

上述命令将创建一个名为”linktest”的cosmos应用程序。你可以进入linktest文件夹并运行`starport serve`以 生成和运行这个区块链。运行结果类似下面这样：

![20210731134352218.png][]

这个区块链目前还没有太多功能。基本上，它所做的就是运行 Tendermint 共识引擎，并提供最小功能， 在地址之间交易。我们下面就要实现业务逻辑了。

从上面的终端输出，可以看到，我们可以在端口26657与tendermint互动。共识引擎会发出不同的事件， 我们可以通过 WebSocket 订阅它们。让我们用命令行和[postman][]说明一下这其中的工作原理，然后我们可以 继续实现Chainlink外部启动器。

打开Postman，然后单击File ->New -> WebSocket请求。在顶部输入ws://localhost:25657并单击Connect。 现在，让我们订阅所有交易事件。在消息字段中粘贴以下信息，然后单击Send：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
</pre> </td> 
   <td> <pre>{
   “jsonrpc”: “2.0”,
   “method”: “subscribe”,
   “id”: 0,
   “params”: {
      “query”:”tm.event = ‘Tx’”
   }
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

就是这样。我们用WebSocket连接共识引擎。现在是时候利用一个交易来测试一切正常。以下是我们需要的命令：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
</pre> </td> 
   <td> <pre>linktestd tx bank send &lt;SENDER_ADDRESS&gt; &lt;RECIPIENT_ADDRESS&gt; &lt;AMOUNT&gt;
</pre> </td> 
  </tr> 
 </tbody> 
</table>

例如，对于我来说，带入实际参数后是这样：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
</pre> </td> 
   <td> <pre>linktestd tx bank send \
  cosmos1fztn5xte9c0gqfhjrf5a8vuqz9d2p6wf90ez72 \
  cosmos1f0g0m92f6s405vww6n0kgjwcqfxyf8fjnzyuff \
  10token
</pre> </td> 
  </tr> 
 </tbody> 
</table>

让我们回到Postman那里，在那里我们可以看到交易已被记录。我们的外部发起人将做同样的事情，并触发 预言机节点的工作。

## 4、创建Chainlink外部启动器 ##

[外部启动器][Link 3]是使Chainlink节点 与区块链无关的秘密武器，即任何区块链都可用。

> 外部发起人允许根据某些外部条件在节点中启动作业。创建和添加外部启动器到Chainlink节点的能力 实现了跨链兼容性。 - Chainlink文档

虽然您可以按照代码执行，但如果你也希望能够运行并测试代码，则应在本地或云中设置Chainlink节点。 要设置本地节点，请按照[此教程][Link 6]执行。一旦你有了自己的节点， 打开.env文件，并确保它包括以下内容，以便禁用以太坊并启用外部启动器：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
</pre> </td> 
   <td> <pre>ETH_CHAIN_ID=0
ETH_DISABLED=true
FEATURE_EXTERNAL_INITIATORS=true
</pre> </td> 
  </tr> 
 </tbody> 
</table>

现在是时候登录到节点的管理员设置，以便添加发起人：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
</pre> </td> 
   <td> <pre>chainlink admin login
</pre> </td> 
  </tr> 
 </tbody> 
</table>

现在可以注册它：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
</pre> </td> 
   <td> <pre>chainlink initiators create linktest http://localhost:6688/jobs
</pre> </td> 
  </tr> 
 </tbody> 
</table>

这将创建一个名为linktest并使用默认端点访问Chainlink节点作业的启动器。输出将是这样的：

![48335702e38002e58f8a79ba5952946d.png][]

复制并保存这些值，因为我们下面还需要它们。

现在使用命令`chainlink node start`启动你的Chainlink节点，并前往浏览器http://localhost:6688。 登录并选择顶部导航栏中的”Bridges”。然后单击”New Bridge”，输入名称（我的是link-ea）和URL（http://localhost:3000）。 可以暂时将最低付款和确认数设置为0。最后单击”Create Bridge”。

> 外部适配器通过创建桥类型添加到Chainlink节点中。桥定义了外部适配器的任务名称和网址。当收到不是 核心适配器之一的任务类型时，节点将搜索带有该名称的桥类型，将桥用于外部适配器。 - Chainlink文档

现在前往顶部栏中的”Jobs”，选择”New Job”，并将此粘贴到”Job Spec”中：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
</pre> </td> 
   <td> <pre>{
  “name”: “LINK-EA”,
  “initiators”: [
     {
       “type”: “external”,
       “params”: {
       “name”: “linktest”,
       “body”: {
          “endpoint”: “random”
        }
      }
    }
  ],
  “tasks”: [
    {
      “type”: “link-ea”
    }
  ]
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

这告诉Chainlink，我们希望运行的工作，由名为linktest的外部发起人触发，并且应该调用link-ea桥。 创建作业后，如果打开它，你将看到名称下的 ID。我们还需要那个ID。

我们要做的最后一件事就是为我们的外部适配器在本地建立一个Postgres数据库。如果你不知道如何做到这一点， 可以查阅Chainlink节点教程中的相关解释。

现在，我们可以创建实际的外部启动器。这只是一个简单的WebSocket服务器，你可以在任何编程语言中构建它， 但我会在Go中构建它，因为我真的很喜欢该语言。

首先，创建一个名为”external-initiator”的项目，并在项目根源中定义一个.env文件。现在，我们需要将 保存的值添加到改文件中：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
4
5
6
7
</pre> </td> 
   <td> <pre>EI_DATABASEURL=&lt;external initiator postgres db url&gt;
EI_CHAINLINKURL=localhost:6688
EI_IC_ACCESSKEY=&lt;ACCESSKEY saved above&gt;
EI_IC_SECRET=&lt;SECRET saved above&gt;
EI_CI_ACCESSKEY=&lt;OUTGOINGTOKEN saved above&gt;
EI_CI_SECRET=&lt;OUTGOINGSECRET saved above&gt;
JOB_ID=&lt;Chainlink Job ID&gt;
</pre> </td> 
  </tr> 
 </tbody> 
</table>

现在让我们来看看WebSocket客户端的代码：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
</pre> </td> 
   <td> <pre>package main

import (
	"encoding/json"
	"log"
	"os"

"github.com/gorilla/websocket"
)

type WebSocket struct {
	Endpoint string
}

type wsConn struct {
	connection *websocket.Conn
	open       bool
}

func (ws WebSocket) Connect() wsConn {
	c, _, err := websocket.DefaultDialer.Dial(ws.Endpoint, nil)
	if err != nil {
		log.Fatal("Error dialing: ", err)
	}

con := wsConn{
		connection: c,
		open:       true,
	}
	return con
}

func (con wsConn) Subscribe(message string) {
	defer con.connection.Close()

interrupt := make(chan os.Signal, 1)

done := make(chan struct{})

err := con.connection.WriteMessage(websocket.TextMessage, []byte(message))

if err != nil {
		con.open = false
		log.Fatal("Error subscibing to tx: ", err)
	}

go func() {
		defer close(done)
		for {
			_, message, err := con.connection.ReadMessage()
			if err != nil {
				log.Println("Read error: ", err)
			}

var txRes TxResult
			json.Unmarshal([]byte(message), &amp;txRes)

var requesterAddr, event string
			txRes.convert(&amp;requesterAddr, &amp;event)

if event == "RequestQuote" {
				startJob(requesterAddr)
			}
		}
	}()

for {
		select {
		case &lt;-done:
			return
		case &lt;-interrupt:
			log.Println("Interrupting")
			err := con.connection.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			con.open = false
			if err != nil {
				log.Println("Close error:", err)
				return
			}
			return
		}
	}
}
</pre> </td> 
  </tr> 
 </tbody> 
</table>

这为外部发起人执行了大部分工作。还有其他一些文件，所以你应该看看[仓库代码][Link 7]，以建立整体概念。

在这里，我们有一个WebSocket结构，它保存访问端接点，还有一个wsConn结构，代表连接。

我们在WebSocket上定义了一个Connect方法，其作用是建立一个连接。

我们在wsConn上定义了subscribe方法，用来订阅交易事件。当它记录到一个事件时，会获取到请求者的地址并 检查事件类型是否为RequestQuote。我们只需要这种类型的事件。然后，它调用startJob方法，这将触发Chainlink 预言机的工作。

现在我们有了一个功能正常的区块链，并且正顺利地将预言机连接到它。伟大的工作！让我们继续！

## 5、创建Chainlink外部适配器 ##

外部适配器是能够用我们的预言机调用任何外部API 的关键。我们将在 JavaScript 中构建适配器， 因为一方面，这几乎是标准方法（尽管你可以同样轻松地使用 Go 或 Python）。另一方面，以后我们将 希望能够签署和广播交易到我们的区块链，Cosmos可以为我们自动生成所需的JavaScript代码。

> 外部适配器是Chainlink如何实现自定义计算和专业 API 的简单集成。外部适配器是Chainlink节点的 核心通过其API与简单的JSON规范进行通信的服务。 – Chainlink文档

首先创建一个文件夹link-ea并执行`npm init`。我们将使用一些包，因此让我们安装：

*  @chainlink/external-adapter：用于创建外部启动器的辅助包。
 *  @cosmjs/proto-signing和@cosmjs/stargate：这两个将帮助我们与Cosmos区块链互动。
 *  express和dotenv：这两个包和layda gaga一样出名。他们将帮助处理网络和环境变量。

还记得我告诉过你保存第一次运行区块链时生成的地址的助记词吗？现在我们需要其中之一。创建一个.env文件， 并复制MNEMONIC和ORACLE\_ADDRESS。如果你没有保存它，只需使用`starport serve --reset-once`生成新的帐户。

现在是时候生成与区块链交互的代码了。在区块链文件夹中运行以下命令：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
</pre> </td> 
   <td> <pre>starport serve --rebuild-proto-once
</pre> </td> 
  </tr> 
 </tbody> 
</table>

在此之后，你应该会看到./vue/src/store路径上名为generated的文件夹。这包含生成的代码。我们只需要 其中一些文件，也必须做一些轻微的修改，以便能够在我们的应用程序中正常工作。完整代码可以查看[这里][Link 8]

一旦我们有了这个，就可以设置签署和广播交易的API：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>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
</pre> </td> 
   <td> <pre>const {DirectSecp256k1HdWallet} = require('@cosmjs/proto-signing')
const {assertIsBroadcastTxSuccess} = require('@cosmjs/stargate')

const {MsgCreateQuote} = require('../cosmos/tx')
const { txClient } = require('../cosmos/client')

require('dotenv').config()

class LinkAPI {
    constructor() {
        this.main = {
            //Create, sign and broadcast a quote tx
            signAndBroadcast: async (oracle, requester, quote) =&gt; {
                const wallet = await DirectSecp256k1HdWallet.fromMnemonic(process.env.MNEMONIC);
                const client = await txClient(wallet)

const msg = MsgCreateQuote.fromJSON({
                    creator: oracle,
                    requester: requester,
                    oracle: oracle,
                    text: quote
                })
                const msgAny = client.msgCreateQuote(msg)
                const result = await client.signAndBroadcast([msgAny])
                assertIsBroadcastTxSuccess(result)
                console.log("Result: ", result)
            }
        }
    }
}
module.exports = LinkAPI
</pre> </td> 
  </tr> 
 </tbody> 
</table>

在上面，我们需要一些东西：

*  DirectSecp256k1HdWallet将利用助记词生成一个钱包
 *  assertIsBroadcastTxSuccess将帮助我们验证已签署和广播的交易。
 *  MsgCreateQuote是为我们生成的一个对象。它提供了创建和编码自定义事务消息的接口和方法。
 *  txClient将用于签署和广播交易。

我们创建一个具有具有singAndBroadcast方法和main属性的API类。我们的 API 目前仅包含此功能， 但此设计可方便将来更新它。

signAndBroadcast方法包括预言机地址、请求报价的帐户地址和报价文本。它利用我们的助记词 （存储在文件中）创建一个钱包，并使用该钱包创建交易客户端（txClient）。然后，我们使用 我们之前引入的MsgCreateQuote对象的fromJSON方法，并传入到txClient创建消息的方法。 之后我们调用signAndBroadcast广播消息，并用assertIsBroadcastTxSuccess来检查一切是否顺利。

除此之外，我们有两个重要的文件（我不会在这里粘贴他们的代码）。一个被称为index.js，它定义了 一个createRequest函数，将验证来自我们的外部发起人的API请求的主体，并生成第三方API请求。

另一个是app.js，它负责启动我们的服务器然后调用createRequest。

## 6、把一切放在一起 ##

我们基本完成了！现在是时候看看是否做的每件事都是正确的。让我们逐一启动所有的流程：

*  chainlink node start：运行链链接节点。
 *  starport serve：运行宇宙区块链。
 *  在外部启动器文件夹中运行go build，然后运行external-initiator
 *  node app.js启动外部适配器。

现在向预言机体提交报价请求：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>1
2
3
</pre> </td> 
   <td> <pre>linktestd tx linktest request-quote \
  cosmos1g7gw9jet6czu2m854v0ce3n3us8g8wyjkmdm3n \
  --from alice
</pre> </td> 
  </tr> 
 </tbody> 
</table>

用你自己的预言机地址替换`cosmos1g...`行，并从任何你喜欢的帐户发送。在这里，我使用默认情况下 创建的帐户之一作为请求者，另一个用作预言机。

现在，您应该观察每个终端窗口中的日志，看到各自流程正在开展的工作。

当一切都完成后，你可以使用`linktest q linktest list-quote`查询报价。你应该看到你的预言机发布 在链上的第一个随机报价。

![quote][]

--------------------

原文链接：[Connect a Chainlink Oracle to a Cosmos Blockchain][]

[Link 1]: http://xc.hubwiz.com/course/5b36629bc02e6b6a59171de3?affid=blog7878
[Link 2]: http://xc.hubwiz.com/course/5b9e779ac02e6b6a59171def?affid=blog7878
[EOS]: http://xc.hubwiz.com/course/5b52c0a2c02e6b6a59171ded?affid=blog7878
[Tendermint]: http://xc.hubwiz.com/course/5bdec63ac02e6b6a59171df3?affid=blog7878
[Hyperledger Fabric]: http://xc.hubwiz.com/course/5c9b89f54898e59b7b63430a?affid=blog7878
[Omni_USDT]: http://sc.hubwiz.com/codebag/omni-php-lib/?affid=blog7878
[Ripple]: http://sc.hubwiz.com/codebag/xrp-php-lib/?affid=blog7878
[Tron]: http://sc.hubwiz.com/codebag/tron-java-lib/?affid=blog7878
[Chainlink]: https://chain.link/
[Cosmos]: https://cosmos.network/
[Tendermint Core]: https://tendermint.com/core/
[Chainlink 1]: https://medium.com/kava-labs/bringing-chainlink-oracles-to-cosmos-24e7ec7f006d
[Link 3]: https://docs.chain.link/docs/external-initiators-introduction/
[Link 4]: https://docs.chain.link/docs/external-adapters/
[Diagram of first solution]: /images/20220829/2a23a263c6e841d684609691d24ca067.png
[_IBC]: https://docs.cosmos.network/master/ibc/overview.html
[Diagram of second solution]: /images/20220829/7c357f679c4a4cf4a739f62b3c9a4f35.png
[Link 5]: https://github.com/lajosdeme/Chainlink-Cosmos
[GitHub]: https://github.com/tendermint/starport
[20210731134352218.png]: /images/20220829/a260298cdc2a4932967383c2e15de0f5.png
[postman]: https://www.postman.com/
[Link 6]: https://www.youtube.com/watch?v=ZB3GLtQvgME
[48335702e38002e58f8a79ba5952946d.png]: /images/20220829/7fcb462fdeb4427d9d7a5a9bf4e66f55.png
[Link 7]: https://github.com/lajosdeme/Chainlink-Cosmos/tree/main/external-initiator
[Link 8]: https://github.com/lajosdeme/Chainlink-Cosmos/tree/main/link-ea/services/cosmos
[quote]: /images/20220829/2824c66f4595454093afa9972383111f.png
[Connect a Chainlink Oracle to a Cosmos Blockchain]: https://betterprogramming.pub/connect-a-chainlink-oracle-to-a-cosmos-blockchain-d7934d75bae5