基于以太坊开发的赏金激励毕业系统设计

最新推荐文章于 2022-03-01 12:08:33 发布
最新推荐文章于 2022-03-01 12:08:33 发布
阅读量467 收藏
点赞数
分类专栏： 区块链毕设论文资料 区块链毕设
个人网站www.qklbishe.com
本文链接：https://blog.csdn.net/v_dnf767/article/details/106434004
版权

1.基本原理

奖励是激励机制的最简单形式：为人们提供完成任务的令牌。以太坊区块链提供了许多好处来支持以下激励机制：

  • 与世界各地的个人进行廉价交易的能力
  • 能够将资金锁定在代管合同（赏金）中的功能，当接受任务完成或可交付证明时，便可以支配资金
  • 以开放且可互操作的方式托管这些赏金的能力，因此可以使用许多不同类型的应用程序从共享的流动资金池（没有人控制）中创建，探索和完成赏金。通过这种方式，StandardBounties使团队能够通过一个应用程序（例如其DAO）创建赏金，并立即将赏金立即在多个赏金市场上列出，以最大程度地扩大赏金的覆盖面并提高市场效率。

2.实施

赏金中有几种关键类型的用户：

  • Bounty Issuers 是有权删除赏金并编辑与赏金相关的详细信息的地址列表。
  • Bounty Approvers是有权接收赏金提交地址的地址列表。（注意：发布者不被认为也是批准者，但可以根据需要添加自己）
  • Bounty Contributors 是对给定赏金有贡献的任何地址
  • Bounty Fulfillers 是任何对给定赏金提交内容的贡献者地址
  • Bounty Submitters 是代表自己或他人提交成就的任何地址

这些参与者共同努力，通过激励的力量来部署资金并塑造人类行为。

赏金生命周期中有几个核心动作，某些用户可以执行：

  • 任何人都可以issue赏金，指定赏金的详细信息，并将关联的IPFS哈希锚定在StandardBounties智能合约内的链上
  • 任何人都可以contribute悬赏，指定他们想要添加到端口的令牌数量。
  • 任何人都可以fulfill悬赏，提交贡献者列表以及详细信息和可交付成果的IPFS哈希。
  • 赏金的任何批准者都可以accept兑现，提交他们希望每个贡献者获得的代币数量。

这些行动构成了赏金的核心生命周期，支持资金流入各种赏金，并随着任务完成而流出。

各种用户可以执行一些其他操作：

  • 只要赏金的期限已过且未接受任何提交，任何贡献者都可以将其捐款退还给赏金。
  • 任何发行人都可以根据需要退还其他用户的捐款（即使还没有截止日期或赏金已经支付了一部分资金）
  • 任何发行人都可以耗尽赏金中一部分资金的赏金
  • 任何人都可以执行概括化的操作action，提交IPFS哈希表，该哈希表存储其操作的详细信息（例如，评论，提交其完成赏金的意图等）
  • 任何提交者都可以更新其提交内容，并对提交数据或贡献者列表进行更改
  • 任何批准者都可以同时提交并接受链下履行，一成不变地记录交换，同时省去了先行提交链上履行的需求
  • 任何发行人都可以更改赏金的任何细节，但与赏金相关的代币合约不可更改。

合约写法

pragma solidity 0.5.12;
pragma experimental ABIEncoderV2;

import "./StandardBounties.sol";



contract BountiesMetaTxRelayer {

  // This contract serves as a relayer for meta txns being sent to the Bounties contract

  StandardBounties public bountiesContract;
  mapping(address => uint) public replayNonce;


  constructor(address _contract) public {
    bountiesContract = StandardBounties(_contract);
  }

  function metaIssueBounty(
    bytes memory signature,
    address payable[] memory _issuers,
    address[] memory _approvers,
    string memory _data,
    uint _deadline,
    address _token,
    uint _tokenVersion,
    uint _nonce)
    public
    returns (uint)
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaIssueBounty",
                                                  _issuers,
                                                  _approvers,
                                                  _data,
                                                  _deadline,
                                                  _token,
                                                  _tokenVersion,
                                                  _nonce));
    address signer = getSigner(metaHash, signature);

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;
    return bountiesContract.issueBounty(address(uint160(signer)),
                                         _issuers,
                                         _approvers,
                                         _data,
                                         _deadline,
                                         _token,
                                         _tokenVersion);
  }

  function metaIssueAndContribute(
    bytes memory signature,
    address payable[] memory _issuers,
    address[] memory _approvers,
    string memory _data,
    uint _deadline,
    address _token,
    uint _tokenVersion,
    uint _depositAmount,
    uint _nonce)
    public
    payable
    returns (uint)
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaIssueAndContribute",
                                                  _issuers,
                                                  _approvers,
                                                  _data,
                                                  _deadline,
                                                  _token,
                                                  _tokenVersion,
                                                  _depositAmount,
                                                  _nonce));
    address signer = getSigner(metaHash, signature);

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    if (msg.value > 0){
      return bountiesContract.issueAndContribute.value(msg.value)(address(uint160(signer)),
                                                 _issuers,
                                                 _approvers,
                                                 _data,
                                                 _deadline,
                                                 _token,
                                                 _tokenVersion,
                                                 _depositAmount);
    } else {
      return bountiesContract.issueAndContribute(address(uint160(signer)),
                                                 _issuers,
                                                 _approvers,
                                                 _data,
                                                 _deadline,
                                                 _token,
                                                 _tokenVersion,
                                                 _depositAmount);
    }

  }

  function metaContribute(
    bytes memory _signature,
    uint _bountyId,
    uint _amount,
    uint _nonce)
    public
    payable
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaContribute",
                                                  _bountyId,
                                                  _amount,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    if (msg.value > 0){
      bountiesContract.contribute.value(msg.value)(address(uint160(signer)), _bountyId, _amount);
    } else {
      bountiesContract.contribute(address(uint160(signer)), _bountyId, _amount);
    }
  }


  function metaRefundContribution(
    bytes memory _signature,
    uint _bountyId,
    uint _contributionId,
    uint _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaRefundContribution",
                                                  _bountyId,
                                                  _contributionId,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.refundContribution(signer, _bountyId, _contributionId);
  }

  function metaRefundMyContributions(
    bytes memory _signature,
    uint _bountyId,
    uint[] memory _contributionIds,
    uint _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaRefundMyContributions",
                                                  _bountyId,
                                                  _contributionIds,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.refundMyContributions(signer, _bountyId, _contributionIds);
  }

  function metaRefundContributions(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    uint[] memory _contributionIds,
    uint _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaRefundContributions",
                                                  _bountyId,
                                                  _issuerId,
                                                  _contributionIds,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.refundContributions(signer, _bountyId, _issuerId, _contributionIds);
  }

  function metaDrainBounty(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    uint[] memory _amounts,
    uint _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaDrainBounty",
                                                  _bountyId,
                                                  _issuerId,
                                                  _amounts,
                                                  _nonce));
    address payable signer = address(uint160(getSigner(metaHash, _signature)));

    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.drainBounty(signer, _bountyId, _issuerId, _amounts);
  }

  function metaPerformAction(
    bytes memory _signature,
    uint _bountyId,
    string memory _data,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaPerformAction",
                                                  _bountyId,
                                                  _data,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.performAction(signer, _bountyId, _data);
  }

  function metaFulfillBounty(
    bytes memory _signature,
    uint _bountyId,
    address payable[] memory  _fulfillers,
    string memory _data,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaFulfillBounty",
                                                  _bountyId,
                                                  _fulfillers,
                                                  _data,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.fulfillBounty(signer, _bountyId, _fulfillers, _data);
  }

  function metaUpdateFulfillment(
    bytes memory _signature,
    uint _bountyId,
    uint _fulfillmentId,
    address payable[] memory  _fulfillers,
    string memory _data,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaUpdateFulfillment",
                                                  _bountyId,
                                                  _fulfillmentId,
                                                  _fulfillers,
                                                  _data,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.updateFulfillment(signer, _bountyId, _fulfillmentId, _fulfillers, _data);
  }

  function metaAcceptFulfillment(
    bytes memory _signature,
    uint _bountyId,
    uint _fulfillmentId,
    uint _approverId,
    uint[] memory _tokenAmounts,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaAcceptFulfillment",
                                                  _bountyId,
                                                  _fulfillmentId,
                                                  _approverId,
                                                  _tokenAmounts,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.acceptFulfillment(signer,
                       _bountyId,
                       _fulfillmentId,
                       _approverId,
                       _tokenAmounts);
  }

  function metaFulfillAndAccept(
    bytes memory _signature,
    uint _bountyId,
    address payable[] memory _fulfillers,
    string memory _data,
    uint _approverId,
    uint[] memory _tokenAmounts,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaFulfillAndAccept",
                                                  _bountyId,
                                                  _fulfillers,
                                                  _data,
                                                  _approverId,
                                                  _tokenAmounts,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.fulfillAndAccept(signer,
                      _bountyId,
                      _fulfillers,
                      _data,
                      _approverId,
                      _tokenAmounts);
  }

  function metaChangeBounty(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    address payable[] memory _issuers,
    address payable[] memory _approvers,
    string memory _data,
    uint _deadline,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaChangeBounty",
                                                  _bountyId,
                                                  _issuerId,
                                                  _issuers,
                                                  _approvers,
                                                  _data,
                                                  _deadline,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.changeBounty(signer,
                  _bountyId,
                  _issuerId,
                  _issuers,
                  _approvers,
                  _data,
                  _deadline);
  }

  function metaChangeIssuer(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    uint _issuerIdToChange,
    address payable _newIssuer,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaChangeIssuer",
                                                  _bountyId,
                                                  _issuerId,
                                                  _issuerIdToChange,
                                                  _newIssuer,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.changeIssuer(signer,
                  _bountyId,
                  _issuerId,
                  _issuerIdToChange,
                  _newIssuer);
  }

  function metaChangeApprover(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    uint _approverId,
    address payable _approver,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaChangeApprover",
                                                  _bountyId,
                                                  _issuerId,
                                                  _approverId,
                                                  _approver,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.changeApprover(signer,
                  _bountyId,
                  _issuerId,
                  _approverId,
                  _approver);
  }

  function metaChangeData(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    string memory _data,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaChangeData",
                                                  _bountyId,
                                                  _issuerId,
                                                  _data,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.changeData(signer,
                _bountyId,
                _issuerId,
                _data);
  }

  function metaChangeDeadline(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    uint  _deadline,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaChangeDeadline",
                                                  _bountyId,
                                                  _issuerId,
                                                  _deadline,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.changeDeadline(signer,
                    _bountyId,
                    _issuerId,
                    _deadline);
  }

  function metaAddIssuers(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    address payable[] memory _issuers,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaAddIssuers",
                                                  _bountyId,
                                                  _issuerId,
                                                  _issuers,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.addIssuers(signer,
                _bountyId,
                _issuerId,
                _issuers);
  }

  function metaAddApprovers(
    bytes memory _signature,
    uint _bountyId,
    uint _issuerId,
    address[] memory _approvers,
    uint256 _nonce)
    public
    {
    bytes32 metaHash = keccak256(abi.encode(address(this),
                                                  "metaAddApprovers",
                                                  _bountyId,
                                                  _issuerId,
                                                  _approvers,
                                                  _nonce));
    address signer = getSigner(metaHash, _signature);
    //make sure signer doesn't come back as 0x0
    require(signer != address(0));
    require(_nonce == replayNonce[signer]);

    //increase the nonce to prevent replay attacks
    replayNonce[signer]++;

    bountiesContract.addApprovers(signer,
                _bountyId,
                _issuerId,
                _approvers);
  }

  function getSigner(
    bytes32 _hash,
    bytes memory _signature)
    internal
    pure
    returns (address)
  {
    bytes32 r;
    bytes32 s;
    uint8 v;
    if (_signature.length != 65){
      return address(0);
    }
    assembly {
      r := mload(add(_signature, 32))
      s := mload(add(_signature, 64))
      v := byte(0, mload(add(_signature, 96)))
    }
    if (v < 27){
      v += 27;
    }
    if (v != 27 && v != 28){
      return address(0);
    } else {
        return ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", _hash)), v, r, s );
    }
  }
}

 

v_dnf767
关注
专栏目录
视频教程-基于以太坊开发的签到DAPP毕业设计-区块链
weixin_34829153的博客
05-28 763
基于以太坊开发的签到DAPP毕业设计 区块链技术研究者 ...
基于以太坊的在线付费课程毕业设计Dapp开发
05-22 595
基于以太坊的在线付费课程Dapp开发 选题背景 随着互联网的普及，知识付费时代也悄然来临——愿意付费学习网上课程的人越来越多，开放在线课程也越来越普遍。与此同时，衍生了学习训练营等社群圈子，打卡返学费也成为一种普遍的促销手段。另一方面，承诺返学费骗局也十分常见，消费者抱怨退费维权困难。在这个背景下，我们利用以太坊上的智能合约，使用合约平台代替网站付费平台或者人工管理，全部交易过程是自动触发的，确保退费的自动执行。同时，课程学习记录是公开透明了，可以作为学习成果的公开凭证。 具体说明 用户需要注册账号 提供账
基于以太坊开发的溯源物流系统毕业设计
05-13
基于以太坊开发的溯源物流系统，可满足毕业设计要求。本视频录制运行于2020年5月，源码部署简单，课程清晰易懂。完成学习本课程，可用作区块链DAPP毕业设计，课程设计。使用truffle.js ganache web3.js 以及使用meatmask构建dapp
基于以太坊开发的签到DAPP毕业设计
05-11
本视频录制运行于2020年5月13日，源码部署简单，课程清晰易懂。开发基于以太坊的签到系统DAPP，迅速了解DAPP项目开发流程。完成学习本课程，可用作区块链DAPP毕业设计，课程设计。使用truffle.js ganache web3.js 以及使用meatmask构建dapp。
区块链以太坊拍卖系统毕设源码
05-08
这是一个简单的拍卖平台。您可以创建新的拍卖，设置开始和结束时间（以及出价增量），使用ETH出价以及提取资金。 我使用ConsenSys的truffle -webpack-demo作为起点，因为这里使用的各种库之间都需要大量样板。 跑步 Web3 RPC位置将从truffle.js文件中选取。 克隆此仓库 npm install 确保testrpc正在其默认端口上运行。然后： npm run start -启动开发服务器 npm run build -生成一个版本 truffle test -运行其余套件（目前没有测试） 如果您使用npm run start该应用程序，则可以在http：// localhost：3001上找到该应用程序。
以太坊开发入门，完整入门
铁柱的博客
07-10 1801
以太坊开发入门，完整入门 翻译自：https://medium.com/@mattcondon/getting-up-to-speed-on-ethereum-63ed28821bbe 从入门到精通，干货篇。 必读，如果你： 是一个专业的程序员 如果你想了解以太坊当前可以做到什么程度，通过什么，如何做到。 预备知识： 1. 你需要知道区块链的概念及实现一个无需信任的电子货币的运作原理...
以太坊开发入门，完整入门篇
mongo_node的专栏
05-02 608
从入门到精通，干货篇。必读，如果你：是一个专业的程序员如果你想了解以太坊当前可以做到什么程度，通过什么，如何做到。预备知识：你需要知道区块链的概念及实现一个无需信任的电子货币的运作原理。可以先看看长版，如果你觉得太长，可以看看短版。但我还是建议，看那个长的视频。如果你是一名软件工程师，拥有软件开发的经验。能知道从系统、架构角度学一个东西，其实能倍增学习效果。如果有一周的空闲时间。好了，下面开始就不...
区块链学习笔记之以太坊（二）
baobaobao0000的博客
05-05 3267
区块链学习笔记二、以太坊5. 以太坊(ETH)的共识机制——GHOST协议5.1 引言5.2 GHOST协议最初版本5.3 Ghost协议新的版本6. 以太坊(ETH)挖矿算法6.1 挖矿概论6.2 莱特币挖矿算法6.3 以太坊挖矿算法7. 以太坊(ETH)难度调整7.1 难度调整的公式7.2 难度调整的代码 二、以太坊 5. 以太坊(ETH)的共识机制——GHOST协议 5.1 引言 （1）以太坊把出块时间降到了十几秒，这有利于提高系统的througput以及降低了系统反应时间。和比特币的10分钟出块时间
以太坊开发入门
mongo_node的专栏
06-06 1333
目标读者： 专业的程序员；&nbsp; 想深入了解以太坊/区块链及其生态的读者； 如果你已经有一定的以太坊技术基础，只想研究一些落地项目，可以直接跳到后面的项目模块。 预备知识： 了解区块链的概念以及比特币的运行机制。 有基本的编程知识将是极大的加分项，了解系统/架构/数学等知识。 不知你是否和我一样，一开始被各种数学问题所迷惑，如拜占庭问题，双花问题等。我的建议是...
以太坊设计原理
liudaoqiang_tj的博客
08-13 402
原文链接：https://ethfans.org/posts/510 原则 以太坊协议的设计遵循以下几点原则： 1.三明治复杂模型 我们认为以太坊的底层协议应尽可能的简单，接口设计应易于理解，那些不可避免的复杂部分应放入中间层。中间层不是核心共识的一部分，且对最终用户不可见，它包含：高级语言编译器、参数序列化和反序列化脚本、存储数据结构模型、leveldb存储接口以及线路协议等。当然，这样的...
以太坊基础开发入门教程，完整入门【转】
07-09 1855
翻译自：https://medium.com/@mattcondon/getting-up-to-speed-on-ethereum-63ed28821bbe 从入门到精通，干货篇。 必读，如果你： 是一个专业的程序员 如果你想了解以太坊当前可以做到什么程度，通过什么，如何做到。 预备知识： 1. 你需要知道区块链的概念及实现一个无需信任的电子货币的运作原理。可以先看看长版（https://www.youtube.com/watch?v=b...
区块链技术之以太坊ETH白皮书
weixin_44172023的博客
08-15 1862
链客，专为开发者而生，有问必答！ 此文章来自区块链技术社区，未经允许拒绝转载。 基于中本聪区块链比特币1.0之后，天才少年Vitalik Buterin（V神）在2013年年末发布了以太坊白皮书，其实他以前在比特社区是一名活跃分子，更是文章的供稿者，对比特币的见解和不足独到而专业。区块链以太坊2.0是一个运行智能合约的去中心化平台，平台上的运用按照程序设定运行，不存在停机、审查、欺诈、第三方人为...
"ScienceMiles：基于区块链的同行评审激励平台
11830ScienceMiles0研究人员的数字货币0Zeeshan Jan KMI -知识媒体研究所，开放大学米尔顿凯恩斯zeeshan.jan@open.ac.uk0Allan Third KMI -知识媒体研究所，开放大学米尔顿凯恩斯allan.third@open.ac.uk0...
程序员投入时间和精力实现财富增长之道,这可能会伴随你程序员整个生涯(请不要连续点赞)
孙叫兽的博客
08-11 6058
无敌的程序员
叶开|Token的10大设计模式及Token金融与治理（长篇干货）
HiBlock的博客
11-07 3458
作者：叶开 Token经济系统设计方面的先行者。 矩阵数字经济智库合伙人，林达控股（1041HK）执行董事，中农普惠金服董事合伙人，南京大学兼职教授。专注于传统产业升级、产业金融和区块链，著有《社会化媒体运营》、《粉丝经济》、《O2O实践》等相关著作。 专访Token经济设计专家叶开：Token设计画布与10大设计模式 本文叶开老师为大家分享Token的10大设计模式，包括 内容模式、服务模式...
基于以太坊区块链的物联网/IoT设备管理【论文及源码】
跨链技术践行者
07-31 1527
本文介绍一个利用以太坊区块链管理物联网IoT设备的身份识别、 验证和声誉的IoT设备管理系统。该系统使用Web界面在以太坊智能合约 中注册物联网设备，并通过密码学签名消息验证Iot设备对平台的 使用权。 1、区块链物联网设备管理系统的基本概念 物联网/IoT设备的标识： 通过默克尔树（Merkle Tree）的利用，无需暴露设备的私有属性即可完成 IoT设备的注册。使用公钥（或其衍生表示）作为IoT设备的标识ID。 物联网/IoT设备的消息签名与验证： 系统中的每个消息都需要由发送端的IoT设备.
白名单认证 solidity 代码
qq_30346433的博客
03-01 579
视频参考：https://www.youtube.com/watch?v=vYwYe-Gv_XI // SPDX-License-Identifier: MIT pragma solidity ^0.8.10; // 0. message to sign // 1. hash(message) // 2.sign(hash(message),private key) | offchain // 3. ecrecover(hass(message),signature) == sign
微信小程序悬赏系统：设计与实现
"微信小程序悬赏信息发布系统设计与实现" 本文主要探讨了如何使用JSP（JavaServer Pages）技术配合MYSQL数据库来开发一个微信小程序，该小程序致力于悬赏信息的发布和接收。微信小程序悬赏信息发布系统的核心功能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值