区块链入门

铁锅炖乔治

于 2024-04-19 16:04:32 发布

阅读量1.3k

点赞数 7

文章标签：区块链

本文链接：https://blog.csdn.net/qq_47102434/article/details/134553284

版权

(一）solidity 见文档

(二）Fisco环境部署

1.Ubuntu搭建单群组Fisco联盟链

1）下载Xftp(与虚拟机交互文件）,Xhell（使用虚拟机的命令行）,官网注册，可免费使用，先查找一下看我下了没有，没有的话就csdn一下教程。

Xshell和xftp免费下载与使用-CSDN博客

2）打开VM,ubuntu20之前我已经在你电脑上配过了，直接打开就行。密码要么root,要么sga163179.进入后，先设置root密码，

ubuntu常用操作：

操作	方法
复制(windows)	Ctrl + shift+C
粘贴(windows)	Ctrl + shift+v
复制(ubuntu)	ctrl+insert
粘贴(uhuntu)	shift+insert
退出	wq
强制退出	q!
切换编辑模式	esc
输入	esc+a

为避免使用vi,可以先下载vim

sudo apt-get install vim-gtk

3）查询虚拟机ip地址，链接Ubuntu主机

允许远程链接：vi可以用vim

vim /etc/ssh/sshd_config
sudo /etc/init.d/ssh restart

打开xftp,连接ubuntu：

结果：链接成功

4）部署环境，下载Fasco

更新依赖

apt -get update

安装依赖

sudo apt install -y openssl curl

创建文件夹

cd ~ && mkdir -p fisco && cd fisco
cd fisco

下载脚本

 curl -#LO https://gitee.com/FISCO-BCOS/FISCO-BCOS/raw/master/tools/build_chain.sh && chmod u+x build_chain.sh

给普通用户权限：

chmod u+x build_chain.sh

搭建单群组4节点联盟链

这一步之前：

1)注意目录必须在~/fisco

2)ls有脚本build_clain.sh

3)请确保机器的30300,30303，20200,20203，8545~8548端口没有被占用，也可以通过-p参数指定其他端口.

bash build_chain.sh -l 127.0.0.1:4 -p 30300,20200,8545

5)启动联盟链

启动联盟链四节点

bash nodes/127.0.0.1/start_all.sh

检查进程，必须有四个节点的进程才算启动成功

ps -ef | grep -v grep | grep fisco-bcos

检查节点node0链接的节点数

tail -f nodes/127.0.0.1/node0/log/log*  | grep connected

crtl+z停止

执行下面指令，检查是否在共识

tail -f nodes/127.0.0.1/node0/log/log*  | grep +++

到这里，已经说明成功在本机部署运行单群组四节点的区块链网络

建议此时保存一个快照

2.配置使用控制台

安装Java环境

sudo apt-get install openjdk-8-jdk

修改环境变量（复制粘贴时，在vim里粘贴先按esc切换模式，再按a,复制后粘贴要用shift+insert)

vim /etc/profile

#在末尾加上以下内容

export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
export PATH=$PATH:$JAVA_HOME/bin

刷新环境变量

source /etc/profile

配置WeBASE-Front

下载安装包

cd ~/fisco/&& wget https://osp-1257653870.cos.ap-guangzhou.myqcloud.com/WeBASE/releases/download/v1.5.2/webase-front.zip

解压

unzip webase-front.zip

将节点所在目录nodes/${ip}/sdk下的证书文件拷贝到conf下，下面是拷贝127.0.0.1节点示例

cp -r nodes/127.0.0.1/sdk/* webase-front/conf/

进入服务

cd webase-front

同时，以下几个服务的命令可能会用到

启动：bash start.sh

停止：bash stop.sh

检查：bash status.sh

输入启动命令：

打开ubuntu浏览器，访问http://localhost:5002/WeBASE-Front

http://localhost:5002/WeBASE-Front/#/home

到这，区块链环境已经搭建完毕，建议在存一个快照

3.合约部署

1）编写合约，后缀名为sol

测试代码

pragma solidity ^0.4.25;
 
contract Helloworld{
    string name;
    
    function Helloworld(){
        name = "Helloworld";
    }
    
    function get()constant returns(string){
        return name;
    }
    
    function setname(string n){
        name = n;
    }
}

编写完成后，点击保存和编译。

2）部署

首先创造一个测试用户来测试

此时返回idea点击部署

最后，对合约的方法进行调用检测

合约中有两个方法，get和set

效果

到这，撒花完结。

4.合约开发

代码

pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

contract DataStorageContract {
    // 数据托管上链合约结构体
    struct StoreLog {
        uint timestamp;         // 时间戳
        string operationType;   // 操作类型
        uint fileId;            // 文件id
        string provider;        // 提供方身份id
        string manager;         // 管理方身份id
        string result;          // 操作结果
        uint bnum;              // 块高
    }

    // 存储结构体的映射
    mapping(uint => StoreLog) private storeLogs;

    // 构造函数
    constructor() {
        // 可以在构造函数中进行一些初始化操作
    }

    // 修改结构体变量的函数
    function putNewStoreLog(
        string memory _operationType,
        uint _fileId,
        string memory _provider,
        string memory _manager,
        string memory _result,
        uint _bnum
    ) public {
        StoreLog storage newStoreLog = storeLogs[_fileId];
        newStoreLog.timestamp = block.timestamp;
        newStoreLog.operationType = _operationType;
        newStoreLog.fileId = _fileId;
        newStoreLog.provider = _provider;
        newStoreLog.manager = _manager;
        newStoreLog.result = _result;
        newStoreLog.bnum = _bnum;
    }

    // 按结构体的fileId获取结构体的函数
    function getFileById(uint _fileId) public view returns (uint, string memory, string memory,string memory, string memory, uint) {
        StoreLog memory result = storeLogs[_fileId];
        return (result.timestamp, result.operationType,result.provider, result.manager, result.result, result.bnum);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

contract DataShareContract {
    // 结构体定义
    struct ShareLog {
        uint timestamp;
        string operationType;
        uint fileId;
        string manager;
        string user;
        string result;
        uint bnum;
    }

    // 存储分享日志的数组
    ShareLog[] public shareLogs;

    // 添加新的分享日志
    function putNewShareLog(
        string memory _operationType,
        uint _fileId,
        string memory _manager,
        string memory _user,
        string memory _result,
        uint _bnum
    ) public {
        // 获取当前块的时间戳
        uint timestamp = block.timestamp;

        ShareLog memory newShareLog = ShareLog({
            timestamp: timestamp,
            operationType: _operationType,
            fileId: _fileId,
            manager: _manager,
            user: _user,
            result: _result,
            bnum: _bnum
        });

        shareLogs.push(newShareLog);
    }

    // 根据文件ID获取分享日志的特定字段
    function getFileById(uint _fileId) public view returns (uint, string memory, string memory, string memory) {
        for (uint i = 0; i < shareLogs.length; i++) {
            if (shareLogs[i].fileId == _fileId) {
                return (shareLogs[i].timestamp, shareLogs[i].operationType, shareLogs[i].manager, shareLogs[i].result);
            }
        }

        // 如果没有找到对应文件ID的分享日志，则返回一个空的元组
        return (0, "", "", "");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

contract DataConfirmContract {
    // 结构体定义
    struct ConfirmLog {
        uint timestamp;
        string operationType;
        uint fileId;
        string provider;
        string manager;
        string user;
        string result;
        uint bnum;
    }

    // 存储确权日志的数组
    ConfirmLog[] public confirmLogs;

    // 添加新的确权日志
    function putNewConfirmLog(
        string memory _operationType,
        uint _fileId,
        string memory _provider,
        string memory _manager,
        string memory _user,
        string memory _result,
        uint _bnum
    ) public {
        // 获取当前块的时间戳
        uint timestamp = block.timestamp;

        ConfirmLog memory newConfirmLog = ConfirmLog({
            timestamp: timestamp,
            operationType: _operationType,
            fileId: _fileId,
            provider: _provider,
            manager: _manager,
            user: _user,
            result: _result,
            bnum: _bnum
        });

        confirmLogs.push(newConfirmLog);
    }

    // 根据文件ID获取确权日志的特定字段
    function getFileById(uint _fileId) public view returns (uint, string memory, string memory, string memory) {
        for (uint i = 0; i < confirmLogs.length; i++) {
            if (confirmLogs[i].fileId == _fileId) {
                return (confirmLogs[i].timestamp, confirmLogs[i].operationType, confirmLogs[i].manager, confirmLogs[i].result);
            }
        }

        // 如果没有找到对应文件ID的确权日志，则返回一个空的元组
        return (0, "", "", "");
    }
}

pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

contract DataStorageContract {
    // 数据托管上链合约结构体
    struct StoreLog {
        uint timestamp;         // 时间戳
        string operationType;   // 操作类型
        uint fileId;            // 文件id
        string provider;        // 提供方身份id
        string manager;         // 管理方身份id
        string result;          // 操作结果
        uint bnum;              // 块高
    }

    // 存储结构体的映射
    mapping(uint => StoreLog) private storeLogs;

    // 构造函数
    constructor() {
        // 可以在构造函数中进行一些初始化操作
    }

    // 修改结构体变量的函数
    function putNewStoreLog(
        string memory _operationType,
        uint _fileId,
        string memory _provider,
        string memory _manager,
        string memory _result,
        uint _bnum
    ) public {
        StoreLog storage newStoreLog = storeLogs[_fileId];
        newStoreLog.timestamp = block.timestamp;
        newStoreLog.operationType = _operationType;
        newStoreLog.fileId = _fileId;
        newStoreLog.provider = _provider;
        newStoreLog.manager = _manager;
        newStoreLog.result = _result;
        newStoreLog.bnum = _bnum;
    }

    // 按结构体的fileId获取结构体的函数
    function getFileById(uint _fileId) public view returns (uint, string memory, string memory,string memory, string memory, uint) {
        StoreLog memory result = storeLogs[_fileId];
        return (result.timestamp, result.operationType,result.provider, result.manager, result.result, result.bnum);
    }
}
-------------------------------------------------------------------------------
// SPDX-License-Identifier: MIT
pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

contract DataShareContract {
    // 结构体定义
    struct ShareLog {
        uint timestamp;
        string operationType;
        uint fileId;
        string manager;
        string user;
        string result;
        uint bnum;
    }

    // 存储分享日志的数组
    ShareLog[] private shareLogs;

    // 添加新的分享日志
    function putNewShareLog(
        string memory _operationType,
        uint _fileId,
        string memory _manager,
        string memory _user,
        string memory _result,
        uint _bnum
    ) public {
        // 获取当前块的时间戳
        uint timestamp = block.timestamp;

        ShareLog memory newShareLog = ShareLog({
            timestamp: timestamp,
            operationType: _operationType,
            fileId: _fileId,
            manager: _manager,
            user: _user,
            result: _result,
            bnum: _bnum
        });

        shareLogs.push(newShareLog);
    }

    // 根据文件ID获取分享日志的特定字段
    function getFileById(uint _fileId) public view returns (uint, string memory, string memory, ,string memory, string memory) {
        for (uint i = 0; i < shareLogs.length; i++) {
            if (shareLogs[i].fileId == _fileId) {
                return (shareLogs[i].timestamp, shareLogs[i].operationType, shareLogs[i].provider,shareLogs[i].manager, shareLogs[i].result);
            }
        }

        // 如果没有找到对应文件ID的分享日志，则返回一个空的元组
        return (0, "", "", "");
    }
}
---------------------------------------------------------------------------
// SPDX-License-Identifier: MIT
pragma solidity ^0.4.25;
pragma experimental ABIEncoderV2;

contract DataConfirmContract {
    // 结构体定义
    struct ConfirmLog {
        uint timestamp;
        string operationType;
        uint fileId;
        string provider;
        string manager;
        string user;
        string result;
        uint bnum;
    }

    // 存储确权日志的数组
    ConfirmLog[] private confirmLogs;

    // 添加新的确权日志
    function putNewConfirmLog(
        string memory _operationType,
        uint _fileId,
        string memory _provider,
        string memory _manager,
        string memory _user,
        string memory _result,
        uint _bnum
    ) public {
        // 获取当前块的时间戳
        uint timestamp = block.timestamp;

        ConfirmLog memory newConfirmLog = ConfirmLog({
            timestamp: timestamp,
            operationType: _operationType,
            fileId: _fileId,
            provider: _provider,
            manager: _manager,
            user: _user,
            result: _result,
            bnum: _bnum
        });

        confirmLogs.push(newConfirmLog);
    }

    // 根据文件ID获取确权日志的特定字段
    function getFileById(uint _fileId) public view returns (uint, string memory, string memory, ,string memory, string memory) {
        for (uint i = 0; i < confirmLogs.length; i++) {
            if (confirmLogs[i].fileId == _fileId) {
                return (confirmLogs[i].timestamp, confirmLogs[i].operationType,confirmLogs[i].provider, confirmLogs[i].manager, confirmLogs[i].result);
            }
        }

        // 如果没有找到对应文件ID的确权日志，则返回一个空的元组
        return (0, "", "", "");
    }
}