Bystack 是由比原链团队提出的一主多侧链架构的 BaaS 平台。其将区块链应用分为三层架构：底层账本层，侧链扩展层，业务适配层。底层账本层为 Layer1，即为目前比较成熟的采用 POW 共识的 Bytom 公链。侧链扩展层为 Layer2，为多侧链层，vapor 侧链即处于 Layer2。
Vapor 侧链采用 DPOS 和 BBFT 共识，TPS 可以达到数万。此处就分析一下连接 Bytom 主链和 Vapor 侧链的跨链模型。
主侧链协同工作模型
1、技术细节
POW 当前因为能源浪费而饱受诟病，而且 POW 本身在提高 TPS 的过程中遇到诸多问题，理论上可以把块变大，可以往块里面塞更多的交易。TPS 是每秒出块数*块里面的交易数。但是也存在问题：小节点吃不消存储这么大的容量的内容，会慢慢变成中心化的模式，因为只有大财团和大机构才有财力去组建机房设备，成为能出块的节点。同时传输也存在问题，网络带宽是有限的，块的大小与网络传输的边际是有关的，不可能无限的去增加块的大小，网络边际上的人拿不到新块的信息，也会降低去中心化的程度，这就是为什么 POW 不能在提高可靠性的情况下，提高 TPS 的原因。
而 BFT 虽然去中心化较弱，但其效率和吞吐量高，也不需要大量的共识计算，非常环保节能，很符合 Bystack 侧链高 TPS 的性能需求
(1)跨链模型架构
在 Bystack 的主侧链协同工作模型中，包括有主链、侧链和 Federation。主链为 bytom，采用基于对 AI 计算友好型 PoW（工作量证明）算法，主要负责价值锚定，价值传输和可信存证。侧链为 Vapor,采用 DPOS+BBFT 共识，高 TPS 满足垂直领域业务。主链和侧链之间的资产流通主要依靠 Federation。
(2)节点类型
跨链模型中的节点主要有收集人、验证人和联邦成员。收集人监控联邦地址，收集交易后生成 Claim 交易进行跨链。验证人则是侧链的出块人。联邦成员由侧链的用户投票通过选举产生，负责生成新的联邦合约地址。
(3)跨链交易流程
主链到侧链
主链用户将代币发送至联邦合约地址，收集人监控联邦地址，发现跨链交易后生成 Claim 交易，发送至侧链
侧链到主链
侧链用户发起提现交易，销毁侧链资产。收集人监控侧链至主链交易，向主链地址发送对应数量资产。最后联邦在侧链生成一笔完成提现的操作交易。
2、代码解析
跨链代码主要处于 federation 文件夹下，这里就这部分代码进行一个介绍。
(1)keeper 启动
整个跨链的关键在于同步主链和侧链的区块，并处理区块中的跨链交易。这部份代码主要在 mainchain_keerper.go 和 sidechain_keerper.go 两部分中，分别对应处理主链和侧链的区块。keeper 在 Run 函数中启动。
func (m *mainchainKeeper) Run() { ticker := time.NewTicker(time.Duration(m.cfg.SyncSeconds) * time.Second) for ; true; <-ticker.C { for { isUpdate, err := m.syncBlock() if err != nil { //.. } if !isUpdate { break } } } }
Run 函数中首先生成一个定时的 Ticker，规定每隔 SyncSeconds 秒同步一次区块，处理区块中的交易。
(2)主侧链同步区块
Run 函数会调用 syncBlock 函数同步区块。
func (m *mainchainKeeper) syncBlock() (bool, error) { chain := &orm.Chain{Name: m.chainName} if err := m.db.Where(chain).First(chain).Error; err != nil { return false, errors.Wrap(err, "query chain") } height, err := m.node.GetBlockCount() //.. if height <= chain.BlockHeight+m.cfg.Confirmations { return false, nil } nextBlockStr, txStatus, err := m.node.GetBlockByHeight(chain.BlockHeight + 1) //.. nextBlock := &types.Block{} if err := nextBlock.UnmarshalText([]byte(nextBlockStr)); err != nil { return false, errors.New("Unmarshal nextBlock") } if nextBlock.PreviousBlockHash.String() != chain.BlockHash { //... return false, ErrInconsistentDB } if err := m.tryAttachBlock(chain, nextBlock, txStatus); err != nil { return false, err } return true, nil }
这个函数受限会根据 chainName 从数据库中取出对应的 chain。然后利用 GetBlockCount 函数获得 chain 的高度。然后进行一个伪确定性的检测。
height <= chain.BlockHeight+m.cfg.Confirmations
主要是为了判断链上的资产是否已经不可逆。这里 Confirmations 的值被设为 10。如果不进行这个等待不可逆的过程，很可能主链资产跨链后，主链的最长链改变，导致这笔交易没有在主链被打包，而侧链却增加了相应的资产。在此之后，通过 GetBlockByHeight 函数获得 chain 的下一个区块。
nextBlockStr, txStatus, err := m.node.GetBlockByHeight(chain.BlockHeight + 1)
这里必须满足下个区块的上一个区块哈希等于当前 chain 中的这个头部区块哈希。这也符合区块链的定义。
if nextBlock.PreviousBlockHash.String() != chain.BlockHash { //.. }
在此之后，通过调用 tryAttachBlock 函数进一步调用 processBlock 函数处理区块。
(3)区块处理
processBlock 函数会判断区块中交易是否为跨链的 deposit 或者是 withdraw，并分别调用对应的函数去进行处理。
func (m *mainchainKeeper) processBlock(chain *orm.Chain, block *types.Block, txStatus *bc.TransactionStatus) error { if err := m.processIssuing(block.Transactions); err != nil { return err } for i, tx := range block.Transactions { if m.isDepositTx(tx) { if err := m.processDepositTx(chain, block, txStatus, uint64(i), tx); err != nil { return err } } if m.isWithdrawalTx(tx) { if err := m.processWithdrawalTx(chain, block, uint64(i), tx); err != nil { return err } } } return m.processChainInfo(chain, block) }
在这的 processIssuing 函数，它内部会遍历所有交易输入 Input 的资产类型，也就是 AssetID。当这个 AssetID 不存在的时候，则会去在系统中创建一个对应的资产类型。每个 Asset 对应的数据结构如下所示。
m.assetStore.Add(&orm.Asset{ AssetID: assetID.String(), IssuanceProgram: hex.EncodeToString(inp.IssuanceProgram), VMVersion: inp.VMVersion, RawDefinitionByte: hex.EncodeToString(inp.AssetDefinition), })
在 processBlock 函数中，还会判断区块中每笔交易是否为跨链交易。主要通过 isDepositTx 和 isWithdrawalTx 函数进行判断。
func (m *mainchainKeeper) isDepositTx(tx *types.Tx) bool { for _, output := range tx.Outputs { if bytes.Equal(output.OutputCommitment.ControlProgram, m.fedProg) { return true } } return false } func (m *mainchainKeeper) isWithdrawalTx(tx *types.Tx) bool { for _, input := range tx.Inputs { if bytes.Equal(input.ControlProgram(), m.fedProg) { return true } } return false }
看一下这两个函数，主要还是通过比较交易中的 control program 这个标识和 mainchainKeeper 这个结构体中的 fedProg 进行比较，如果相同则为跨链交易。fedProg 在结构体中为一个字节数组。
type mainchainKeeper struct { cfg *config.Chain db *gorm.DB node *service.Node chainName string assetStore *database.AssetStore fedProg []byte }
(4)跨链交易(主链到侧链的 deposit)处理
这部分主要分为主链到侧链的 deposit 和侧链到主链的 withdraw。先看比较复杂的主链到侧链的 deposit 这部分代码的处理。
func (m *mainchainKeeper) processDepositTx(chain *orm.Chain, block *types.Block, txStatus *bc.TransactionStatus, txIndex uint64, tx *types.Tx) error { //.. rawTx, err := tx.MarshalText() if err != nil { return err } ormTx := &orm.CrossTransaction{ //.. } if err := m.db.Create(ormTx).Error; err != nil { return errors.Wrap(err, fmt.Sprintf("create mainchain DepositTx %s", tx.ID.String())) } statusFail := txStatus.VerifyStatus[txIndex].StatusFail crossChainInputs, err := m.getCrossChainReqs(ormTx.ID, tx, statusFail) if err != nil { return err } for _, input := range crossChainInputs { if err := m.db.Create(input).Error; err != nil { return errors.Wrap(err, fmt.Sprintf("create DepositFromMainchain input: txid(%s), pos(%d)", tx.ID.String(), input.SourcePos)) } } return nil }
这里它创建了一个跨链交易 orm。具体的结构如下。可以看到，这里它的结构体中包括有 source 和 dest 的字段。
ormTx := &orm.CrossTransaction{ ChainID: chain.ID, SourceBlockHeight: block.Height, SourceBlockTimestamp: block.Timestamp, SourceBlockHash: blockHash.String(), SourceTxIndex: txIndex, SourceMuxID: muxID.String(), SourceTxHash: tx.ID.String(), SourceRawTransaction: string(rawTx), DestBlockHeight: sql.NullInt64{Valid: false}, DestBlockTimestamp: sql.NullInt64{Valid: false}, DestBlockHash: sql.NullString{Valid: false}, DestTxIndex: sql.NullInt64{Valid: false}, DestTxHash: sql.NullString{Valid: false}, Status: common.CrossTxPendingStatus, }
创建这笔跨链交易后，它会将交易存入数据库中。
if err := m.db.Create(ormTx).Error; err != nil { return errors.Wrap(err, fmt.Sprintf("create mainchain DepositTx %s", tx.ID.String())) }
在此之后，这里会调用 getCrossChainReqs。这个函数内部较为复杂，主要作用就是遍历交易的输出，返回一个跨链交易的请求数组。具体看下这个函数。
func (m *mainchainKeeper) getCrossChainReqs(crossTransactionID uint64, tx *types.Tx, statusFail bool) ([]*orm.CrossTransactionReq, error) { //.. switch { case segwit.IsP2WPKHScript(prog): //.. case segwit.IsP2WSHScript(prog): //.. } reqs := []*orm.CrossTransactionReq{} for i, rawOutput := range tx.Outputs { //.. req := &orm.CrossTransactionReq{ //.. } reqs = append(reqs, req) } return reqs, nil }
很显然，这个地方的交易类型有 pay to public key hash 和 pay to script hash 这两种。这里会根据不同的交易类型进行一个地址的获取。
switch { case segwit.IsP2WPKHScript(prog): if pubHash, err := segwit.GetHashFromStandardProg(prog); err == nil { fromAddress = wallet.BuildP2PKHAddress(pubHash, &vaporConsensus.MainNetParams) toAddress = wallet.BuildP2PKHAddress(pubHash, &vaporConsensus.VaporNetParams) } case segwit.IsP2WSHScript(prog): if scriptHash, err := segwit.GetHashFromStandardProg(prog); err == nil { fromAddress = wallet.BuildP2SHAddress(scriptHash, &vaporConsensus.MainNetParams) toAddress = wallet.BuildP2SHAddress(scriptHash, &vaporConsensus.VaporNetParams) } }
在此之后，函数会遍历所有交易的输出，然后创建跨链交易请求，具体的结构如下。
req := &orm.CrossTransactionReq{ CrossTransactionID: crossTransactionID, SourcePos: uint64(i), AssetID: asset.ID, AssetAmount: rawOutput.OutputCommitment.AssetAmount.Amount, Script: script, FromAddress: fromAddress, ToAddress: toAddress, }
创建完所有的跨链交易请求后，返回到 processDepositTx 中一个 crossChainInputs 数组中，并存入 db。
for _, input := range crossChainInputs { if err := m.db.Create(input).Error; err != nil { return errors.Wrap(err, fmt.Sprintf("create DepositFromMainchain input: txid(%s), pos(%d)", tx.ID.String(), input.SourcePos)) } }
到这里，对主链到侧链的 deposit 已经处理完毕。
(5)跨链交易(侧链到主链的 withdraw)交易处理
这部分比较复杂的逻辑主要在 sidechain_keeper.go 中的 processWithdrawalTx 函数中。这部分逻辑和上面主链到侧链的 deposit 逻辑类似。同样是创建了 orm.crossTransaction 结构体，唯一的改变就是交易的 souce 和 dest 相反。这里就不作具体描述了。
3、跨链优缺点
优点
(1) 跨链模型、代码较为完整。当前有很多项目使用跨链技术，但是真正实现跨链的寥寥无几。
(2) 可以根据不同需求实现侧链，满足多种场景
缺点
(1) 跨链速度较慢，需等待 10 个区块确认，这在目前 Bytom 网络上所需时间为 30 分钟左右
(2) 相较于 comos、polkadot 等项目，开发者要开发侧链接入主网成本较大
(3) 只支持资产跨链，不支持跨链智能合约调用
**4、**跨链模型平行对比 Cosmos
可扩展性
bystack 的主测链协同工作模型依靠 Federation，未形成通用协议。其他开发者想要接入其跨链网络难度较大。Cosmos 采用 ibc 协议，可扩展性较强。
代码开发进度
vapor 侧链已经能够实现跨链。Cosmos 目前暂无成熟跨链项目出现，ibc 协议处于最终开发阶段。
跨链模型
vapor 为主侧链模型，Cosmos 为 Hub-Zone 的中继链模型。
5、参考建议
侧链使用 bbft 共识，非 POW 的情况下，无需等待 10 个交易确认，增快跨链速度。
作者：诗人
欢迎来到这里！
我们正在构建一个小众社区，大家在这里相互信任，以平等 • 自由 • 奔放的价值观进行分享交流。最终，希望大家能够找到与自己志同道合的伙伴，共同成长。
注册 关于