FISCO BCOS——SmartDev-Contract——MarriageEvidence结婚证书合约案例分析

于 2021-12-27 20:37:55 发布
阅读量1.3w 收藏 17
点赞数 2
分类专栏： Solidity智能合约开发 区块链开发篇-FISCO BCOS 文章标签： 区块链 以太坊 比特币
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43402353/article/details/122179155
版权

MarriageEvidence结婚证书合约案例分析

一、合约场景分析

谨以白头之约书向鸿笺，好将红叶之盟载明鸳谱。三千年来，结婚证书的形式一直在变化，但我们相信，它承载的美好爱情和对幸福婚姻生活的向往从未变过。使用区块链技术，让结婚证书上链，定格在区块链的历史长河中——永存。

源码贡献者：

github：Blockchain_Key

源码分析者：

github：Blockchain_Key

源码链接：

https://github.com/WeBankBlockchain/SmartDev-Contract/tree/master/contracts/business_template/marriage_evidence

二丶基础合约介绍

1. 角色合约

Characters.sol：

pragma solidity^0.4.25;

import "./Roles.sol";

contract Character{
    using Roles for Roles.Role;
    Roles.Role private _character;
    
    event characterAdded(address amount,string summary);
    event characterRemoved(address amount);
    event characterRevised(address amount,string summary);
    event characterSeeked(address amount);
    
    address owner;
    address[] characters;
    
    
    constructor()public{
        owner = msg.sender;
    }
    
    modifier onlyOwner(){
        require(owner == msg.sender,"Only owner can call");
        _;
    }
    
    function isCharacter(address amount)public view returns(bool){
        return _character.has(amount);
    }
    
    function _addCharacter(address amount,string _summary)internal{
        _character.add(amount,_summary);
        characters.push(amount);
        emit characterAdded(amount,_summary);
    }
    
    function _removeCharacter(address amount)internal{
        _character.remove(amount);
        emit characterRemoved(amount);
    }
    
    function _reviseCharacter(address amount,string _summary)internal{
        _character.revise(amount,_summary);
        emit characterRevised(amount,_summary);
    }
    
    function _seekCharacter(address amount)internal view returns(string){
        return _character.seek(amount);
        emit characterSeeked(amount);
    }
    
    function _removeCharacterByAddress(address amount)internal{
        for (uint i = 0; i < characters.length; i++) {
            if (amount == characters[i])
                for (uint j = i; j < characters.length-1; j++) 
                    characters[j] = characters[j+1];
            characters.length--;
            }
    }   
    
    function addCharacter(address amount,string _summary)public onlyOwner{
        require(!isCharacter(amount),"The character already exist");
        _addCharacter(amount,_summary);
    }
    
    function removeCharacter(address amount)public onlyOwner{
        require(isCharacter(amount),"The character does not exist");
        _removeCharacter(amount);
        _removeCharacterByAddress(amount);
    }
    
    function reviseCharacter(address amount,string _summary)public onlyOwner{
        require(isCharacter(amount),"The character does not exist");
        _reviseCharacter(amount,_summary);
    }
    
    function seekCharacter(address amount)public view returns(string) {
        require(isCharacter(amount),"The character does not exist");
        return _seekCharacter(amount);
    }
    
    function getAllCharater()public view returns(address[]){
        return characters;
    }
    
}

Roles.sol：

pragma solidity^0.4.25;

library Roles{
    struct Role{
        mapping(address=>bool) bearer;
        mapping(address=>string) summary;
    }
    //判断角色
    function has(Role storage role,address amount)internal view returns(bool){
        require(amount!=address(0),"Address is zero address");
        return role.bearer[amount];
    }
    //添加角色
    function add(Role storage role,address amount,string _summary)internal{
        require(!has(role,amount),"Address already exists");
        role.bearer[amount] = true;
        role.summary[amount] = _summary;
    }
    //删除角色
    function remove(Role storage role,address amount)internal{
        require(has(role,amount),"Address does not exist");
        role.bearer[amount] = false;
    }
    //修改角色
    function revise(Role storage role,address amount,string _summary)internal {
        require(has(role,amount),"Address does not exist");
        role.summary[amount] = _summary;
    }
    //查询角色
    function seek(Role storage role,address amount)internal view returns(string){
        require(has(role,amount),"Address does not exist");
        return role.summary[amount];
    }
    
}

（1）功能说明

本合约支持角色操作。包含角色的增删改查：

（2）接口说明

提供了两个合约：Roles合约，Character合约。其中Character合约是对外服务合约，Roles合约是库合约，用于数据和逻辑抽象化。

Character合约：对外服务的唯一接口。包含：

  • addCharacter(address amount,string summary): 管理员进行添加角色操作。amount是添加角色的地址， _summary添加角色的基本信息
  • removeCharacter(address amount): 管理员进行删除角色操作。amount是删除角色的地址
  • reviseCharacter(address amount,string _summary)：管理员进行修改角色信息操作。amount是修改角色的地址， _summary修改角色的基本信息
  • seekCharacter(address amount): 任何人都可以进行查询角色信息操作。amount是查询角色的地址
  • getAllCharater()：任何人都可以进行查看当前存在的所有角色操作。
  • isCharacter(address amount): 任何人都可以进行查看当前地址是否已经被添加为角色。amount是查询的地址

（3）使用说明

角色的增删改查，整个过程如下：

合约初始化：

- 以管理员地址部署Character合约

合约调用：

- 管理员调用Character.addCharacter提交添加角色请求，参数传入添加角色的地址，角色的基本信息
- 任何人调用Character.getAllCharater提交查看角色请求
- 任何人调用Character.isCharacter提交查询当前地址是否已经被添加成功
- 管理员调用Character.reviseCharacter提交修改角色信息请求，参数传入修改角色的地址，修改角色的基本信息
- 任何人调用Character.seekCharacter提交查询角色信息请求，参数传入查询角色的地址
- 管理员调用Character.removeCharacter提交删除角色的请求，参数传入删除角色的地址
- 任何人调用Character.isCharacter提交查询角色是否还存在请求，参数传入查询角色的地址
- 任何人调用Character.getAllCharater提交查看角色请求

2. 存证合约

Evidence.sol

pragma solidity ^0.4.25;

contract EvidenceSignersDataABI
{
    //验证是否是合法地址
	function verify(address addr)public constant returns(bool){}
	//根据索引值返回签名者地址
	function getSigner(uint index)public constant returns(address){} 
	//返回签名人数
	function getSignersSize() public constant returns(uint){}
}

contract Evidence{
    
    string evidence; //存证信息
    address[] signers;//储存合法签名者地址
    address public factoryAddr;//工厂合约地址
    //返回事件信息，查看log->判断正确或错误的信息
    event addSignaturesEvent(string evi);
    event newSignaturesEvent(string evi, address addr);
    event errorNewSignaturesEvent(string evi, address addr);
    event errorAddSignaturesEvent(string evi, address addr);
    event addRepeatSignaturesEvent(string evi);
    event errorRepeatSignaturesEvent(string evi, address addr);
    //查看此地址是否为合法签名者地址
    function CallVerify(address addr) public constant returns(bool) {
        return EvidenceSignersDataABI(factoryAddr).verify(addr);
    }
    //初始化，创建存证合约
   constructor(string evi, address addr)  {
       factoryAddr = addr;
       //tx.origin =>启动交易的原始地址（其实就是部署者的地址）
       //如果是外部调用，在此可以理解为函数调用者地址
       if(CallVerify(tx.origin))
       {
           evidence = evi;
           signers.push(tx.origin);
           newSignaturesEvent(evi,addr);
       }
       else
       {
           errorNewSignaturesEvent(evi,addr);
       }
    }
    //返回签名信息，合约签名者地址，当前签名者地址
    function getEvidence() public constant returns(string,address[],address[]){
        uint length = EvidenceSignersDataABI(factoryAddr).getSignersSize();
         address[] memory signerList = new address[](length);
         for(uint i= 0 ;i<length ;i++)
         {
             signerList[i] = (EvidenceSignersDataABI(factoryAddr).getSigner(i));
         }
        return(evidence,signerList,signers);
    }
    //添加签名者地址（此地址必须为合约签名者地址）
    function addSignatures() public returns(bool) {
        for(uint i= 0 ;i<signers.length ;i++)
        {
            //此时的tx.orgin为当前调用此方法的调用者地址
            if(tx.origin == signers[i])
            {
                addRepeatSignaturesEvent(evidence);
                return true;
            }
        }
       if(CallVerify(tx.origin))
       {
            signers.push(tx.origin);
            addSignaturesEvent(evidence);
            return true;
       }
       else
       {
           errorAddSignaturesEvent(evidence,tx.origin);
           return false;
       }
    }
    //返回所有的合约签名者地址
    function getSigners()public constant returns(address[])
    {
         uint length = EvidenceSignersDataABI(factoryAddr).getSignersSize();
         address[] memory signerList = new address[](length);
         for(uint i= 0 ;i<length ;i++)
         {
             signerList[i] = (EvidenceSignersDataABI(factoryAddr).getSigner(i));
         }
         return signerList;
    }
}

EvidenceFactory.sol

pragma solidity ^0.4.25;
import "Evidence.sol";

contract EvidenceFactory{
        address[] signers;  //存储签名者地址
		event newEvidenceEvent(address addr); //新签证事件，返回地址
		//传入签名内容 string类型，创建合约Evidence并初始化
        function newEvidence(string evi)public returns(address)
        {
            //this:代表当前工厂合约的地址
            Evidence evidence = new Evidence(evi, this);
            newEvidenceEvent(evidence);
            return evidence;
        }
        //获得签证信息
        function getEvidence(address addr) public constant returns(string,address[],address[]){
            return Evidence(addr).getEvidence();
        }
        
                
        function addSignatures(address addr) public returns(bool) {
            return Evidence(addr).addSignatures();
        }
        //初始化合约，导入签名者们的地址（数组传参）为合法签名者地址
        //只有合法签名者才有资格进行签证
        constructor(address[] evidenceSigners){
            for(uint i=0; i<evidenceSigners.length; ++i) {
            signers.push(evidenceSigners[i]);
			}
		}
        // 验证身份是否为合法签名者地址
        function verify(address addr)public constant returns(bool){
                for(uint i=0; i<signers.length; ++i) {
                if (addr == signers[i])
                {
                    return true;
                }
            }
            return false;
        }
        //根据索引值返回合约签名者地址
        function getSigner(uint index)public constant returns(address){
            uint listSize = signers.length;
            //判断索引值是否越界
            if(index < listSize)
            {
                return signers[index];
            }
            else
            {
                return 0;
            }
    
        }
        //获取当前合约签名者人数
        function getSignersSize() public constant returns(uint){
            return signers.length;
        }
        //返回所有合约签名者的地址
        function getSigners() public constant returns(address[]){
            return signers;
        }

}

（1）功能说明

实现普通存证信息的创建，存储，获取

（2）接口说明

  • newEvidence(string evi)public returns(address)：创建新签证事件，返回地址
  • getEvidence(address addr) public constant returns(string,address[],address[])：获取存证信息
  • addSignatures(address addr) public returns(bool)：添加合法签名者
  • getSigner(uint index)public constant returns(address)：返回签名者地址
  • getSignersSize() public constant returns(uint)：获取总签名人数
  • getSigners() public constant returns(address[])：返回所有合约签名者的地址

（3）使用说明

  • 部署合约，初始化传入2个用户地址
    0x76c4e6e1d093092135d79677b724ae3470cdd6e3
    0xad6110c4f698ec996667fd5e2da0cdf5f1ee78e8
    在这里插入图片描述

  • 查看合法签名者地址
    在这里插入图片描述
    在这里插入图片描述

  • 查看是否为合法地址
    在这里插入图片描述
    在这里插入图片描述

  • 创建签证合约（只有合法签名者才能成功创建）
    在这里插入图片描述
    在这里插入图片描述

  • 查看签证信息
    在这里插入图片描述
    在这里插入图片描述

  • 合法签名者签名签证合约
    在这里插入图片描述
    在这里插入图片描述

  • 再次查看签证信息
    在这里插入图片描述

三丶业务合约介绍

1. 结婚证书合约

MarriageEvidence.sol

pragma solidity^0.4.25;
import "./EvidenceFactory.sol";
import "./Character.sol";

contract MarriageEvidence is Character{
    address admin;
    address eviContractAddress;
    address eviAddress;
    constructor() public Character{
        admin = msg.sender;
    }
    
    modifier adminOnly{  
        require(msg.sender == admin ,"require admin");
        _;
    }
    
    modifier charactersMustBeAddedFirst{
        require(getAllCharater().length != 0,"It is null");
        _;
    }
    
    modifier signersOnly{
        require(EvidenceFactory(eviContractAddress).verify(msg.sender),"you not is signer");
        _;
    }
    function deployEvi() external adminOnly charactersMustBeAddedFirst{
        addCharacter(msg.sender,"民政局");
        EvidenceFactory evi = new EvidenceFactory(getAllCharater());
        eviContractAddress = address(evi);
    }
    
    function getSigners() public constant returns(address[]){
        return EvidenceFactory(eviContractAddress).getSigners();
    }
    
    function newEvi(string _evi)public adminOnly returns(address){
        eviAddress = EvidenceFactory(eviContractAddress).newEvidence(_evi);
        return eviAddress;
    }
    
    function sign() public signersOnly returns(bool) {
            return EvidenceFactory(eviContractAddress).addSignatures(eviAddress);
    }
    function getEvi() public constant returns(string,address[],address[]){
            return EvidenceFactory(eviContractAddress).getEvidence(eviAddress);
    }
}

（1）功能说明

实现结婚证书的创建，发放，夫妻签名，验证合法性等

（2）接口说明

  • addCharacter(address amount,string _summary)：传入要添加的夫妻地址，以及基本信息
  • deployEvi() external adminOnly charactersMustBeAddedFirst：此方法必须要提前添加人物角色
  • getSigners() public constant returns(address[])：获取夫妻地址，返回地址数组
  • newEvi(string _evi)public adminOnly returns(address)：传入结婚信息，创建结婚证书请求，返回证书地址
  • sign() public signersOnly returns(bool)：夫妻分调用此接口对证书进行签名，使其具有合法性
  • getEvi()public constant returns(string,address[],address[])：获取结婚证书相关信息

（3）使用说明

  • 部署 MarriageEvidence 合约(民政局管理员key调用部署合约)
    在这里插入图片描述
    在这里插入图片描述

  • 调用添加角色接口

民政局管理员Key调用方法：
添加丈夫地址：0x004a8b8f111b02bc49a06bc4c8b19c29048b939c
添加丈夫信息：{ "name": "K", "url": "https://blog.csdn.net/weixin_43402353", "id": 321183200007270010, "sex": male, "address": { "street": "科技园路.", "city": "江苏苏州", "country": "中国" } }
添加妻子地址：0xd3c34312ae665884c453d46325341d649eb3c05b
添加妻子信息：{ "name": "T", "url": "https://blog.csdn.net/weixin_43402353", "id": 320382200012100001, "sex": female, "address": { "street": "国际中心", "city": "江苏扬州", "country": "中国" } }

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  • 调用查看信息接口
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 部署存证合约(调用 deployEvi 方法)
    在这里插入图片描述

  • 创建结婚证书(本质上是支持多签的一条存证)
    在这里插入图片描述
    在这里插入图片描述

  • 调用sign接口(夫妻分别签名)
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 调用getEvi查看证书
    在这里插入图片描述
    在这里插入图片描述

评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Blockchain_KT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值