去中心化跨链之轻节点和收据证明

上次文章写了下双层网络，收到了一些好评也遇到了些问题。这篇文章将主要讲解轻节点证明和收据证明，只有节点可靠即节点MMR验证通过才会去获取收据证明。轻节点证明中以太坊使用了CHT去证明节点安全性，CHT目前实现是POA多签合约更新CHT树根，以太坊区块头收据根目前只有是块里所有收据的验证，没实现单一收据的证明，对跨链交易不是很友好，证明的共性是都是基于树的特性去验证的，通过构建证明所需要的路径来证明数据的正确性。

文章将基于去中心化跨链之双层网络讲，这篇文章遇到了RPC和P2P的区别，从以太坊的狭隘理解上，P2P需要节点发现,数据加密,连接管理,心跳检测,网络协议,广播策略,序列化。RPC倾向于查询，Dapp交互，API访问管理，数据JOSN化，账户，HTTP访问相关的问题。两者实现的都是远程调用，实现的方式有所区别。

轻节点证明

现在提跨链，言必提轻节点，有要把轻节点实现到EVM合约合约里面的，有在波卡Runtime里面实现轻节点的。目前没看到这两种实现的开源代码。跨链实现轻节点的目的是轻节点占用资源少，数据可验证，毕竟跨链交易跟本链内交易比还是少数。所有没有运行全节点的必要性。

CHT证明

在以太坊全节点中，每params.CHTFrequency=32768个区块，会将区块hash，td存到CHT树中，key为区块高度。

    td := rawdb.ReadTd(c.diskdb, hash, num)
    binary.BigEndian.PutUint64(encNumber[:], num)
    data, _ := rlp.EncodeToBytes(ChtNode{hash, td})
    c.trie.Update(encNumber[:], data)

看过以太坊代码应该会注意到如下代码

    MainnetTrustedCheckpoint = &TrustedCheckpoint{
        SectionIndex: 333,
        SectionHead:  common.HexToHash("0xb80784cbe88077e5911b446765edc814dd67ca3f6bdd33b6ec72d66058df4a11"),
        CHTRoot:      common.HexToHash("0x4da9cde840dd3de39916620f7a97674c5747a89a9359e6b918e134d199a8dd45"),
        BloomRoot:    common.HexToHash("0xdd0f4fef7fa2a5cc05d49568e38f15dab24098ffc7677a2e35d1a8d67f5458af"),
    }

这是之前硬编码到代码中轻节点CHT验证需要的数据，后来感觉每次升级要更改这个和安全性太低升级为验证人合约。

    MainnetCheckpointOracle = &CheckpointOracleConfig{
        Address: common.HexToAddress("0x9a9070028361F7AAbeB3f2F2Dc07F82C4a98A02a"),
        Signers: []common.Address{
            common.HexToAddress("0x1b2C260efc720BE89101890E4Db589b44E950527"), // Peter
            common.HexToAddress("0x78d1aD571A1A09D60D9BBf25894b44e4C8859595"), // Martin
            common.HexToAddress("0x286834935f4A8Cfb4FF4C77D5770C2775aE2b0E7"), // Zsolt
            common.HexToAddress("0xb86e2B0Ab5A4B1373e40c51A7C712c70Ba2f9f8E"), // Gary
            common.HexToAddress("0x0DF8fa387C602AE62559cC4aFa4972A7045d6707"), // Guillaume
        },
    }

下面来看下这个轻节点简化验证流程

    header := new(types.Header)
    if err := rlp.DecodeBytes(headerEnc, header); err != nil 
    // Verify the CHT
    value, err := trie.VerifyProof(r.ChtRoot, encNumber[:], reads)
    var node light.ChtNode
    if err := rlp.DecodeBytes(value, &node); err != nil 
    if node.Hash != header.Hash()
    if r.BlockNum != header.Number.Uint64()
    }

可以看到，首先如下验证

• CHT的proof证明是否可信，成功获取到叶子节点value
• 轻节点获取的区块头HASH方法和value中获取ChtNode中hash比较
• 比较CHT的高度是否和区块头的一致

经过如上证明，可知对方节点当前可信，这是之后验证的起点，之前的几百万区块不需要下载，这样轻节点在手机，浏览器才有可能运行。

MMR证明

讲解了如上CHT证明，我们来看下MMR证明。MMR证明需要在区块头里面加MMR的根，每挖到新区块的时候都需要更新MMR的根

    n := ulvp.NewNode(b.Hash(), d, new(big.Int).Set( b.Difficulty()), big.NewInt(0), time)
    mmr.Push(n)

MMR主要是靠采样，根据安全精度决对采样数据的数量，只需要logN的数据即可证明节点的安全性，被称为超轻节点。网上有很多这方面的介绍，这里主要说下如何实现。有两个地方需要更改

• 矿工挖矿需要更新区块头MMR根调用PushBlockInMMR
• 验证节点校验MMR并更新树

MMR第一次验证

节点第一次握手的时候，需要校验对方是否为可信的对链节点。

            proof, err := uLVP.PushFirstMsg()
            errc <- p2p.Send(p.rw, StatusMsg, &statusData{
                ProtocolVersion: uint32(p.version),
                NetworkID:       network,
                TD:              td,
                Head:            head,
                Genesis:         genesis,
                Proof:           [][]byte{proof},
            })

需要将MMR Proof证明发给对方节点，证明包含如下部分

    Right, heads := getRightDifficult(uv.localChain, curNum, new(big.Int).Set(cur.Difficulty))
    proof, _, _ := uv.MmrInfo.CreateNewProof(Right)
    heads = append([]*types.Header{genesis.Header(), cur}, heads...)
    res := &ulvp.ChainHeaderProofMsg{
        Proof:  proof,Header: heads,Right:  Right,}

对链节点握手验证

func (p *peer) readOtherStatus(network uint64, status *statusData, genesis common.Hash, uLVP *core.SimpleULVP) error {
    msg, err := p.rw.ReadMsg()
    // Decode the handshake and make sure everything matches
    if err := msg.Decode(&status); err != nil {
        return errResp(ErrDecode, "msg %v: %v", msg, err)
    }
    if status.Genesis != genesis 
    if err := uLVP.VerifyFirstMsg(status.Proof[0]); err != nil 
    return nil
}

创世校验后调用MMR验证流程。

收据证明

以太坊收据中存在只能整体校验，不能单独验证每个receipt的正确性。可通过查看如下代码

func DeriveSha(list DerivableList, hasher Hasher) common.Hash {
    hasher.Reset()
    keybuf := new(bytes.Buffer)
    for i := 0; i < list.Len(); i++ {
        keybuf.Reset()
        rlp.Encode(keybuf, uint(i))
        hasher.Update(keybuf.Bytes(), list.GetRlp(i))
    }
    return hasher.Hash()
}

收据树的构造是通过索引做key，验证的时候难以验证收据在区块中的索引，所以难以单独校验，通过将索引改为TxHash可解决此问题，不过需要在验证区块的时候加上交易的排序才可以。

第一篇文章讲到跨链交易转发后停了，现在接着继续讲。

    case msg.Code == OtherTransactionMsg || (msg.Code == PooledTransactionsMsg && p.version >= eth65):
        var txs []*types.Transaction
        if err := msg.Decode(&txs); err != nil {
            return errResp(ErrDecode, "msg %v: %v", msg, err)
        }
        for i, tx := range txs {
            // Validate and mark the remote transaction
            p.MarkTransaction(tx.Hash())
        }
        // Broadcast the block and announce chain insertion event
        pm.eventMux.Post(core.NewOtherTxsEvent{Txs: txs})

网络中收到跨链交易后，将交易转发给矿工模块。

    if ev, ok := ev.Data.(core.NewOtherTxsEvent); ok {
        for _, tx := range ev.Txs {
            if w.insertCM(tx) && !request {
                request = true
                w.requestCrossTxProof(tx.Hash())
            }
        }
    }

矿工将交易插入缓存并去重，调用请求收据proof证明。

BestPeer请求证明

请求证明的过程涉及到找哪一个Peer请求数据的流程

    if ev, ok := obj.Data.(core.NewRequestTxProofEvent); ok {
        peer := pm.peersOther.BestPeer()
        if peer != nil {
            peer.RequestMMRReceipts([]common.Hash{ev.TxHash})
        }
    }

通过寻找难度最高的节点请求数据是最好的，如果难度最高的节点验证失败，找次之节点继续验证

对链Hash通知

本链每个区块的Hash和难度都会通过NewOtherBlockHashesMsg广播到对链，这样对链有了一个缓存本链哪个Peer的区块是最新的机制。

MMR第二次请求

当节点收到GetMMRReceiptProofMsg消息，为对链查询跨链消息的证明。

    case msg.Code == GetMMRReceiptProofMsg:
        var query getBlockMMRData
        if err := msg.Decode(&query)
        var mtProof ulvp.SimpleUlvpProof
        receiptRep, receipt, err := pm.ulVP.GetReceiptProof(query.TxHash)
        data, err := pm.ulVP.HandleSimpleUlvpMsgReq(pm.ulVP.GetSimpleUlvpMsgReq([]uint64{receipt.BlockNumber.Uint64(), pm.blockchain.CurrentBlock().NumberU64()}))
        mtProof.Result = true
        mtProof.ReceiptProof = receiptRep
        mtProof.ChainProof = &ulvp.UlvpChainProof{Res: data}
        mtProof.Header = pm.blockchain.GetHeaderByHash(receipt.BlockHash)
        mtProof.End = pm.blockchain.CurrentBlock().Number()
        mtProof.TxHash = query.TxHash

首先拿到对链请求的Txhash，查找此交易收据是否存在，生成收据的proof证明。

func (uv *SimpleULVP) GetReceiptProof(txHash common.Hash) (*ulvp.ReceiptTrieResps, *types.Receipt, error) {
    lookup := uv.localChain.GetTransactionLookup(txHash)
    receipts := uv.localChain.GetReceiptsByHash(lookup.BlockHash)

    tri := types.DeriveShaHasher(receipts, new(trie.Trie))
    keybuf := new(bytes.Buffer)
    keybuf.Reset()
    rlp.Encode(keybuf, lookup.Index)
    proofs := types.NewNodeSet()
    tri.Prove(keybuf.Bytes(), 0, proofs)
    return &ulvp.ReceiptTrieResps{Proofs: proofs.NodeList(), Index: lookup.Index, ReceiptHash: block.ReceiptHash()}, receipt, nil
}

根据交易所在高度生成MMR证明，由于高度发生改变，需要重新采样，故此时需要新的MMR证明。

data, err := pm.ulVP.HandleSimpleUlvpMsgReq(pm.ulVP.GetSimpleUlvpMsgReq([]uint64{receipt.BlockNumber.Uint64(), pm.blockchain.CurrentBlock().NumberU64()}))

将收据所在高度和当前区块的高度传进去生成证明。将两个证明拼在一起发给对方节点。

节点收据校验

节点收到验证数据，验证MMR和收据证明是否正确，校验失败将把本peer踢掉，然后通知矿工从新请求。

    case msg.Code == MMRReceiptProofMsg:
        var request *ulvp.SimpleUlvpProof
        if err := msg.Decode(&request); err != nil {
            return errResp(ErrDecode, "%v: %v", msg, err)
        }
        find := false
        if !request.Result {
            find = true
        } else if _, err := request.VerifyULVPTXMsg(request.TxHash); err != nil {
            find = true
        }
        if find {
            pm.removeOtherPeer(p.id)
            request.Result = false
        }
        pm.eventMux.Post(core.NewProofEvent{MRProof: request})

如果验证成功，矿工需要转换跨链为新的铸币交易，这部分在下篇继续梳理。目前已把节点证明和收据证明梳理完。

Mouse和Duck跨链github链接

感兴趣的朋友欢迎一起讨论。