邹杰:Libra 技术专业解析

技术干货 | Libra 技术解读,详解Libra共识协议! 01 Libra 区块链简介 Libra 区块链的目标是成为金融服务的基础,包括打造一种新的全球支付系统,满足数十 十亿人的日常金融需求。通过对现有区块链解决方案的评估, Libra 决定基于下列三项要求构 建一个新的区块链: 能够扩展到数十亿帐户,这要求区块链具有极高的交易吞吐量和低延迟等特点,并拥 有一个高效且高容量的存储系统。 高度安全可靠,可保障资金和金融数据的安全。 灵活多变,为未来金融服务创新提供动力。 Libra 区块链就是为了了全... 阅读详情

摘要:Libra支持并行计算parallel updates. 这对提高TPS效率非常重要的。LibraBFT有了一个最新的更新,就是说它这个链可以容许有空块的存在和也有临时的侧链的存在。然后能够达到最后一轮LibraBFT共识的就成为最后的主链。他试图把这个树的分枝变得更平衡,那么这样储存起来,检索速度最快。Libra的共识机制建立在最新的拜占庭将军协议进展上的HotStuff。以前如果拜占庭将军协议的节点大于30以后,它的效率就会急剧下降。那么最新的进展HotStuff或其他的,可以是达到上百,甚至上千还仍然保持高效率。拜占庭将军协议的突破性进展才可能使联盟链有上百上千上万的节点数。

 

【以下为主题分享内容】

 

Claire: 大家晚上好!我是【魔笛手技术开发社区】的创始人Claire Wu,也是今晚的主持人。

 

首先,我来介绍一下今晚的主讲嘉宾邹杰先生,他是柏链科技CTO,是瑞士联邦理工学院(洛桑)博士,克利夫兰俄亥俄州州立大学计算机硕士,华中科技大学材料专业学士,Drexel大学博士后。曾服务于美国宇航局NASA克利夫兰研究中心和美国国家研究委员会NRC 5年以上。拥有二十年硅谷互联网经验及教训,包括云计算及系统疑难攻关。熟悉各种区块链结构、区块链层次结构、二层协议、共识机制、VRF、比特币、分布式金融、闪电支付网络、分布式交易所、稳定币、OTC、Libra、 Open Libra、Libra数据结构、MOVE智能合约。

 

继比特币和以太坊之后,真正能够引爆世界区块链领域的是Libra. Libra 子凭父贵,因为Facebook而被世人疯狂追捧。然而,对于金融业来说,区块链是一个颠覆性的创新。Libra和比特币,以太坊这种去中心化的网络不一样,它有问责团体,传统的金融机构和政府对Libra所带来的威胁疑虑重重,千方百计阻挠其发展,令Libra举步维艰。不过,Libra凝聚了世界上很多顶尖程序猿的智慧,在架构,效率和可信度上,因应不同的实际需求作出了改良。如果你也想学习Libra 的核心技术和精髓,敬请关注以下邹杰先生主讲的直播:『Libra技术专业解析』

 

现在有请邹杰先生……

 

邹杰:大家好!我今天主讲的题目是:『Libra技术专业解析』

 

第一是背景,为什么要研究Libra

 

首先这是与区块链的困境有关的。到目前为止,区块链除了发币和炒币外,还没有成功的商业模式,而且这两个模式在大多数情况下都是不合规合法的。其他商业模式,比如存证溯源积分发票等应用,都不能挣钱,都不是一个成功的商业模式,尽管是可以去做,但这些都是伪需求。

 

Libra是第1次把区块链和数字货币连在一起,不发空气币,只发与法币价值等价的数字货币,并有等量的法币储备来做价格支撑,而且是合规合法的。当然要合规合法,就不可能是一个公链,因为每个节点都需要是合规合法的,这就是为什么选择了一个联盟链,当然,联盟链的选择也是因为在拜占庭将军协议取得了突破性的进展。拜占庭将军协议能够高效处理上百个节点。与以前的联盟链相比,比如说fabric hyperledger相比是不一样的,因为以前的联盟链是不发币的,是主要作为一个信息的交流,而不是真正价值的交换,没有币是不可能实现价值交换的。合规合法是联盟链的一个特性,当然以前的联盟链通常是用在产业链,比如说供应链金融里面。其实还没有走过合规合法的流程。Libra是第1个发行一个数字货币走合规合法全流程的联盟链。

 

尽管Libra是自比特币以来的最大的一个突破,但是,他的愿景和现实的冲突还是巨大的。Libra愿景是为没有银行账户的人群提供银行服务,但是这些没有银行账户的人,他们大多数都生活在当地法币不稳定,或者不能自由兑换的国家和地区,而Libra只能支持稳定的法币,已经发展发达国家,能够自由兑换的法币。所以,Libra他的愿景和现实是有一个根本性上的冲突,这个冲突不是通过技术能够解决的。Libra是一个全球货币,而这些发展中国家,他们的法币不可能是以全球货币的一部分。另外Libra也有它的局限性,至少是现在来看,首先它只支持支付,只支持一个全球数字货币,而且用一个新的MOVE语言。已经有半年了MOVE还没有正式发布,直到现在还是用他的一个中间临时的IR。

 

Libra的目标及与以前区块链的关系

 

首先,他的目标是要突破币圈的局限性。币圈只能发币和炒币这两个真正具有商业价值的应用。在币圈里面的所有发行的币,除了比特币包括比特币现金和以太坊外,一般都不能够用来作为支付手段去购买一个真实的东西。那么第一个超越币圈以外的应用,当然就是支付,这就是Libra专注的应用。当然要支付就涉及到必要的安全性,因为这是真金白银。也是当年中本聪发明区块链和比特币的最主要的想法和应用。支付要用到现实社会当中,就需要一定的效率。比如TPS要足够高,这是以太坊和比特币的局限性和EOS的启示,区块链可以做到足够高的效率,TPS可以上千。另外智能合约也是必要的,而且智能合约的安全性是绝对重要的,这是以太坊的启示。因为在以太坊的智能合约里发现了很多漏洞被攻击,所以很难在以太坊上开发一个完全没有漏洞的智能合约,这对于金融应用是非常致命的。Libra核心就是能够有一个MOVE语言,验证器及虚拟机来保证安全,能够逐步做到formal verification完整的验证。可以基本上保证没有代码层的漏洞。

 

下面就开始讲这个里边儿的核心技术,因为我们这次讲座,主要是讲Libra技术。

 

首先Libra不是一个区块链,它是一个数据库,是一个能够自我证明的,自然数据的数据库。能自我证明,就是说能够用已有的数据也验证这个数据库的数据是否被修改了,自然数据是说它是随着交易次数不断增加的是不可逆的,不可能回滚的。数据也就是用了这个叫做Sparse Merkle Tree。这也是以太坊用的。

当其中的一些节点数据是不存在的时候,它能够验证说这些节点上的数据是不存在的。也可以验证这个其他有数据的节点上的数据的正确性。它还有一个其他的特性,就是说它能够支持分片sharding。这个对于扩展数据库是非常重要的。还有就是它支持这个并行计算parallel updates。这也是对提高TPS效率非常重要的。另外它也支持并行计算最初的交易的验证和签字的验证,这也是非常重要的。证明:VRF函数Verify(alpha, f, r, pi) 例子alpha = H(h4||H(H(2||r)||h3))

 

当然Libra也试图考虑用AVL Tree。AVL Tree的核心是一个平衡树。

 

就是说他试图把这个树的分枝变得更平衡,那么这样储存起来,检索速度最快。下面这张图就是一个AVL Tree表现,你可以看到它是一个非常平衡的树,它没有其中一个枝变得特别长而其他地方没有枝。然后也有人把这个AVL Tree进一步的发展成AVL+ Tree。

 

左边是AVL+ Tree树每个节点的数据。右边是这个树的证明。就是对应每个节点的哈希值。这样当这个节点的数据发生变化的时候,那么右边这个证明的树就会改变,这就是用来证明这个数据是否被修改了。其实在Libra里面用到的这个证明函数就很类似于这个VRF的验证函数,里面包括了一个最初值,它的函数,另外就是它们的计算结果和计算结果的证明。 

 

还有就是Libra的拜占庭将军协议共识所形成的交易是确定的。比特币共识机制是不一样的,就是所有的POW共识的交易都是不是100%确定的。这也是一个很重要的区别。现在LibraBFT有了一个最新的更新,就是说它这个链可以容许有空块的存在和也有临时的侧链的存在。然后能够达到最后一轮LibraBFT共识的就成为最后的主链。

 

另外就是哈希函数和签名,也是用了一个比较新的技术。他的这个签名是用的ed25519 Edwards Curve Digital Signature Algorithm (EdDSA: 2017)。就是2017年的版本,这个版本应该是说是可以说是Ed25519曲线上的最新的一个算法。那么这个算法的特征就是没有怀疑的NSA的后门漏洞。以太坊和比特币用的是P-256曲线被怀疑有NSA的后门漏洞,也就是为什么这个函数将会被用到TLS 1.3版,在这是在2018年定下来的,就是为了防止NSA留下后门漏洞。EdDSA也是美国标准局NIST在2017年推荐给所有美国联邦政府机构使用的算法。还有就是每次的交易,都会有一个多于2/3(3f+1)的节点间签名。对每一个交易最后都形成一个Shnorr签字。区块链是通过每个块的哈希值连接在一起。Libra数据库则是每个交易都有多于2/3(3f+1)的节点签名而且每个交易都有一个序列号及整个数据库都有一个从创始交易开始的总交易数量版本号来防止重复和回滚。

Block-tree Libra // 区块树的定义

Block // 区块

round ; // the round that generated this proposal 轮数

payload ; // proposed transaction(s) 交易

parent qc ; // qc for parent block 上轮签字

id ; // unique digest of round, payload and parent qc:id

// 上面三个数(轮数,交易,上轮签字)的哈希值

VoteInfo // 投票信息

id, round ; // id and round of block

parent_id, parent_round; // id and round of parent

exec_state id ; // speculated execution state

// speculated new committed state to vote directly on

LedgerCommitInfo // 预计的写入数据库结果

Commit_state_id ; // nil if no commit happens when this vote is aggregated to QC

Vote_info_hash ; // hash of VoteMsg:vote info

VoteMsg // 投票结果

Vote_info ; // a VoteInfo record

Ledger_commit_info ; // Speculated ledger info

sender <- u, signature <- signu(ledger commit info);

// QC is a VoteMsg with multiple signatures

QC // 法定人数签字证书

Vote_info // 投票信息

Ledger_commit_info // 写入数据库结果

signatures; // quorum of signatures 签字

PendingBlkTree ; // tree of blocks pending commitment 预备块的树

PendingVotes ; // collected votes per block indexed by their LedgerInfo hash 收集的块投票

High_qc ; // highest known QC 最高的法定人数签字

Procedure execute_and_insert(b) // 执行和插入

Execute_state_id <- Ledger:speculate(P:parent_qc:block_id; P:id; P:payload)

PendingBlkTree:add(b)

High_qc <- maxround{b:parent_qc; high_qc}

Procedure process_vote(v) // 投票过程

vote idx <- hash(v:ledger_commit_info)

V[vote_idx] <- V[vote_idx] U v:signature

if |V[vote_idx]| = 2f + 1 then

qc <- QC<

vote_info <- v:vote info,

state_id <- v:state id,

votes <- V[vote idx]

>

Pacemaker.advance_round(qc) high_qc <- maxround{qc; high_qc}

Function generate_proposal(cmds) // 提出出块建议

return <

b:round <- current_round,

b:payload <- cmds,

b:parent_qc <- high_qc,

b:id <- hash(b:round || b:payload || parent_qc:id)

>

Function process_commit(id) // 执行数据库更新

Ledger:commit(id)

PendingBlkTree:prune(id) // id becomes the new root of pending

 

Libra链也包含了一个日志数据库。这个独立的数据库是非常重要的。就是用来写交易输出结果作为验证交易是否成功。如果交易执行了无论成功与否都会写入日志。比如gas费没有了,时间过期了,等等。日志包括这个账号的路径和这个交易的本身以及这个交易的这个序列数。所以这三个在一起就形成了一个唯一的值。这个就是会被用来验证每个交易的有效性。

 

Libra也用了哈希3的算法SHA3-256。这个也是以太坊用的但比特币没有用。应该是比sha2-256更好。

 

Libra的共识机制也是建立在最新的拜占庭将军协议进展上的HotStuff。以前如果拜占庭将军协议的节点大于30以后,它的效率就会急剧下降。那么最新的进展HotStuff或其他的,可以是达到上百,甚至上千还仍然保持高效率。拜占庭将军协议的突破性进展才可能使联盟链有上百上千上万的节点数。这是以前做不到的,也就是在比如说fabric和hyperledger里面,是做不到的。下面这张图就是它的一个最核心特征:链块。它是通过三轮由不同的出块者来提出需要共识的块。每轮都有签字而且后面的轮的签字都是建立在上一轮上面的。

 

每一轮的拜占庭将军协议都是建立在上一轮上的。最后第三轮一起commit写进数据库。图上这个QC就是2/3以上节点的签字证书(法定人数签字证书)。

 

每轮都包含了这个QC法定人数签字证书。这是每轮里包含的几个数据。就是它的ID,第几个轮,这个交易本身和这个交易时间及签字。

 

这个图就是说如果是其中有一轮没有达成共识,就是说会是因为gas费用完了或者时间过期了,那么他仍然能够通过第二轮第三轮这个回合来形成达成共识。下面图里的K就是Timeout Certificate (TC)就是未完成轮的法定人数签字证书。

 

现在的HotStuff拜占庭将军协议的算法上,大概能支撑上百个节点,但是如果要支撑上万个节点的话,那还需要不同的,具有更强扩展性的拜占庭将军协议。BFTree的算法和其中一个。这是一个拜占庭将军协议里的节点树。从这个图当中就会看到,如果是这个有节点没能够达到共识的,那么它会将把这些节点从这个树里面移出去。那么只有形成共识的节点才会留在这个树里面。

 

其他还有一种叫做MOCA的共识机制。就像这张图显示的一样,就在这个图当中你会看到一个星号在最右边。就说它的这个节点数可以达到100万,同时它的这个TPS还可以达到上万。,这就是这个共识机制特别的地方。

 

还有就是Libra在HotStuff当中没有具体描述和实现的。就是每一步是怎么计算的?每个回合是如何计算的?Libra有一套新的实现,它不是用绝对时间而是用步骤来作为计算,这样就避免了在不同的节点在不同的时间区,会形成不同的时间造成的时间差的问题。

 

还有就是MOVE语言。MOVE语言的最大的特性就是实现了资金和逻辑的分离。比如说Libra代币就定义为合约的资源或资产部分。合约的逻辑就是模块部分。在Libra里面资产只能产生,销毁和转移但不能复制。就像一个硬件东西只有一个原件没有复制品。下面是MOVE语言的组成部分

 

a) MOVE语言

├── README.md      # This README 简介

├── benchmarks      # Benchmarks for the Move language VM and surrounding code

├── bytecode-verifier  # The bytecode verifier 验证器

├── e2e-tests         # Infrastructure and tests for the end-to-end flow 端到端测试

├── functional_tests    # Testing framework for the Move language 功能测试

├── compiler          # The IR to Move bytecode compiler 编译器

├── stdlib             # Core Move modules and transaction scripts 标准库

├── test.sh            # Script for running all the language tests 测试脚本

└── vm

    ├── cost-synthesis  # Cost synthesis for bytecode instructions gas费分析

    ├── src    # Bytecode language definitions, serializer, and deserializer代码

    ├── tests          # VM tests 虚拟机测试

    ├── vm-genesis # The genesis state creation, and blockchain genesis writeset创世块

└── vm-runtime   # The bytecode interpreter 执行码

 

b) MOVE编译器把模块和脚本编译成字节码(开发很费时=低效)(Module & Script)

USAGE:

    compiler [FLAGS] [OPTIONS] 编译选项

FLAGS:

    -h, --help        Prints help information 帮助

    -l, --list_dependencies    Instead of compiling the source, emit a dependency list of the compiled source 依赖库

-m, --moduleTreat input file as a module (default is to treat file as a program) 模块 

--no-stdlib   Do not automatically compile stdlib dependencies 不编译标准库里的依赖库

--no-verify   Do not automatically run the bytecode verifier 不跑验证器

    -V, --version    Prints version information 打印版本号

OPTIONS:

    -a, --addressAccount address used for publishing 发布的账户地址

    --deps      Path to the list of modules that we want to link with 连接列表

    -o, --output     Serialize and write the compiled output to this file输出文件

ARGS:

Path to the Move IR source to compile 输出文件夹

 

c) MOVE编译器的组成

compiler               # Main compiler crate. This depends on stdlib.

├── ir-to-bytecode   # Core backend compiler logic, independent of stdlib.

│   ├── src

│   │   ├── compiler.rs# Main compiler logic - converts an AST generated by `syntax.rs` to a `CompiledModule` or `CompiledScript`.

│   │   └── parser.rs    # Wrapper around Move IR syntax crate.

│   └── syntax           # Crate containing Move IR syntax.

│       └── src

│           ├── ast.rs   # Contains all the data structures used to build the AST representing the parsed Move IR input.

│           ├── syntax.lalrpop  # Description of the Move IR language, used by lalrpop to generate a parser.

              └── syntax.rs        # Parser generated by lalrpop using the description in `syntax.lalrpop` - a clean checkout won't contain this file.

└── src

    ├── main.rs          # Compiler driver - parses command line options and calls the parser, compiler, and bytecode verifier.

    └── util.rs            # Misc compiler utilities.

 

这是一个MOVE交易例子。核心是资产Libra coin(import 0x0.LibraCoin;)只能被转账

// A small variant of the peer-peer payment example that creates a fresh

// account if one does not already exist.

import 0x0.LibraAccount;

import 0x0.LibraCoin;

main(payee: address, amount: u64) {

  let coin: LibraCoin.T;

  let account_exists: bool;

  // Acquire a LibraCoin.T resource with value `amount` from the sender's

  // account.  This will fail if the sender's balance is less than `amount`.

  // 提款

  coin = LibraAccount.withdraw_from_sender(move(amount));

  account_exists = LibraAccount.exists(copy(payee));

  if (!move(account_exists)) {

    // Creates a fresh account at the address `payee` by publishing a

    // LibraAccount.T resource under this address. If theres is already a

    // LibraAccount.T resource under the address, this will fail.

    create_account(copy(payee));

  }

  // 存款

  LibraAccount.deposit(move(payee), move(coin));

  return;

}

只有module LibraCoin模块本身才能生成,销毁,合成Libra coin。下面就是对上面Libra账户LibraAccount两个资产转移函数提款和存款的定义(只是用来说明不是真正Libra代码里的)

// 数字货币

module Currency {

// 定义数字货币

resource Coin { value: u64 }

// 存款

public deposit(payee: address, to_deposit: Coin) {

let to_deposit_value: u64 = Unpack<Coin>(move(to_deposit));

let coin_ref: &mut Coin = BorrowGlobal<Coin>(move(payee));

let coin_value_ref: &mut u64 = &mut move(coin_ref).value;

let coin_value: u64 = *move(coin_value_ref);

*move(coin_value_ref) = move(coin_value) + move(to_deposit_value);

}

// 提款

public withdraw_from_sender(amount: u64): Coin {

let transaction_sender_address: address = GetTxnSenderAddress();

let coin_ref: &mut Coin = BorrowGlobal<Coin>(move(transaction_sender_address));

let coin_value_ref: &mut u64 = &mut move(coin_ref).value;

let coin_value: u64 = *move(coin_value_ref);

RejectUnless(copy(coin_value) >= copy(amount));

*move(coin_value_ref) = move(coin_value) - copy(amount);

let new_coin: Coin = Pack<Coin>(move(amount));

return move(new_coin);

}

}

真正的Libra币LibraCoin在Libra代码里的定义如下:

https://github.com/libra/libra/blob/master/language/move-lang/stdlib/modules/libra_coin.move

// Libra币的代码定义

address 0x0:

module LibraCoin {

// 交易

    use 0x0::Transaction;

 // A resource representing the Libra coin

 // The value of the coin. May be zero

 // 币本身

    resource struct T { value: u64 }

 // A singleton resource that grants access to `LibraCoin::mint`. Only the Association has one.

    resource struct MintCapability {}发币权限

 // The sum of the values of all LibraCoin::T resources in the system

// 发币数量

    resource struct MarketCap { total_value: u64 } 

 // Return a reference to the MintCapability published under the sender's account. Fails if the

 // sender does not have a MintCapability.

 // Since only the Association account has a mint capability, this will only succeed if it is

 // invoked by a transaction sent by that account.

// 发默认币数量

    public mint_with_default_capability(amount: u64): T acquires MintCapability, MarketCap{

        mint(amount, borrow_global<MintCapability>(Transaction::sender()))

    }

 // Mint a new LibraCoin::T worth `value`. The caller must have a reference to a MintCapability.

 // Only the Association account can acquire such a reference, and it can do so only via

// `borrow_sender_mint_capability`

// 发新币数量

    public mint(value: u64, capability: &MintCapability): T acquires MarketCap {

    // TODO: temporary measure for testnet only: limit minting to 1B Libra at a time.

    // this is to prevent the market cap's total value from hitting u64_max due to excessive

    // minting. This will not be a problem in the production Libra system because coins will

    // be backed with real-world assets, and thus minting will be correspondingly rarer.

    // * 1000000 because the unit is microlibra

        Transaction::assert(value <= 1000000000 * 1000000, 11);

    // update market cap resource to reflect minting

        let market_cap = borrow_global_mut<MarketCap>(0xA550C18);

        market_cap.total_value = market_cap.total_value + value;

        T { value }

    }

    // This can only be invoked by the Association address, and only a single time.

// Currently, it is invoked in the genesis transaction

// 初始化

    public initialize() {

    // Only callable by the Association address

        Transaction::assert(Transaction::sender() == 0xA550C18, 1);

        move_to_sender(MintCapability{});

        move_to_sender(MarketCap { total_value: 0 });

    }

// Return the total value of all Libra in the system

// 查询系统里币数量

    public market_cap(): u64 acquires MarketCap {

        borrow_global<MarketCap>(0xA550C18).total_value

    }

// Create a new LibraCoin::T with a value of 0

// 发布一个数量为零的币

    public zero(): T {

        T { value: 0 }

    }

// Public accessor for the value of a coin

// 查询币数量

    public value(coin: &T): u64 {

        coin.value

    }

    // Splits the given coin into two and returns them both

// It leverages `Self::withdraw` for any verifications of the values

// 分币:把一个币分成两个

    public split(coin: T, amount: u64): (T, T) {

        let other = withdraw(&mut coin, amount);

        (coin, other)

    }

    // "Divides" the given coin into two, where original coin is modified in place

    // The original coin will have value = original value - `amount`

    // The new coin will have a value = `amount`

// Fails if the coins value is less than `amount`

// 提款

    public withdraw(coin: &mut T, amount: u64): T {

        // Check that `amount` is less than the coin's value

        Transaction::assert(coin.value >= amount, 10);

        // Split the coin

        coin.value = coin.value - amount;

        T { value: amount }

    }

// Merges two coins and returns a new coin whose value is equal to the sum of the two inputs

// 合并两个币为一

    public join(coin1: T, coin2: T): T  {

        deposit(&mut coin1, coin2);

        coin1

    }

    // "Merges" the two coins

    // The coin passed in by reference will have a value equal to the sum of the two coins

// The `check` coin is consumed in the process

// 充值

    public deposit(coin: &mut T, check: T) {

        let T { value } = check;

        coin.value = coin.value + value

    }

    // Destroy a coin

    // Fails if the value is non-zero

    // The amount of LibraCoin::T in the system is a tightly controlled property,

// so you cannot "burn" any non-zero amount of LibraCoin::T

// 销毁币

    public destroy_zero(coin: Self::T) {

        let T { value } = coin;

        Transaction::assert(value == 0, 11)

    }

}

因为Libra是一个专注支付的系统,所以它并到目前为止并不支持具有双向原子交易的功能,或者就是说,两个币之间进行原子交换的功能。

 

下面这图是Libra交易流程图。

 

Libra的交易流程是交易方首先把请求发到验证节点(第一步)。然后验证节点把请求送到虚拟机去检验请求是否有效的。比如是否有足够的钱、是否签了字、签字是否有效、格式是否正确、等等。如果请求是查询已有的交易,就送到数据库里查询交易然后返回交易信息给请求方(第二步)。如果不是查询而是新的交易,就送到内存池(第三步)。内存池进一步验证交易。比如交易序列号是否是最新的(第四步)。如果是合格的交易就把交易发送给其他验证节点的内存池(第五步)。如果这个验证节点是出块节点,共识层就从内存池里取出所有有效交易作为这个块包含的交易(第六步)。然后发给所有验证节点(第七步)。同时每个验证节点把包含在块里的交易送去执行模块(第八步)。执行模块在达成共识之前将交易送去虚拟机执行(第九步)。执行模块把执行结果加到内存池Merkle Tree里(第十步)。出块节点按照LibraBFT共识机制试图获取3f+1的验证节点签字(第十一步)。如果出块节点获取了足够的验证节点签字3f+1,执行模块就将内存池里的交易结果和Merkle Tree写进数据库(第十二步)。

 

Libra链本身有一个叫做命令行的界面。也就是CLI就可以从命令行执行各种命令。然后可以建立一个本地的测试链,就说在一个计算机上可以建一个多节点的测试链。而在多个服务器上建立的测试链,则是比较麻烦。可以从Libra的代码挖掘到所需的信息。这个我们也是最开始是不知道的。那么Libra的主链现在就是pre-mainnet,它实际上是不公开的。包括里面的一些具体的部署是不公开的。这就是联盟链的特征。有些东西是不公开的。

 

MOVE语言至今还就是一个IR语言,也就是一个中间过度的语言,还不是MOVE的正式语言,只是一个脚本语言。但是可以用这个脚本语言来写MOVE合约,比如合约里资产的定义和逻辑部分。

 

数字货币与DeFi

a)支付与双向交易

i.支付是一方用货币交易而另一方用提供实物或服务作为交易

ii.双向交易是双方都用货币交易但是两个不同的货币

b)DEX交易所

i.挂单

ii.撮合

iii.执行交易

c)借贷

i.抵押

ii.利息

iii.期限

 

DeFi是包括支付和双向交易或者说叫做交换。支付是一方用货币进行交易,而另一方用实物,或者服务作为交易。这就是支付是一种单方的交易而交换是一种双方的交易。比如说我用港币换美元,这就是一个交换是两个不同币的交换。这个Libra里的MOVE合约现在是不支持的。但是这个原子交换是今后的DeFi当中的一个最最基本的需求。这个原子交换在区块链当中,现在最受关注的就是分布式或者去中心化交易所。因为中心化交易所的所有问题。当中涉及挂单撮合执行交易,这些都是需要解决这个双向交易或者说原子交换。在这个基础上才可以建立包括借贷抵押利息期限。这些都是智能合约需要完成的,而在以太坊里面已经很成熟了,但是在Libra里面,还没有出现,也就是今后需要把这个已经在以太坊上成熟的这些地方的协议迁移到Libra上面来,把以太坊合约改成MOVE合约。

 

对Libra和MOVE的预测和期望

 

首先是希望这个move的正式版能够发行。这是最重要的。还有就是我们希望Libra能够支持更多隐私交易。一个具体的形式就是链上的交易需要符合监管需求,但是链下的交易可以是全隐私的交易,就像闪电网络里面的支付通道一样,在这个通道里是可以实现全隐私的。但链上的这个交易可以符合监管的要求。这我们想到的一个最佳的组合就是半隐私链上交易,全隐私链下交易。

 

支持原子交换这是目前区块链最热门的一个话题。下面这个图就是这个原子交换的示意图。

 

 

如果你想要用一个BT C交换等价的ETH。那么你首先是要挂单,然后有人愿意要和你交换。然后你把这个BTC放在一个盒子里面锁上。然后把其中的一把钥匙给另一个人把这个盒子打开但把只能把ETH放进去。这样这个盒子里就有两个币了。两个互相交换后,大家再各自拿出自己需要的。这就是原子交换的一个基本原理,那么怎么去具体实现,这是有不同的做法。

 

因为现在所有的DeFi协议基本上都是在支持ERC20标准上实现。所以也是希望今后在Libra上发行的数字货币也能支持ERC20类似的标准。这里把ERC20这个标准列出来了。

 

 

他有这个几个主要的功能。第1个就是币的总数是多少。就是这个币的发行总数是多少。第二个就是他现在的存量是多少?第三是容许的是多少。转账是多少。授权转账交易。还有就是转账是从哪里到哪里。也有日志这是转账和授权结果。

 

下面是这个0x协议API。

 

contract IAuthorizable { // 授权接口

    /// @dev Gets all authorized addresses.

    /// @return Array of authorized addresses.

    function getAuthorizedAddresses()  // 获取已经授权的地址列表

        external

        view

        returns (address[]);

    /// @dev Authorizes an address.

    /// @param target Address to authorize.

    function addAuthorizedAddress(address target) // 添加授权地址

        external;

    /// @dev Removes authorizion of an address.

    /// @param target Address to remove authorization from.

 

function removeAuthorizedAddress(address target) // 除去授权地址

        external;

    /// @dev Removes authorizion of an address.

    /// @param target Address to remove authorization from.

    /// @param index Index of target in authorities array.

 

function removeAuthorizedAddressAtIndex( // 从授权列表里除去第x名地址

        address target,

        uint256 index

    )

        external;

}

 

contract IAssetProxy is IAuthorizable // 已经授权的接口

{

    /// @dev Transfers assets. Either succeeds or throws.

    /// @param assetData Byte array encoded for the respective asset proxy.

    /// @param from Address to transfer asset from.

    /// @param to Address to transfer asset to.

    /// @param amount Amount of asset to transfer.

    function transferFrom( // 从地址xxx向地址yyy转账

        bytes assetData,

        address from,

        address to,

        uint256 amount

    )

    external;

    /// @dev Gets the proxy id associated with the proxy address.

    /// @return Proxy id.

    function getProxyId() // 获取代理ID

        external

        view

        returns (uint8);

}

 

你可以看到0x协议API。首先是已经取得授权地址列表。然后就是给一个地址授权。就是把某个地址加到这个授权里面。还有就是取消某个地址授权的授权或从授权的地址列表里去掉。如果已经代理授权了,就可以从哪里到哪里转账了。最后就是获取这个代理ID。

 

这个图是一个很简单的分布式交易所或去中心化交易所。有一个买家taker和卖家maker。卖家首先是把这个交易挂单order到订单表orderbook。买家看到了后就通过0x协议API吃单execute order。0x智能合约就把挂单和吃单分别发送到买家和卖家。这个中继层Relayer是最重要的。这些都是在MOVE合约里可能实现的。

 

Libra 链开发进展

Master 代码每天 几十个 commit 更新几百个文件

测试链每两周更新一次(开始时从每天到每周) 最近一次是一个月之后

预计 2020 年 3 月底出 beta 版

预计 2020 年 6 月底出第一版

预计 MOVE 语言正式版应该在 beta 版里发布

 

监管方面

2020 年也是美国大选年。在 2020 年底前上线应该是在美国大选后上线当然取决于大选局势。

 

Facebook Pay法币支付:进展不顺也是必要的实习过程和双管齐下的做法。

 

Libra是否最终支持多种数字货币:Facebook Pay应该支持多种法币。

 

MOVE合约中资产和程序的分离是移植以太坊上虚拟币DeFi协议的核心挑战。

 

需要重新思考建立在资产和程序分离上的真金白银数字货币DeFi协议而不是虚拟币DeFi 协议。在Libra上开发数字货币DeFi要在2020年后了,真金白银的数字货币DeFi将会建立在Libra上。

 

MOVE VM将会归顺于WAVM。

 

我今天的分享完毕。

 

文|魔笛手技术开发社区     

【高速互连技术】合规性测试规范:物理层信号完整性与链路均衡验证系统设计 内容概要:本文档介绍了分析工具进行实践对照,并关注后续规范版本更新以确保符合最终发布标准。 立即下载

相关推荐

frontend-design skills

frontend-design skills

【Libra 技术解读】详解Libra共识源码

Libra技术系列解读往期回顾:move语言简介move语法、解释器和验证器LibraBFT共识机制本期由百度超级链颜值与才华并存的“小X姐姐”带来“Libra共识源码”...

baiduxuperchain的博客 2317

政府科技管理者在推动区域科技成果转化过程中,如何解决成果供需匹配效率低的问题?.docx

政府科技管理者在推动区域科技成果转化过程中,如何解决成果供需匹配效率低的问题?

Libra基础知识

核心特征 低波动性加密货币(相比比特币) 具有发币(国家央行)的作用 核心概念 GAS价格:相当于手续费,手续费越高,执行的优先级越高 交易的状态:区块链上每个人账户最终状态,比如 这个人账户余额是多少,转账是多少,等。 分类帐状态: 在这个区块链上的所有账户的状态。 为了执行交易,区块链的节点的validator 必须知道最新的全局状态。 工作量证明(PoW): 实现竞争结果判定。 Libra项目构建 Admission Control: admission contro.

qq_37405219的博客 569

用于计算系统状态的卡尔曼最优增益和最小均方误差(MMSE)估计研究(Matlab代码实现)

内容概要:本文围绕用于计算系统状态的卡尔曼最优增益和最小均方误差(MMSE)估计展开研究,深入探讨了卡尔曼滤波在动态系统状态估计中的核心作用。文章系统阐述了卡尔曼滤波的数学基础,包括状态空间模型的建立、先验与后验状态估计、协方差矩阵的递推更新,以及最优增益矩阵的推导过程,确保在高斯白噪声环境下实现对系统状态的最小均方误差估计。结合Matlab代码实现,完整展示了算法从理论建模到仿真实验的全流程,涵盖系统建模、噪声设置、滤波迭代、状态更新与误差分析等环节,并通过仿真实验验证了算法在噪声干扰下对系统真实状态的高精度跟踪能力。该研究为控制工程、导航系统、信号处理及自动化领域中的状态估计问题提供了坚实的理论依据与高效的数值实现方案。; 适合人群:具备一定控制理论、概率统计基础和Matlab编程能力,从事自动化、电子信息、航空航天、机器人、导航定位等相关领域的科研人员、工程技术人员及高校研究生。; 使用场景及目标:①掌握卡尔曼滤波的基本原理及其在状态估计中的数学推导过程;②学习如何利用Matlab实现卡尔曼滤波算法并进行系统仿真与性能评估;③应用于目标跟踪、传感器融合、惯性导航、故障诊断、时间序列预测等实际工程中的动态状态估计问题。; 阅读建议:建议读者结合文中提供的Matlab代码进行动手实践,通过调整系统模型参数、过程噪声与观测噪声强度,观察滤波效果的变化,深入理解卡尔曼增益的自适应调节机制与MMSE估计的收敛特性。同时可进一步拓展学习扩展卡尔曼滤波(EKF)、无迹卡尔曼滤波(UKF)等非线性滤波方法,以应对更复杂的非线性系统状态估计挑战。

高校技术转移办公室人员如何提升成果转化服务效率?.docx

科易网基于行业知识库+行业大数据+科技资源要素+AI模型,以AI,赋能技术转移、成果转化、技术经理人培训、知识产权管理、区域产业分析与布局、地方科技招商、创新创业大赛等场景,推出科技创新领域的AI工具、场景化服务和数智化解决方案,推动科技创新与产业创新智能化发展。

Facebook Libra 存储(Storage)简介

存储 存储模块为 Libra Blockchain 上的整个数据集提供可靠且高效的持久化存储,以及 Libra Core 内部所使用的必要数据。 概观 存储模块旨在实现两个主要目的: 保留区块链数据,特别是验证方通过共识协议达成一致的交易及输出。 为区块链数据的查询提供 Merkle 校样的响应。如果客户端已获得正确的根哈希,则客户端可以轻松验证响应的完整性。 Libra Blockchain...

zhangxin09的专栏 1725

国央企创新负责人如何利用平台实现技术需求的精准挖掘与匹配?.docx

科易网基于行业知识库+行业大数据+科技资源要素+AI模型,以AI,赋能技术转移、成果转化、技术经理人培训、知识产权管理、区域产业分析与布局、地方科技招商、创新创业大赛等场景,推出科技创新领域的AI工具、场景化服务和数智化解决方案,推动科技创新与产业创新智能化发展。

libra白皮书技术解读-1

简介libra目前是一个联盟链的组织形式,他的去中心化体现在,由多个validator来共同处理交易以及区块链中的状态,但是随着时间的推移,libra也计划朝着公有链的方向发展。对于libra,我们可以将其看做是一个通过libra协议管理的带加密认证的数据库,通过libraBFT共识算法,可以保证每个诚实节点中数据库的数据是一致的。与ethereum相似的,libra也有智能合约和账户的概念,但是...

cpongo5 1825

自适应多机器人编队规划,以包围和跟踪具有运动和可见性约束的目标(Matlab代码实现)

内容概要:本文提出了一种自适应多机器人编队规划方法,旨在实现对具有运动能力和可见性约束目标的高效包围与持续跟踪,采用Matlab进行算法实现与仿真验证。该方法综合考虑了多机器人系统在动态环境中的协同控制、编队形态生成与保持、障碍物规避以及目标可见性维护等关键问题,通过设计分布式控制律使编队能够根据目标行为和环境变化自适应调整队形与运动轨迹,确保稳定包围并最大化目标观测质量。文中详细阐述了系统的数学建模过程、控制策略设计原理及约束处理机制,并提供了多场景下的仿真实验结果,验证了所提方法在复杂条件下的鲁棒性、灵活性与有效性。; 适合人群:具备自动化、机器人学、控制理论或人工智能等相关领域基础知识的科研人员及研究生,熟悉Matlab编程环境并致力于多智能体系统、协同控制、路径规划或智能无人系统研究的专业人士。; 使用场景及目标:①应用于多机器人系统在监视、围捕、搜救等任务中对移动目标的协同包围与跟踪控制;②为研究分布式编队控制、可见性优化、动态避障与多智能体协同决策等核心技术提供可复现的算法实例与理论支撑; 阅读建议:建议读者结合提供的Matlab代码逐模块分析算法实现细节,重点关注控制律设计、约束建模与仿真结果对比部分,宜在仿真环境中调整参数配置以深入理解系统性能边界与优化潜力。

人形机器人系列——硬件介绍

人形机器人是多领域交叉技术的产物,主要由三大系统组成:感知系统、决策系统和执行系统。感知系统感知系统是人形机器人获取外界信息的途径,主要由各种传感器组成。其中,视觉传感器用于获取图像信息,如摄像头、激光雷达等;触觉传感器用于感知触碰和压力,如力/力矩传感器、声学传感器等。这些传感器收集到的信息为机器人的决策和执行提供基础。决策系统决策系统是人形机器人的大脑,负责处理和决策各种信息。它由芯片和算法组成。芯片是硬件基础,提供计算能力;算法是软件基础,用于处理和分析传感器收集到的信息,并做出相应的决策。执行系统。

liangwqi的博客 1万+

Libra技术介绍

1.为什么要发起Libra 1.1 Libra所处的时间坐标 关于Libra的起源,首先我们必须放在一外一内两个维度上来看它所处的时间坐标。 外的维度是其他大公司发币的时间轴,我们会发现Facebook并不是第一个吃螃蟹的人,美国主流经济正在一步一步的拥抱区块链和数字货币。 2018 年 7 月,纽约证交所的实际所有者 ICE 公司与微软、波士顿咨询集团和星巴克合作,成立加密数字资产服务机...

w365904的博客 9657

深入分析大众点评 Ajax 接口:直接请求 JSON 数据高效获取评论

大众点评网站采用前后端分离架构,通过Ajax接口动态加载数据。按F12打开开发者工具,切换到Network(网络)面板。实际环境中,我们需要使用Python重现这一加密逻辑。查看请求响应,寻找包含评论数据的JSON接口。参数是大众点评的反爬机制核心,需要特别处理。:尊重网站的robots.txt文件规定。:仅将数据用于合法合规的研究和分析目的。:不侵犯大众点评的商业秘密和知识产权。打开大众点评网站,进入任意商户页面。:对采集到的用户信息进行脱敏处理。:避免对目标网站造成过大负担。

Z_suger7的博客 1591

Libra(技术解读) (2)

Libra区块链是一个分散的、可编程的数据库,旨在支持一种低波动性的加密货币,该加密货币将能够作为全球数十亿人的有效交换媒介。我们提出了一项关于Libra协议的建议,该协议实施了Libra区块链,旨在创建一个金融基础设施,以促进创新、降低进入壁垒和改善金融服务的获取。为了验证liba协议的设计,我们构建了一个开源原型实现——liba核心——以期通过全球协作推动这个新生态系统的发展。 liba协议允...

xiaoxifei的专栏 1245

保姆级教程:在SIwave 2024 R2中搞定TDR仿真,手把手教你分析USB 3.0差分线阻抗

本文提供了一份详细的SIwave 2024 R2 TDR仿真教程,重点讲解如何分析USB 3.0差分线阻抗。从项目准备、参数配置到结果分析,逐步指导工程师完成完整的仿真流程,并分享实战经验和高级技巧,帮助提升信号完整性分析能力。

weixin_33670786的博客 498

Latex下使用JabRef添加参考文献

文章目录 前言 一、pandas是什么? 二、使用步骤 1.引入库 2.读入数据 总结 前言 Latex可以手动添加参考文献,但文献过多时,使用JabRef软件相对方便。 提示:以下是本篇文章正文内容,下面案例可供参考 一、JabRef安装 网址:http://www.jabref.org 打开网址后,点击“Download” 进入如下页面后,选择 portable (便携版,无需安装),下载后是一压缩包,打开即可使用。 二、使用 1.创建库 ...

sz3076799的博客 3471

Facebook的Libra “区块链”到底是如何运作的?

本文深入研究了“关于Facebook Libra coin (以及更多)平台协议”的26页技术文档,并对其内容进行了分解说明。同时,我们对这53位作者表示衷心的钦佩! 以下为具体分析内容: (文中英文内容为“协议”原文,中文翻译是对“协议”内容的解读。) 摘要 The Libra protocol allows a set of replicas—referred to as valida...

weixin_30711917的博客 488

代码的自由之旅:用AI写出无版权烦恼的Verilog

他们还基于这个数据集,训练了一个名叫“FreeV”的AI模型,不仅能写出好用的Verilog代码,还把版权侵权的风险降到了仅3%。为了让AI安全地写Verilog,研究团队提出了三个“法宝”:一个检测AI是否会生成侵权代码的测试方法、一个干净的Verilog数据集FreeSet,还有一个基于FreeSet训练的AI模型FreeV。AI的记忆力超强,能记住训练时见过的代码。测试发现,一些用Verilog数据训练过的AI,比如VeriGen,生成侵权代码的概率从9%涨到了15%,说明它们可能学了不该学的代码。

步子哥的博客 1810

Libra是一个纸老虎吗?Libra技术专业解析 | 技术帖

Libra是一个纸老虎吗?Libra当然不是一只纸老虎。否则的话,它也不会引起全球金融监管的高度重视,美国国会也不会很快就此召开听证会,调查Libra项目的真实企图和以及它会带来的影响。...

weixin_45727359的博客 1014

uniapp [全端兼容] - 实现大文件上传分片/切片+本地选择文件上传超大文件,大文件切片上传+断点续传+上传进度条+失败自动重传,支持单个/批量上传图片、视频、文档各种文件(App、小程序、H5

uniapp 分片 断点续传 大文件上传。uniapp大文件切片上传,uniapp实现大文件上传 分片上传 进度条,分片上传附件,实现大文件上传,实现分片大文件上传,Uniapp实现大文件上传 分片上传 进度条,uniapp文件分片上传,uniapp如何上传很大的文件,在选择文件后,按指定大小将文件切割成独立的文件片,并逐片上传,uniapp 微信小程序上传大文件如何切片,uniapp APP实现大文件分片上传、断点续传、秒传,解决大文件上传问题,大文件上传如何做断点续传,uniapp上传视频,Uniapp

🏆 前端领域优质创作者 1万+

RK3588 部署 YOLO26 目标检测:PT → ONNX → RKNN 全流程

YOLO26n 在 RK3588 上 INT8 量化后 NPU 推理约 15ms,系统 FPS 约 55,可以覆盖边缘端实时检测需求。模型从 PT 到 RKNN 的转换要用opset=11避免算子兼容问题。先用 YOLO26n + 640 输入跑通全链路,确认推理结果正确后再做性能调优。

m0_64661770的博客 306

【Libra 技术解读】详解LibraBFT共识机制

Libra技术系列解读往期回顾:move语言简介move语法、解释器和验证器本期详解“LibraBFT共识机制”Libra白皮书中关于共识机制的描述Libra 区块链采用...

baiduxuperchain的博客 3526

基于STM32单片机的智能分拣系统

基于STM32单片机的智能分拣系统是一种高效、精准的自动化分拣解决方案,适用于物流、仓储、制造业等领域。该系统利用STM32单片机作为核心控制器,结合传感器技术、电机控制算法和通信模块,实现对物品的自动识别、分类和分拣。通过智能化的设计,该系统能够大幅提高分拣效率,降低人工成本,并减少错误率。基于STM32单片机的智能分拣系统是一种高效、精准、低成本的自动化解决方案,能够广泛应用于物流、制造、环保等领域。

qq_62634009的博客 1940

fabric代码目录结构

bccsp : 密码学:加密,签名以及证书等等 bddtests: 行为驱动开发 需求 概要设计 详细设计 开发 需求 开发 commen: 公共库 错误处理,日志处理,账本存储,各种工具 core : 核心库 组件核心逻辑 devenv : 开发环境 vagrent docs: 文档相关 events: 事件监听机制 examples: 一些例子 go...

passionadu的博客 628

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

Facebook Libra 加密简介

加密 Crypto 我们在 Libra 中用到的所有加密原语,都实现在 Crypto 加密组件中,它包含:散列(Hashing),签名和密钥派生/生成。 在即将到来的版本中将包含的加密原语(位于 NextGen 目录)有:新的加密 API 来保证类型安全、可验证的随机函数、BLS 签名。 概述 Libra 使用了几种加密算法: SHA-3 作为主要的哈希函数。它在 FIPS 202 中被标准化。...

zhangxin09的专栏 1665

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

上一篇: 研究报告:闪电网络在费用和隐私方面存在缺陷(内附原文件)
下一篇: Libra Core第二版路线图发布 将按优先级顺序交付主网功能
BitTribeLab
博客等级 码龄8年 49粉丝 22原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值