Chainlink去中心预言机网络简介

区块链上的数据和操作都是确定性的，最终是需要被全部区块所共同承认的，也就是通过共识算法达成一致。而现实中的操作和数据都是不确定的，无法与区块链的确定性相对应。

解决方案1 中心化预言机

这种中心化的方案，违背了区块链本身去中心化 decentralized的设计原则；同时，存在传统中心化的弊端，容易出现单点失败的风险，不能向客户提供稳定的服务。

解决方案2 去中心化预言机网络

服务1：DataFeed

chainlink DataFeed基础知识

Chainlink Data Feeds 又称喂价，这项服务可以让用户的智能合约以最快的方式获得特定资产标的价格，不论你使用的是链上的智能合约和还是链下应用，都可以通过单一请求，从 Chainlink Data Feeds 获得资产的价格数据。

DataFeed的示例合约代码

To consume price data, your smart contract should reference **AggregatorV3Interface**, which defines the external functions implemented by Data Feeds.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract PriceConsumerV3 {
	//Consumer调用Proxy合约函数的实现
    AggregatorV3Interface internal priceFeed;

    /**
     * Network: Goerli
     * Aggregator: ETH/USD
     * Address: 0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e
     */
    constructor() {
        priceFeed = AggregatorV3Interface(
            0xD4a33860578De61DBAbDc8BFdb98FD742fA7028e  //根据不同的测试网络和对价要求，在chainlink获取不同的address
        );
    }

    /**
     * Returns the latest price.
     */
    function getLatestPrice() public view returns (int) {
        // prettier-ignore
        (
            /* uint80 roundID */,
            int price,
            /*uint startedAt*/,
            /*uint timeStamp*/,
            /*uint80 answeredInRound*/
        ) = priceFeed.latestRoundData();
        return price;
    }
}

When you use data feeds, retrieve the feeds through the AggregatorV3Interface and the proxy address. Optionally, you can call variables and functions in the AccessControlledOffchainAggregator contract to get information about the aggregator behind the proxy.

Import this interface【AggregatorV3Interface】 to your contract and use it to run functions in the proxy contract. Create the interface object by pointing to the proxy address. For example, on Goerli you could create the interface object in the constructor of your contract using the following example:

/**
 * Network: Goerli
 * Data Feed: BTC/USD
 * Address: 0xA39434A63A52E749F02807ae27335515BA4b07F7
 */
constructor() {
  priceFeed = AggregatorV3Interface(0xA39434A63A52E749F02807ae27335515BA4b07F7);
}

Consumer编写代码中的AggregatorV3Interface指的是Proxy合约中的此接口。

DataFeed的测试合约代码

const { network, ethers } = require("hardhat");
const { loadFixture } = require("@nomicfoundation/hardhat-network-helpers");
const { assert } = require("chai");


describe("单元测试：Chainlink Data feed", async function() {

    /**
     * the function is to deploy smart contracts
     * MockV3Aggregator and DataFeedTaskLocal to the hardhat environment
     */

    async function deployDataFeedFixture() {
        const [deployer] = await ethers.getSigners();

        const DECIMALS = "18";
        const LINK_INITIAL_PRICE = "100000000000000000000";
        const BTC_INITIAL_PRICE = "200000000000000000000";
        const ETH_INITIAL_PRICE = "300000000000000000000";

        const mockV3AggregatorFactory = await ethers.getContractFactory("MockV3Aggregator");
        const mockV3AggregatorLink = await mockV3AggregatorFactory
            .connect(deployer)
            .deploy(DECIMALS, LINK_INITIAL_PRICE);
        
        const mockV3AggregatorBtc = await mockV3AggregatorFactory
            .connect(deployer)
            .deploy(DECIMALS, BTC_INITIAL_PRICE);

        const mockV3AggregatorEth = await mockV3AggregatorFactory
            .connect(deployer)
            .deploy(DECIMALS, ETH_INITIAL_PRICE);
        
        const dataFeedFactory = await ethers.getContractFactory("DataFeedTask");
        
        const dataFeed = await dataFeedFactory
            .connect(deployer)
            .deploy(
                mockV3AggregatorLink.address,
                mockV3AggregatorBtc.address,
                mockV3AggregatorEth.address
            );

        return { dataFeed, mockV3AggregatorLink, mockV3AggregatorBtc, mockV3AggregatorEth }
    };

    // check if the contract is deployed successfully
    // check if the address of aggregator in the DataFeed is the same as aggregator
    it("单元测试 0-0：LINK aggregator 地址配置正确", async () => {
        const { dataFeed, mockV3AggregatorLink } = await loadFixture(
            deployDataFeedFixture
        )
        const response = await dataFeed.getLinkPriceFeed();
        assert.equal(response, mockV3AggregatorLink.address);
    })


    it("单元测试 0-1：BTC aggregator 地址配置正确", async () => {
        const { dataFeed, mockV3AggregatorBtc } = await loadFixture(
            deployDataFeedFixture
        )
        const response = await dataFeed.getBtcPriceFeed();
        assert.equal(response, mockV3AggregatorBtc.address);
    })
      

    it("单元测试 0-2：ETH aggregator 地址配置正确", async () => {
        const { dataFeed, mockV3AggregatorEth } = await loadFixture(
            deployDataFeedFixture
        )
        const response = await dataFeed.getEthPriceFeed();
        assert.equal(response, mockV3AggregatorEth.address);
    })


    // check if the contract is able to fetched the corrected price data defined when the contract deployed
    it("单元测试 0-3: Link aggregator 地址配置正确", async () => {
        const { dataFeed, mockV3AggregatorLink } = await loadFixture(
            deployDataFeedFixture
        );
        const dataFeedLatestPrice = await dataFeed.getLinkLatestPrice();
        const dataFeedRound = (await mockV3AggregatorLink.latestRoundData()).answer;
        assert.equal(dataFeedLatestPrice.toString(), dataFeedRound.toString())
    })

    it("单元测试 0-4: BTC aggregator 返回正确结果", async () => {
        const { dataFeed, mockV3AggregatorBtc } = await loadFixture(
            deployDataFeedFixture
        );
        const dataFeedLatestPrice = await dataFeed.getBtcLatestPrice();
        const dataFeedRound = (await mockV3AggregatorBtc.latestRoundData()).answer;
        assert.equal(dataFeedLatestPrice.toString(), dataFeedRound.toString())
    })
        
    it("单元测试 0-5: ETH aggregator 返回正确结果", async () => {
        const { dataFeed, mockV3AggregatorEth } = await loadFixture(
            deployDataFeedFixture
        );
        const dataFeedLatestPrice = await dataFeed.getEthLatestPrice();
        const dataFeedRound = (await mockV3AggregatorEth.latestRoundData()).answer;
        assert.equal(dataFeedLatestPrice.toString(), dataFeedRound.toString())
    })

    it("单元测试 0-6: LINK aggregator 返回正确结果", async () => {
        const { dataFeed, mockV3AggregatorLink } = await loadFixture(
            deployDataFeedFixture
        );
        const dataFeedLatestPrice = await dataFeed.getLinkLatestPrice();
        const dataFeedRound = (await mockV3AggregatorLink.latestRoundData()).answer;
        assert.equal(dataFeedLatestPrice.toString(), dataFeedRound.toString())
    })
});

服务2：VRF（Veritified Random function）

在密码学中，可验证随机函数（VRF）是一种随机数生成器（RNG），可以通过加密手段来验证随机性。可验证的随机数对许多区块链应用来说都是不可或缺的要素，因为这类随机数具有防篡改性和不可预测性，可以用来打造刺激的游戏体验，铸造罕见的NFT，并保障公平的结果。

本文将讨论什么是可验证随机函数，研究随机数在区块链上的应用，以及智能合约开发者如何利用Chainlink可验证随机函数（VRF）在dApp中获得安全的随机数来源。

什么是可验证随机函数（VRF）？

可验证随机函数是一种加密函数，基于数据输入生成伪随机数并附上一份证明，任何人都可以对其进行验证。

VRF的数据输入通常包含一对公钥和私钥（也称为“verification key”和“secret key”）以及一个seed。公钥和私钥是生成的，而seed则是选择的。将这些数值一起输入VRF，用私钥和seed来生成随机数。然后，VRF会生成一个随机数以及一份证明。最关键的一步是生成证明，因为用户可以通过证明来验证函数。而将私钥保密则可以确保随机数无法被预测。

可验证随机函数的关键特质都写在了它的名字里：

可验证——任何人都可以验证VRF生成的随机数是否有效，只需要查看证明并验证哈希计算结果是否正确即可。只有持有VRF私钥的人才能进行哈希运算，而任何持有公钥的人都可以验证哈希运算结果。
随机——对于不知道seed或不持有私钥的人来说，VRF输出的结果完全不可预测且概率均匀分布，没有任何规律可循。VRF输出的每个结果都拥有同样的概率，并使用seed和私钥，以独特的方式生成随机数。
函数——VRF使用数学算法来生成随机数以及证明。VRF将seed隐藏起来，以保障其不可预测性；同时，将随机数证明公开，以供所有人查看和验证。

VRF的发展历史

可验证随机函数这个概念是在1999年由知名计算机科学家和数学家Silvio Micali、Michael Rabin以及Salil Vadhan在论文中提出的。值得一提的是，Silvio Micali后来创建了Algorand区块链，Algorand在共识机制中也使用了VRF。

之后，VRF技术出现了一系列关键突破。2005年，Yevgeniy Dodis和Aleksandr Yampolskiy使用了抗碰撞哈希函数实现了更短的证明和密钥，因此提升了VRF的效率，并推动了这项技术的发展。2015年，Dennis Hofheinz和Tibor Jager使用椭圆曲线加密技术开发了可验证安全性的VRF。2019年，Nir Bitansky提出了VRF可以用一般原语构造，而不用简单的代数构造。如今许多VRF方案都建立在这些创新之上。

2020年，研究者提出了一种使用Lattice加密的VRF方案。这个方案的安全性足以抵御量子计算机发起的攻击，这意味着VRF将在未来仍是一项重要技术。

VRF的应用场景

大多数RNG都无法生成可以通过加密技术进行验证的随机数，因此这类RNG容易受到操纵，导致其应用场景受限。VRF如果能保障随机数的安全性，就可以解锁一系列关键的用例，其中包括：

网络安全——使用VRF保障域名系统（DNS）消息传输的安全性。
零知识技术——VRF可以用来打造零知识证明和零知识数据库。
非交互式抽奖系统——VRF可以为抽奖游戏保障公平、可验证且高效的结果。
可验证的交易托管机制——VRF可以支持自动托管服务，保障用户的匿名性。
区块链和智能合约——VRF已经成为了去中心化协议和应用重要的组成部分。

区块链中的VRF

包括Algorand、Cardano、Internet Computer和Polkadot在内的许多L1区块链都在共识机制中使用了VRF来随机选择出块节点。

另外，区块链智能合约开发者在开发应用时也需要随机数。然而，由于区块链网络具有高确定性，链上应用往往无法获得安全的随机数生成器。使用链上区块哈希生成随机数有可能被区块链矿工/验证者操控，他们可以放弃对他们不利的区块，重新“掷色子”，以改变随机数。而链下随机数则缺乏透明性，而且无法验证随机数是否公正且没有受到数据源或节点的操控。

可以利用链上生成随机数方案的漏洞谋取私利。

稳健的随机数生成方案意味着随机数的公平性可以得到验证，所有参与者都拥有同样的概率，并且攻击者不太可能通过预测随机数来操纵智能合约。

Chainlink VRF

Chainlink VRF 是公平、可验证的RNG，可以满足上述需求，为智能合约提供具有加密证明的安全随机数，无法被预言机节点、用户或开发团队篡改。

Chainlink VRF可以为开发者带来以下好处：

不可预测性——Chainlink VRF无法被预测。由于在请求随机数时无法得知区块数据，因此任何人都无法通过预测随机数来提高自己的成功概率。
公平性——Chainlink VRF非常公平公正，因为随机数是均匀分布的，所有数字都有同样的概率被选中。
随机性——Chainlink VRF的随机性可以得到验证，因为其使用区块哈希作为seed来生成随机数，而区块哈希无法提前预知。
防篡改性——Chainlink VRF具有防篡改性，任何人，包括预言机、外部方或开发团队，都无法操纵随机数生成流程。

Chainlink VRF是用户和区块链之间的抽象层，可以帮助智能合约开发者访问安全的随机数来源。

Chainlink VRF采用了开源代码和加密技术，生成防篡改的随机数，用户可以验证随机数的真实性。

Chainlink VRF采用了Goldberg的可验证随机函数（VRF），详情请查看这篇论文。Chainlink VRF会针对每一个随机数请求生成一个或多个随机数，并附上一份随机数的加密证明。这份证明会被发布到链上并在链上得到验证，验证通过后才会使用随机数。

Chainlink VRF的应用场景

Chainlink VRF目前正在为Web3生态中的众多应用提供安全的链上随机数来源，其中包括GameFi、DeFi以及NFT等项目。

ChainlinkVRF的应用场景包括：

为NFT分配随机属性——Chainlink VRF可以用来铸造特殊的NFT。比如，Axie Infinity 使用Chainlink VRF为每个Origin Axie赋予随机属性。
公平地分配罕见NFT——Chainlink VRF可以证明NFT是公平分配的，且证明可以得到验证。比如，Bored Ape Yacht Club（BAYC）使用Chainlink VRF向BAYC NFT持有者随机分配变异血清NFT。
游戏结果无法预测——开发者可以利用随机数打造出更好玩的区块链游戏。比如，Blockmine使用Chainlink VRF在Next Card游戏中随机抽取卡牌。
公平地选出参与者——发放热门活动门票，抽取奢侈品预售的买家，以及选出热门公开发售活动的参与者。比如，Centaur使用Chainlink VRF选出链上公开发售活动的参与者。
随机选出中奖者——Chainlink VRF可以让用户验证中奖者的筛选流程是否公平公正。比如，PoolTogether是一个无损储蓄游戏，将用户存款放在一个资金池中，并每天和每周展开抽奖，将池子的收益随机分配给中奖者。

PoolTogether利用Chainlink VRF随机选出无损储蓄游戏的中奖者。

服务3：Keepers合约自动化（自动执行智能合约）

一开始，我们要先统一智能合约自动化的概念，也就是要搞清楚智能合约自动化可以帮开发者解决哪些问题。

问题：智能合约无法自动执行

智能合约是在区块链上运行的确定性程序。其代码逻辑是：“如果发生事件x，则执行任务y”。然而，智能合约无法自动执行，也就是说，合约必须要被一笔链上交易触发才能运行，并在链上发起状态变更。这笔外部交易的作用是“唤醒”智能合约，并触发合约逻辑。这就好像你得用鼠标点击桌面上的图标才能启动程序一样。

举个例子，你必须发起一笔链上交易，调用区块链借贷协议的清算功能，才能清算抵押率不足的贷款。一旦调用了这个功能，借贷协议的清算智能合约将会参考链上喂价，验证贷款是否存在抵押率不足。如果是，则用户的抵押品会被清算，以支付欠款；否则，交易会被撤回。

一些情况下，终端用户会直接通过自己的智能合约交互来调用链上功能。比如，如果一名用户想要在去中心化的货币市场贷款，可以发起一笔交易，通过抵押资产来贷入通证，这笔交易可以直接触发智能合约的贷款发放函数。这个函数将判断用户的贷款额度上限，然后将贷款金额发到用户地址。然而，很多时候智能合约为了保证协议能够健康运行，必须能够自动执行链上功能。

解决方案：通过Keepers实现交易自动化

Keepers是外部账户（EOA），可以在一定经济激励下触发智能合约基于预定义的条件执行。开发团队、DAO或协议用户可以在任务中定义/提交触发条件以及完成keeper任务可以获得的奖励。智能合约通常会基于时间（比如每天在东部标准时间下午5点触发x函数）或事件（比如当资产价格超过某一阈值时触发y函数）自动执行。

Keepers是非常好用的智能合约自动化机器人，可以监控预定义的条件是否达成，一旦达成，则会自动发起交易。在这个过程中，Keeper会使用链下计算来执行与链上同样的智能合约函数。一旦函数返回值为true，则keepers会发起一笔链上交易，调用链上智能合约函数。当函数被调用后，协议的智能合约就会验证条件是否满足，然后会发起状态变更，以确保keeper是正确的。因此，智能合约只有当需要时才会根据定义清晰的条件在区块链上运行。

虽然keepers的作用相对比较简单易懂，但更重要的是在实现keeper的过程中考虑一些关键的技术问题，以更好地理解Chainlink Keepers在设计方面的独特优势。

智能合约自动执行需要考虑的安全和成本因素

以下是在自动执行智能合约时必须考虑的安全和成本因素。

手动完成DevOps任务以及使用中心化的服务器

有一种keeper是在中心化的服务器上运行一个脚本，或让开发团队监控触发合约的条件是否达成，并手动发起链上交易。在这类方案中，keeper存在单点失效风险，无法保障第一时间执行智能合约函数（注：比如keeper下线或延迟）。如果智能合约无法及时执行，就可能出现由于信息不对称而导致的操纵行为，或导致用户错失一些机会，最常见的包括交易滑点、协议资金枯竭以及用户资金损失。

靠开发者手动完成DevOps任务还会占用项目有限的开发时间和资源，而这些资源本来可以用来开发核心产品以及扩大生态规模。随着时间推移，项目会想要通过将智能合约自动化来简化用户体验，并添加更多高级的功能。因此，手动完成DevOps任务会显得越来越麻烦。最终，智能合约需要实现去中心化，而负责触发合约执行的链下keeper基础架构也需要实现去中心化。

赏金机制成本高昂且无法预测

另一类keeper采用的方式是悬赏奖金。当触发条件满足时，第一个调用链上函数的keeper会获得一笔奖金。虽然这个方案基于中心化的keeper模式得到了不断改善，但仍然在成本效益、中心化水平以及不可预测性方面存在挑战。

赏金机制最大的问题在于，keeper节点最后会形成“赢者通吃”的直接竞争，这会引发优先gas拍卖（PGA）的价格战。Keepers之间互相竞争，将不断推高gas价格。因此keepers不得不支付越来越高的gas费来让矿工优先处理他们的交易。由于条件满足后只能调用一次智能合约函数，因此只有最先调用函数的keeper可以成功获得酬劳。所有其他keeper都会无功而返，因为发起的交易失败而白白承担gas费损失。大多数keeper任务的成本都包含基础费用以及一笔gas费，因此PGA会导致终端用户成本上涨，因为gas费上涨最终会转嫁到终端用户头上。

采用公开悬赏机制的keeper还会导致其他意想不到的问题。比如，PGA会加剧区块链上的拥堵，进一步推高keeper以及网络其他用户的gas费用。另外，竞争还会导致keeper数量逐渐减少，最后只有少数资本雄厚的keeper才有实力参与gas价格战。中心化的keeper网络中，负责监控和提交交易的keeper数量会相对较少，因此在可靠性方面会打折扣。

公开赏金机制还有一个危险之处，那就是keeper无法直接对智能合约做出承诺，保障服务的及时性。这在一定程度上导致了不确定性，特别是在市场严重波动和网络拥堵的情况下，而在这些情况下往往是最需要keeper效力的。比如，如果一小群互相竞争的keeper由于gas价格太高、gas余额不足或没时间等原因而不能及时触发链上合约，那么借贷协议可能就无法及时清算，最后导致合约违约。

从上述这些keeper方案中我们可以总结出一个经验教训，那就是keeper网络在自动触发智能合约时需要保障成本效益、防篡改以及可用性。

Chainlink Keepers：去中心化，成本低，并且能可靠地自动执行智能合约

项目与其采用中心化的keeper模式或冒险采用公开悬赏机制，不如使用Chainlink Keepers实现智能合约自动化。Chainlink Keepers是一个去中心化的交易自动化服务，其可靠性和激励机制都得到了实战的检验。Chainlink Keepers已经在以太坊和Polygon上运行，未来还会接入更多区块链。

Chainlink Keepers拥有以下优势：

经济激励机制——Chainlink Keepers为用户提供了一个简单的框架，用户可明确定义去中心化Chainlink节点的任务和奖励，并创建可预测的经济激励机制。
运行稳定——Chainlink Keepers沿用了Chainlink Price Feeds专业的DevOps团队运行节点，这些DevOps团队在极端地网络拥堵和市场波动期间也能可靠地运行Chainlink Price Feeds。Chainlink Keepers节点已经在各个Chainlink服务（如：Price Feeds）中为智能合约保障了800多亿美元的价值
成本低——Chainlink Keepers网络拥有多个gas费优化功能，可以降低dApp自动化的成本；并建立了轮转机制筛选节点，避免PGA价格战并稳定用户成本。
执行去中心化——Chainlink建立了去中心化且透明的Keeper池，可以更安全、及时地执行智能合约，为团队节省大量时间，并降低了人为干预或中心化服务器存在的风险。
功能更强——Chainlink Keepers可以执行高级的链下计算并生成智能合约可验证的calldata，因此可以为开发者可实现前所未有的高级功能，并且不需要额外的信任假设。
无缝集成——Chainlink Keepers可以在几个小时内就集成至智能合约。开发者可以查阅简单易懂的开发文档并获得详细的指导。

开发者可以利用Chainlink Keepers轻松添加新的维护任务，自动执行各种智能合约功能。

Chainlink Keepers将为许多项目进一步拓展智能合约的功能并提升用户体验。

Chainlink Keepers自动执行智能合约的用例

下面我们会跟大家分享几个Chainlink Keepers的具体用例。我们在这里只是抛砖引玉，希望能够启发广大开发者打造出更多创新的应用场景。

自动聚合收益并偿还贷款

Alchemix 是一个自动还贷的借贷协议。其集成了Chainlink Keepers，每天聚合用户抵押资产所产生的收益。聚合的收益用来偿还一部分贷款，整个过程中无需任何人为干预。

以去中心化的方式rebase弹性供应通证

COTI 正使用Chainlink Keepers锚定加密货币波动指数（CVI）来调整通证供应量，UTC时间每天半夜12点会rebase一次。这样做可以更好地保障通证以完全去中心化的方式锚定CVI指数。

以最佳方式重新平衡流动性供给

Visor Finance 是针对Uniswap v3流动性提供方（LP）的管理协议，其目的是优化收益回报率。Visor Finance集成了Chainlink Keepers，当达到预定义阈值时将收益和资产重新投资到活跃的流动性持仓和单一资产限价单。因此，LP可以高效及时地配置资产，并维持较高的资产利用率。

当特定事件发生时铸造限量版NFT

Curse NFT 是一个动态NFT艺术品项目，项目基于以太坊价格走势展示出模特Krystal Schott脸部五种不同的3D渲染模式。Curse NFT集成了Chainlink Keepers，当以太币价格达到2万美元时将触发NFT展示最终的完整形态。

一只小码农

Chainlink预言机介绍