← COMP5565 全部讲次
L06c · 第 8 周

L06c Fabric(三):一笔交易的五步,先试算再排队

从三种节点角色讲起,对比公链的先排序后执行和 Fabric 的 Execute → Order → Validate,一帧一帧走完交易五步,再讲背书策略怎么写、非确定性的合约为什么有时能过有时不能。

一句话版

Fabric 的一笔交易先让指定的几家试算并签字,再交给排序服务排队,最后每个 peer 只核对签字和版本、不重算。公链正好反过来:先排队,然后人人都算一遍。

身份见 L06a,账本结构见 L06b。

先认识这几个词

词 全称 / 读法 一句人话
client 客户端 代表用户发起交易的程序
endorser 背书者 被指定先试算交易、签字担保结果的 peer
orderer 排序节点 只给交易排先后、打包成块,不看交易内容
chaincode 链码 Fabric 里的智能合约
提案 proposal 客户端发出的「请帮我执行这个函数」的请求
背书策略 endorsement policy 规定哪些组织必须签字,写成 OR、AND、OutOf
EOV Execute → Order → Validate Fabric 的三段式:先执行、再排序、后验证

一个类比:报销单先审后排再核

员工填好报销单(提案),先找指定的两位经理各自核算一遍、签字(背书)。经理只算不动账。员工自己把签好的单子投进前台收件箱(排序服务)。前台不看内容,只按收到的先后编号,攒够一叠就装订成册,分发给各部门的会计(peer)。

每个会计按编号逐张核对:该签的人签了没有?经理核算时看到的余额,现在还是不是那个数?都对才入账,对不上的单子留在册子里,盖个作废章。

类比在哪里失效:

  • 现实里会计发现余额变了,可能会重新算一遍再入账。Fabric 的 peer 不重新执行 chaincode,对不上就直接判无效,客户端只能重新发起。
  • 现实里经理会站在公司立场审批。背书者检查的只是「按我本地当前状态,执行结果对不对」。

从零讲起

1. 三种角色:client、peer、orderer

它解决什么问题

一笔交易要经过好几类机器。分不清谁管什么,后面的五步就记不住。Fabric 把节点分成三种逻辑角色,每种只做自己那一段。

直觉

client 是跑腿的:发提案、收签字、把交易送去排队。peer 是记账的:每个 peer 都存着区块链和 world state,其中被策略点名的那几个还要先试算,叫背书者。orderer 是排号的:只定先后,完全不知道应用状态。

「节点」只是逻辑功能,一台服务器可以同时跑几种。重要的是它归哪个组织、落在哪个信任域里。

一步一步看

目标:把 client、peer、orderer 三种角色分开看,看出谁发起、谁执行并保存账本、谁只管排序。

  1. client 代表终端用户,必须连一个 peer 才能和区块链通信,连哪个自己选。

  2. peer 保存区块链和 world state。只有 chaincode 策略指定的那部分 peer(背书者)执行提案,其余 peer 只验证。

  3. orderer 组成排序服务,给所有交易排出统一顺序,既不执行,也不验证。

    三个并排的方框:client 发起并签名提案、收集背书、把交易交给排序服务、不保存账本;peer 保存区块链和 world state,背书者模拟执行并签名,所有 peer 验证、提交,背书时不改账本;orderer 青绿高亮,排全序、打包成块、分发给 peer,不看应用状态,不执行也不验证;底部说明角色是逻辑的,一台服务器可以同时跑 peer 和 orderer,信任谁来执行和信任谁来排序仍是两件事

  4. 一家组织可以同时跑 peer 和 orderer。即便如此,背书错了是背书者的责任,顺序出问题是排序服务的责任,两种信任不会合并。

怎么判断

遇到一个动作,问它改不改业务数据、看不看交易内容:试算并签字是背书者;验证并写账是 peer;只排序打包、不看内容的是 orderer。

意思是:orderer 像邮局给信件盖编号,不拆信。

常见误解

以为每个 peer 都要执行每笔交易

只有背书策略指定的背书者执行。其他 peer 甚至可以根本没装 chaincode,它们只检查签字和版本。

试一下

某组织在一台服务器上同时跑了 peer 和 orderer。这台机器上的 orderer 会顺便帮忙验证交易吗?

不会。角色按功能分,orderer 这个角色永远只排序,验证是 peer 角色的事。

2. 两种流水线:Order → Execute 与 Execute → Order → Validate

它解决什么问题

比特币和以太坊先排序,然后每个节点都把每笔交易按顺序执行一遍。全网重复算同一件事,慢,而且合约必须对所有人公开。Fabric 想把执行挪出去,只让少数节点做。

从哪来(补充)

Fabric 的设计写在 Androulaki 等人 2018 年的论文《Hyperledger Fabric: A Distributed Operating System for Permissioned Blockchains》里,论文在 arXiv 上于 2018 年 1 月提交。课件里的四阶段图就取自这篇论文。论文把公链的做法叫 order-execute,把 Fabric 的叫 execute-order-validate。

出处:arXiv: 1801.10228

直觉

公链像全班同学先排好队,然后每人把全部题目都做一遍再对答案。Fabric 是先请指定的几位同学做题并签字,把答卷交给班长按顺序收齐,最后每个人只核对签字和答卷上用到的数据有没有过时。

一步一步看

目标:把公链的先排序后执行和 Fabric 的执行、排序、验证三段对照着走,看出执行挪给了谁,验证时为什么不用重算。

  1. 公链第一段:出块者按手续费挑选并排序交易。

  2. 公链第二段:每个节点按顺序执行每笔交易,更新 UTXO 或账户状态。

  3. Fabric 第一段 Execute:背书策略指定的 peer 模拟执行,产出读写集并签名,不改账本。

  4. Fabric 第二段 Order:排序服务排序、打包成块,不执行 chaincode。

  5. Fabric 第三段 Validate:所有 peer 检查背书策略和读集版本,不重新执行;无效交易留在区块里,但不改 world state。

    公链与 Fabric 交易流程对比:上排比特币和以太坊先由出块者按手续费排序,再由每个节点按顺序执行每笔交易,最后更新 UTXO 或账户状态;下排 Fabric 先由背书策略指定的 peer 模拟执行并产出读写集,再由排序服务排序打包且不执行 chaincode,最后所有 peer 检查背书策略和读集版本、不重新执行,无效交易留在区块里但不改 world state

怎么判断

看一条链属于哪种流水线,只问一句:执行发生在排序之前还是之后?之后,而且人人都执行,是 order-execute;之前,而且只有背书者执行,是 EOV。

意思是:EOV 把「算」和「排」拆开,好处跟着来。

优点 一句话
可插拔的排序共识 排序和执行解耦,换排序算法不影响业务逻辑
灵活的信任模型 背书策略规定哪些组织必须认可结果
通用的合约语言 chaincode 用 Go、Java、JavaScript 写
并发模拟 不同背书者可以同时模拟互不相关的提案
提交者不重新执行 只校验签名、背书策略和读版本
容忍非确定性 单背书者时随机结果也能被接受,见第 5 个概念
chaincode 保密 合约只装在背书者上,其他 peer 只看到读写集和签名

常见误解

以为无效交易会被排序服务挡在区块外面

排序服务根本不看内容,无效交易照样进块。它只是在验证阶段被标成 invalid,不改 world state。公链才是无效交易一般进不了区块。

试一下

以太坊的合约字节码为什么没法像 Fabric 的 chaincode 那样保密?

以太坊每个节点都要执行每笔交易,必须拿到合约代码。Fabric 只有背书者执行,代码只需装在它们那里。

3. 一笔交易的五步

它解决什么问题

把 EOV 落到具体的机器上:谁先发、谁签字、谁送去排序、谁打包、谁写账。课件用同一张网络图画了六帧动画,正好对应五步。

直觉

网络里有应用 A1,peer P1 到 P6,每个 peer 都有一份账本 L。P1 标着 E+S,意思是背书者,装了 chaincode;P4 标着 O,是排序节点。五步里只有最后一步改账本。

一步一步看

目标:跟着提案 PTx1 走完五步,看清每一步由谁发给谁,账本又是在哪一步才被改动。

  1. 提案:A1 生成交易提案 PTx1,发给背书者 P1。提案里有目标函数、输入参数和客户端签名。

    第 1 步:应用 A1 青绿高亮,一支箭头指向背书者 P1,P1 标 E+S;P4 是排序节点 O;右侧 P1、P2、P3、P5、P6 五个 peer 都持有账本 L;底部说明提案里有目标函数、输入参数、客户端签名

  2. 背书:P1 用自己的 chaincode 和本地账本模拟执行,生成读写集并签名,把背书交易 Tx1 还给 A1。账本没动。

    第 2 步:背书者 P1 青绿高亮,箭头从 P1 指回应用 A1;右侧五个 peer 的账本仍是 L;底部说明读写集加上 P1 的签名就是背书交易 Tx1

  3. 提交排序:A1 自己把 Tx1 交给排序节点 P4。背书者不代劳。

    第 3 步:箭头从应用 A1 指向排序节点 P4;P1 没有参与这一步;右侧五个 peer 的账本仍是 L;底部说明送去排序的是客户端,背书者不代劳

  4. 打包分发:P4 把 Tx1 和同期其他交易排好序、打包成区块 B,发给 P1、P2、P3、P5、P6。

    第 4 步:排序节点 P4 青绿高亮,向右侧 P1、P2、P3、P5、P6 五个 peer 各发出一支箭头送去区块 B;各 peer 的账本仍是 L;底部说明 P4 只排序打包,不看交易内容

  5. 验证提交:每个 peer 独立验证区块 B 里的交易,把有效交易写进自己的账本,L 变成 L’。

    第 5 步:右侧 P1、P2、P3、P5、P6 五个 peer 全部青绿高亮,账本都从 L 变成 L 撇;底部说明只有这一步改账本,之后 peer 发事件通知应用结果

  6. 第五步之后还有一环:peer 更新账本后发出事件,应用由此得知交易最终是不是有效。

怎么判断

背五步可以压成十个字:提案、背书、提交排序、打包分发、验证提交。问「哪一步改账本」,答案永远是最后一步。

意思是:第 1、2 步是 Execute,第 3、4 步是 Order,第 5 步是 Validate 加更新状态。

常见误解

以为背书者签完名会替客户端把交易送去排序

送去排序的是客户端自己。背书者签完就把结果还给客户端,后面的事不管。

以为客户端把交易交给排序服务,就说明交易成功了

交出去只是送去排队。要等 peer 验证提交后发来的事件,才知道交易有没有被标成 valid。

试一下

第 2 步结束时,P1 的账本 L 变了吗?P2 的呢?

都没变。背书只是模拟,所有账本要到第 5 步才变成 L’。

4. chaincode、Send 与 Query、背书策略

它解决什么问题

业务逻辑写在哪、怎么调用、要谁签字才算数,这三件事都绑在 chaincode 上。

直觉

chaincode 就是 Fabric 的智能合约,用 Go、Java 或 JavaScript 写,装在 peer 上,在安全容器里运行。调用时指定 chaincode 名称、函数名和参数,比如 chaincodeId “mycc-2”、函数 “CreateAsset”、参数 [“asset-01”,“yellow”,“Tom”]。Fabric 没有合约地址,靠名字定位。

调用分两种。Send 要把结果打包成交易交给 orderer,最终上链。Query 只拿回结果就结束,不经过 orderer,不上链。

背书策略规定要谁签字,三种基本写法可以嵌套。

一步一步看

目标:从单个组织签到嵌套的 OR 加 AND,逐条读背书策略,看出怎样画成一棵树从叶子往上判断签够没有。

  1. OR('Org1.peer'):Org1 一家的 peer 背书就够。

  2. AND('Org1.peer','Org2.peer'):Org1 和 Org2 都必须背书。

  3. OutOf(2, …):列出的几个组织里任意两个。

  4. 嵌套:「Org1 和 Org2 一起签,或者 Org3 单独签」写成 OR(AND('Org1MSP.peer','Org2MSP.peer'),'Org3MSP.peer')。把它画成一棵树,从叶子往上判断。

    一棵策略树:根节点 OR 青绿高亮,左孩子 AND 下面挂 Org1 和 Org2,右孩子是 Org3;右侧说明 OR 两边满足一边就行,AND 要 Org1、Org2 都签,只有 Org1 签时两边都不满足

怎么判断

拿到一组签名,从策略树的叶子往上算:叶子上的组织签了记「满足」;AND 要所有孩子都满足;OR 有一个孩子满足就行;OutOf(n, …) 要至少 n 个孩子满足。根节点满足,策略就满足。

意思是:只签一家 Org1 时,AND 缺 Org2,右边缺 Org3,根节点 OR 两边都落空,不通过。

提交前 SDK 先检查一次策略满没满足,验证阶段每个 peer 还会再查一次。只查询的话,客户端拿到结果通常就不提交排序了。

常见误解

以为 Query 也会在链上留记录

Query 不经过 orderer,不打包成交易,也就不上链。

试一下

策略是 OutOf(2, Org1, Org2, Org3)。只有 Org2 和 Org3 签了,满足吗?

满足。三家里任意两家就够。

5. 非确定性:同样的输入算出不同结果

它解决什么问题

如果 chaincode 里调了随机数,同样的输入每次可能算出不同结果。公链里每个节点都要重算,结果一不同状态就分歧,所以 EVM 必须是确定性的。Fabric 的 peer 不重算,情况就不一样了。

直觉

结果只由一个背书者算出来时,别人不重算,也就没人能对出不同。结果要两个背书者各算一遍时,两人一对,随机数大概率不一样,签字对不上。

一步一步看

目标:让含随机数的 chaincode 分别在单背书者和双背书者策略下跑,看出前者结果被接受,后者连交易都形成不了。

  1. chaincode 里有一行 rand.Intn(100),取一个 100 以内的随机整数。

  2. 单背书者,策略 OR('Org1MSP.peer'):Org1 的 peer 算出 42,写集是 random → 42。排序后其他 peer 只查签字和版本,这个结果被接受并提交。

  3. 多背书者,策略 AND('Org1MSP.peer','Org2MSP.peer'):Org1 算出 42,Org2 算出 87,两份写集不一致。

  4. 客户端收集不到一致的背书,交易形成不了,根本不会送去排序。

    左右对比:左边 OR 策略只有 Org1 的 peer 算出 42,青绿框写背书一致、可提交,注明其他 peer 不重新执行所以单背书者的随机结果会被接受;右边 AND 策略下 Org1 的 peer 算出 42、Org2 的 peer 算出 87,灰框写背书不匹配、交易形成不了

怎么判断

问两句:策略要几个背书者?它们各自算出的结果会不会不同?只要一个,非确定性能过;要多个且结果会不同,交易失败。

意思是:课件说 Fabric 支持非确定性,指的是单背书者这种情况,并不是说随机数合约在任何策略下都能用。

常见误解

以为 Fabric 支持非确定性,所以 chaincode 里随便用随机数

策略一旦要求多个背书者,各自的随机结果对不上,交易就形成不了。

试一下

策略是 OR(Org1, Org2),客户端只找了 Org1 背书,chaincode 里有随机数。交易能提交吗?

能。OR 只要一家,只有一份结果,没有可比的对象,不会出现背书不匹配。

把它们串起来

三种角色各管一段:client 跑腿,peer 记账,被点名的 peer 兼做背书,orderer 只排号。

把它们放进 EOV 的流水线,就是五步。客户端发提案给背书者。背书者在本地模拟执行,交回读写集和签名,账本没动。客户端凑够策略要求的签名,自己送去排序。排序服务不看内容,排好、打包、分发给所有 peer。每个 peer 只查签字和版本,有效的写进账本。

背书策略决定第二步要找谁。它用 OR、AND、OutOf 组合,可以画成一棵树来判断。也因为其他 peer 不重算,单背书者的随机结果能过,多背书者的会因签字对不上而失败。至于第五步具体怎样用读写集和版本号判有效无效,见下一页。

课件里的坑

  • [课件有误] p.65–69 五页标题拼错:p.65、p.67–69 印成「Endoser」,p.66 印成「Endosor」,应为 Endorser(p.65–69)
  • [课件有误] p.64 第三条策略的说明印成「2 out of of participating orgs」,多了一个 of;同一行的 principal 前一个写 Org1MSP.member、后两个写 Org2.member、Org3.member,写法不统一,按三个组织的成员理解(p.64)
  • [读图提醒] p.63 图里提案写 foo(2010),模拟处写 foo(3011),同一次调用参数前后不一致,按同一调用理解(p.63)
  • [读图提醒] p.53 右下角除了页码,还多出一个小号「39」,是原素材的旧页码(p.53)
  • [读图提醒] p.49–54 的页脚数字渲染时被拆成两行,按页序读即可(p.49–54)

课后 10 分钟:考点复习

这 10 分钟怎么用:合上页面,先默写交易五步,每步写出是谁做的、账本动没动;再把 OR(AND('Org1MSP.peer','Org2MSP.peer'),'Org3MSP.peer') 画成树;最后做下面的完整例题。

必背

  1. 节点是逻辑角色,分 client、peer(committing peer 与 endorser)、ordering service node;orderer 不知道应用状态,不参与执行和验证。
  2. 传统链是 Order → Execute,排序后每个节点都执行;Fabric 是 Execute → Order → Validate,背书者只模拟不改账本,排序服务不执行 chaincode,所有 peer 只验证不重新执行。
  3. 交易五步:客户端发提案 → 背书者模拟执行、签名返回 → 客户端提交排序 → 排序服务打包成块分发给所有 peer → 每个 peer 验证后更新账本。
  4. Query 只调 chaincode 拿结果,不经过 orderer、不上链;Send 要把结果打包成交易交给 orderer;背书策略写法有 OR、AND、OutOf(n, …)。
  5. EOV 的优点:可插拔的排序共识、灵活的信任模型、通用的合约语言、并发模拟、提交者不重新执行 chaincode、容忍背书端非确定性、chaincode 可保密。
  6. 非确定性 chaincode:单背书者时结果被接受并提交;多背书者时各自结果不同,背书不匹配,交易形成不了。

课件例题

例 1(课件 p.64–66):读懂背书策略

题面:p.64 列了三条策略:OR('Org1.peer')、AND('Org1.peer','Org2.peer')、OutOf(2, 'Org1MSP.member', 'Org2.member', 'Org3.member');p.65 又举了 three-out-of-five 和 ((P1 and P2) or P3)。逐条说明要求谁背书。在 ((P1 and P2) or P3) 下,只有 P1 和 P3 背书够不够?只有 P1 和 P2 呢?p.66 的设定是 channel studentchannel、chaincode student.go、组织 Org1、Org2、Org3,策略 (Org1 AND Org2) OR Org3:这条策略在命令里怎么写?只有 Org1 签行不行?

提示

把每条策略画成树,AND 要孩子全满足,OR 要一个,OutOf(n, …) 要 n 个。p.66 的命令分「批准」和「提交」两处。

解答
  1. OR('Org1.peer'):Org1 一家的 peer 背书就够。
  2. AND('Org1.peer','Org2.peer'):Org1 和 Org2 都必须背书。
  3. OutOf(2, …):列出的三个组织里任意两个背书即可。
  4. three-out-of-five:五个指定背书者里任意三个签了就算满足。
  5. ((P1 and P2) or P3):要么 P1、P2 都签,要么 P3 签。P1 加 P3 满足,因为 P3 一个就够;P1 加 P2 也满足。
  6. 提交前由 SDK 检查策略是否满足,验证阶段每个 peer 还会再查一次。
  7. p.66 的策略写成 OR(AND('Org1MSP.peer','Org2MSP.peer'),'Org3MSP.peer')。各组织批准 chaincode 定义(peer lifecycle chaincode approveformyorg)和最后提交定义(peer lifecycle chaincode commit)时,都用 --signature-policy 带上同一条策略。
  8. 只有 Org1 签不行:AND 那半边缺 Org2,OR 那半边缺 Org3。Org1 加 Org2、单独 Org3、Org1 加 Org3 都满足。

完整例题

题面(自编情境,按课件 p.64–66、p.86 的概念):channel 里有 Org1、Org2、Org3、Org4 四家,背书策略是 OR(AND('Org1MSP.peer','Org2MSP.peer'), OutOf(2, 'Org3MSP.peer','Org4MSP.peer','Org1MSP.peer'))。chaincode 是确定性的。问:(1) 客户端拿到下面四组背书,各自满不满足?(a) Org1、Org2;(b) Org3、Org4;(c) Org1、Org3;(d) Org2、Org4。(2) 如果 chaincode 改成含 rand.Intn(100) 的版本,(a) 还能顺利提交吗?

约定:从叶子往上算,AND 要全部孩子满足,OR 要一个,OutOf(2, …) 要至少两个。

解法:

  1. 先拆树:根是 OR,左孩子是 AND(Org1, Org2),右孩子是 OutOf(2, Org3, Org4, Org1)。
  2. (a) Org1、Org2:左边 AND 满足,根满足。
  3. (b) Org3、Org4:左边缺 Org1、Org2;右边三个里有两个,满足,根满足。
  4. (c) Org1、Org3:左边缺 Org2;右边 Org1 和 Org3 正好两个,满足,根满足。
  5. (d) Org2、Org4:左边缺 Org1;右边只有 Org4 一个,Org2 不在右边名单里,不满足。根两边都落空,不通过。
  6. (2) (a) 要两家背书,两家各自算随机数,结果多半不同,写集对不上,背书不匹配,交易形成不了。

要点:同一家组织可以同时出现在两棵子树里,比如 Org1;算的时候每棵子树单独看。随机数问题只看「这组背书有几家」,一家没事,两家以上就要求结果一致。

答题格式:先画出策略树,再对每组背书写一行「左子树 / 右子树 / 根」三个结果。

变式题(先自己做)

(1) 同一条策略下,客户端只找了一家 Org3 背书。满足吗? (2) 改编自课件 p.86:策略换成 OR('Org1MSP.peer','Org2MSP.peer'),chaincode 含 rand.Intn(100)。客户端找 Org1 一家背书,交易会怎样?如果客户端多事,同时找了 Org1 和 Org2,拿到 42 和 87 两份不同结果呢? (3) 交易五步里,如果第 3 步之后客户端什么都不做,它怎么知道交易最后有没有效?

提示

(1) 右边 OutOf 要几个?(2) 想想 p.86 两个场景差在哪:策略要求几份一致的背书。(3) 回看第 5 步之后那一环。

判分点与答案(非官方评分标准)

判分点:① (1) 要两棵子树都检查;② (2) 要说出「单背书者时随机结果被接受」;③ (3) 要点出事件。

(1) 不满足。左边缺 Org1、Org2;右边只有 Org3 一个,不够两个。

(2) 只找 Org1:策略满足,结果 42 被接受并提交,其他 peer 不重新执行。同时找两家:OR 本来一家就够,客户端只需挑其中一份背书去提交,策略照样满足;不能把两份不同的结果拼进同一笔交易。

(3) 等 peer 验证提交后发出的事件,事件告诉应用这笔交易是 valid 还是 invalid(p.58)。

闪卡自测

1. 节点分哪三种角色?

client、peer(committing peer 与 endorser)、ordering service node(p.45)。

2. orderer 会检查交易内容或做 MVCC 检查吗?

不会。它只排序、打包、分发,还负责访问控制和配置更新校验(p.73、p.87)。

3. 交易五步里,哪一步才真正改账本?

最后一步:peer 验证后提交(p.54)。

4. 背书交易由哪两部分组成?

proposal + proposal response(读写集和背书者签名)(p.63)。

5. Send 和 Query 差在哪?

Send 要把结果打包成交易交给 orderer,最终上链;Query 拿回结果就结束,不经过 orderer(p.62)。

6. AND('Org1.peer','Org2.peer') 是什么意思?

Org1 和 Org2 都必须背书(p.64)。

7. 背书者检查的是什么?

按它本地当前状态,chaincode 执行结果对不对(p.67)。

8. 非确定性 chaincode 在单背书者和多背书者策略下分别会怎样?

单背书者:结果被接受并提交;多背书者:各自结果不同,背书不匹配,交易提交不了(p.86)。

9. EOV 怎样让 chaincode 保密?

chaincode 只部署和执行在特定背书者上,其他 peer 只看到读写集和签名(p.85)。

10. 送交易去排序的是背书者还是客户端?

客户端(p.52)。

下一讲

第 5 步说 peer 会验证交易,具体看什么?读写集长什么样、版本号怎么逐笔比、为什么换个排序结果就变了、一个网络里怎么跑多本账,见 L06d。

下一讲 →
L06d L06d Fabric(四):读写集、版本号验证与 channel

个人整理的学习笔记,不是官方材料;数字与结论以课件和讲师为准。