根据例子学习Solidity-Solidity官方文档(3)

Solidity 介绍 智能合约(Smart contract )是一种旨在以信息化方式传播验证或执行合同的计算机协议。智能合约允许在没有第三方的情况下进行可信交易,这些交易可追踪且不可逆转。智能合约概念于1995年由Nick Szabo首次提出。智能合约的目的是提供优于传统合约的安全方法,并减少与合约相关的其他交易成本。简单地说,智能合约可以理解为一个自执行的协议。智能合约可以自动处理协议的履行、管理、以及支付。 阅读详情

image

写在前面:HiBlock区块链社区成立了翻译小组(以太坊中文社区),翻译区块链相关的技术文档及资料,本文为Solidity官方文档翻译的第三部分《根据例子学习Solidity》,特发布出来邀请solidity爱好者、开发者做公开的审校,您可以添加微信baobaotalk_com,验证输入“solidity”,然后将您的意见和建议发送给我们,也可以在文末“留言”区留言,有效的建议我们会采纳及合并进下一版本,同时将送一份小礼物给您以示感谢。

1

投 票

以下的合约相当复杂,但展示了很多Solidity的功能。它实现了一个投票合约。 当然,电子投票的主要问题是如何将投票权分配给正确的人员以及如何防止被操纵。 我们不会在这里解决所有的问题,但至少我们会展示如何进行委托投票,同时,计票又是自动和完全透明的 。

我们的想法是为每个(投票)表决创建一份合约,为每个选项提供简称。 然后作为合约的创造者——即主席,将给予每个独立的地址以投票权。

地址后面的人可以选择自己投票,或者委托给他们信任的人来投票。

在投票时间结束时,winningProposal() 将返回获得最多投票的提案。

pragma solidity ^0.4.16;

/// @title 委托投票

contract Ballot {
* // 这里声明了一个新的复合类型用于稍后的变量*
* // 它用来表示一个选民*
* struct* Voter {
uint weight;* // 计票的权重*
* bool* voted; // 若为真,代表该人已投票
address delegate; // 被委托人
* uint* vote; // 投票提案的索引
}

  • // 提案的类型*
    struct Proposal {
    bytes32 name; // 简称(最长32个字节)
    * uint* voteCount; // 得票数
    }

    * address* public chairperson;

  • // 这声明了一个状态变量,为每个可能的地址存储一个 Voter。*
    mapping(address => Voter) public voters;

    • // 一个 Proposal 结构类型的动态数组*
      Proposal[] public proposals;

    /// 为 proposalNames 中的每个提案,创建一个新的(投票)表决
    function Ballot(bytes32[] proposalNames) public {
    chairperson = msg.sender;
    voters[chairperson].weight = 1;

    • //对于提供的每个提案名称,*
    • //创建一个新的 Proposal 对象并把它添加到数组的末尾。*
      * for* (uint i = 0; i < proposalNames.length; i**++**) {
      • // Proposal({...}) 创建一个临时 Proposal 对象,*
      • // proposals.push(...) 将其添加到 proposals 的末尾*
        proposals.push(Proposal({
        name: proposalNames[i],
        voteCount: 0
        }));
        }
        }

    *// 授权 voter 对这个(投票)表决进行投票
    // 只有 chairperson 可以调用该函数。*
    * function* giveRightToVote(address voter) public {

    • // 若 require 的入参判定为 false,
      // 则终止函数,恢复所有对状态和以太币账户的变动,并且也不会消耗 gas 。
      // 如果函数被错误的调用,使用require,将是一个很好的选择。*
      require(
      (msg.sender == chairperson) &&
      !voters[voter].voted &&
      (voters[voter].weight == 0)
      );
      voters[voter].weight = 1;
      }

    /// 把你的投票委托到投票者 to。
    function delegate(address to) public {

    • // 传引用*
      Voter storage sender = voters[msg.sender];
      require(**!**sender.voted);

      • // 委托给自己是不允许的*
        require(to** !=** msg.sender);

      • // 委托是可以传递的,只要被委托者 to 也设置了委托。
        // 一般来说,这种循环委托是危险的。因为,如果传递的链条太长,
        // 则可能需消耗的gas要多于区块中剩余的(大于区块设置的gasLimit),
        // 这种情况下,委托不会被执行。
        // 而在另一些情况下,如果形成闭环,则会让合约完全卡住。*
        while (voters[to].delegate != address(0)) {
        to = voters[to].delegate;

        • // 不允许闭环委托*
          require(to != msg.sender);
          }
      • // sender 是一个引用, 相当于对 voters[msg.sender].voted 进行修改*
        sender.voted = true;
        sender.delegate = to;
        Voter storage delegate_ = voters[to];
        if (delegate_.voted) {

        • // 若被委托者已经投过票了,直接增加得票数*
          proposals[delegate_.vote].voteCount += sender.weight;
          } else {
        • // 若被委托者还没投票,增加委托者的权重*
          delegate_.weight += sender.weight;
          }
          }
  • /// 把你的票(包括委托给你的票),
    /// 投给提案 proposals[proposal].name.*
    function vote(uint proposal) public {
    Voter storage sender = voters[msg.sender];
    require(**!**sender.voted);
    sender.voted = true;
    sender.vote = proposal;

    • // 如果 proposal 超过了数组的范围,则会自动抛出异常,并恢复所有的改动*
      proposals[proposal].voteCount** +=** sender.weight;
      }

    /// @dev 结合之前所有的投票,计算出最终胜出的提案
    * function* winningProposal() public view
    * returns* (uint winningProposal_)
    {
    * uint* winningVoteCount = 0;
    * for* (uint p = 0; p < proposals.length; p**++**) {
    * if* (proposals[p].voteCount > winningVoteCount) {
    winningVoteCount = proposals[p].voteCount;
    winningProposal_ = p;
    }
    }
    }

    // 调用 winningProposal() 函数以获取提案数组中获胜者的索引,并以此返回获胜者的名称
    * function* winnerName() public view
    * returns* (bytes32 winnerName_)
    {
    winnerName_ **= **proposals[winningProposal()].name;
    }

}

可能的优化

当前,为了把投票权分配给所有参与者,需要执行很多交易。你有没有更好的主意?

2

秘密竞拍(盲拍)

在本节中,我们将展示如何轻松地在以太坊上创建一个秘密竞价的合约。 我们将从公开拍卖开始,每个人都可以看到出价,然后将此合约扩展到盲拍合约, 在竞标期结束之前无法看到实际出价。

简单的公开拍卖

以下简单的拍卖合约的总体思路是每个人都可以在投标期内发送他们的出价。 出价已经包含了资金/以太币,来将投标人与他们的投标绑定。 如果最高出价提高了(被其他出价者的出价超过),之前出价最高的出价者可以拿回她的钱。 在投标期结束后,受益人需要手动调用合约来接收他的钱 - 合约不能自己激活接收。

pragma solidity ^0.4.21;

contract SimpleAuction {
* // 拍卖的参数。*
address public beneficiary;
* // 时间是unix的绝对时间戳(自1970-01-01以来的秒数)
// 或以秒为单位的时间段。*
uint public auctionEnd;

  • // 拍卖的当前状态*
    * address* public highestBidder;
    uint public highestBid;

    * //可以取回的之前的出价*
    mapping(address => uint) pendingReturns;

    • // 拍卖结束后设为 true,将禁止所有的变更*
      bool ended;

    • // 变更触发的事件*
      * event* HighestBidIncreased(address bidder, uint amount);
      event AuctionEnded(address winner, uint amount);

    *// 以下是所谓的 natspec 注释,可以通过三个斜杠来识别。
    // 当用户被要求确认交易时将显示。*

    • /// 以受益者地址 _beneficiary 的名义,
      /// 创建一个简单的拍卖,拍卖时间为 _biddingTime 秒。*
      * function* SimpleAuction(
      * uint* _biddingTime,
      address _beneficiary
      ) public {
      beneficiary = _beneficiary;
      auctionEnd = *now +* _biddingTime;
      }

    */// 对拍卖进行出价,具体的出价随交易一起发送。
    /// 如果没有在拍卖中胜出,则返还出价。*
    * function* bid() public payable {

    • // 参数不是必要的。因为所有的信息已经包含在了交易中。
      // 对于能接收以太币的函数,关键字 payable 是必须的。

      // 如果拍卖已结束,撤销函数的调用。*
      require(now <= auctionEnd);

      • // 如果出价不够高,返还你的钱*
        require(msg.value > highestBid);

      * if* (highestBid != 0) {

      • // 返还出价时,简单地直接调用 highestBidder.send(highestBid) 函数,
        // 是有安全风险的,因为它有可能执行一个非信任合约。
        // 更为安全的做法是让接收方自己提取金钱。*
        pendingReturns[highestBidder] += highestBid;
        }
        highestBidder = msg.sender;
        highestBid = msg.value;
        emit HighestBidIncreased(msg.sender, msg.value);
        }
  • /// 取回出价(当该出价已被超越)*
    * function* withdraw() public returns (bool) {
    uint *amount =* pendingReturns[msg.sender];
    ** if (amount > **0) {
    * // 这里很重要,首先要设零值。
    // 因为,作为接收调用的一部分,
    // 接收者可以在 send 返回之前,重新调用该函数。*
    pendingReturns[msg.sender] = 0;

      ** if** (**!**msg.sender.send(amount)) {
          * // 这里不需抛出异常,只需重置未付款*
           pendingReturns[msg.sender] **=** amount;
           **return false;**
       }
    

    }
    * return true;*
    }

    • /// 结束拍卖,并把最高的出价发送给受益人*
      * function* auctionEnd() public {

      • // 对于可与其他合约交互的函数(意味着它会调用其他函数或发送以太币),
        // 一个好的指导方针是将其结构分为三个阶段:
        // 1. 检查条件
        // 2. 执行动作 (可能会改变条件)
        // 3. 与其他合约交互
        // 如果这些阶段相混合,其他的合约可能会回调当前合约并修改状态,
        // 或者导致某些效果(比如支付以太币)多次生效。
        // 如果合约内调用的函数包含了与外部合约的交互,
        // 则它也会被认为是与外部合约有交互的。

      // 1. 条件*
      require(now >= auctionEnd); // 拍卖尚未结束
      require(*!**ended); // 该函数已被调用*

      • // 2. 生效*
        ended = true;
        emit AuctionEnded(highestBidder, highestBid);
    • // 3. 交互*
      beneficiary.transfer(highestBid);
      }

}

秘密竞拍(盲拍)

之前的公开拍卖接下来将被扩展为一个秘密竞拍。 秘密竞拍的好处是在投标结束前不会有时间压力。 在一个透明的计算平台上进行秘密竞拍听起来像是自相矛盾,但密码学可以实现它。

在 投标期间 ,投标人实际上并没有发送她的出价,而只是发送一个哈希版本的出价。 由于目前几乎不可能找到两个(足够长的)值,其哈希值是相等的,因此投标人可通过该方式提交报价。 在投标结束后,投标人必须公开他们的出价:他们不加密的发送他们的出价,合约检查出价的哈希值是否与投标期间提供的相同。

另一个挑战是如何使拍卖同时做到 绑定和秘密 : 唯一能阻止投标者在她赢得拍卖后不付款的方式是,让她将钱连同出价一起发出。 但由于资金转移在 以太坊Ethereum 中不能被隐藏,因此任何人都可以看到转移的资金。

下面的合约通过接受任何大于最高出价的值来解决这个问题。 当然,因为这只能在披露阶段进行检查,有些出价可能是 无效 的, 并且,这是故意的(与高出价一起,它甚至提供了一个明确的标志来标识无效的出价): 投标人可以通过设置几个或高或低的无效出价来迷惑竞争对手。

pragma solidity ^0.4.21;

contract BlindAuction {
struct Bid {
bytes32 blindedBid;
uint deposit;
}

address public beneficiary;
uint** public** biddingEnd;
* uint*** public** revealEnd;
bool** public** ended;

* mapping*(address => Bid[]) **public **bids;

address public highestBidder;
* uint* **public **highestBid;

// 可以取回的之前的出价
mapping(address =>* uint*) pendingReturns;

event AuctionEnded(address winner, uint highestBid);

  • /// 使用 modifier 可以更便捷的校验函数的入参。
    /// onlyBefore 会被用于后面的 bid 函数:
    /// 新的函数体是由 modifier 本身的函数体,并用原函数体替换 _; 语句来组成的。*
    modifier onlyBefore(uint **_time) { require(now < **_time); _; }
    modifier onlyAfter(uint time) { require(now > _time); ; }

    * function* BlindAuction(
    uint _biddingTime,
    ** uint **_revealTime,
    address _beneficiary
    ) public {
    beneficiary = _beneficiary;
    biddingEnd = now + _biddingTime;
    revealEnd = biddingEnd + _revealTime;
    }

    • /// 可以通过 _blindedBid = keccak256(value, fake, secret)
      /// 设置一个秘密竞拍。
      /// 只有在出价披露阶段被正确披露,已发送的以太币才会被退还。
      /// 如果与出价一起发送的以太币至少为 “value” 且 “fake” 不为真,则出价有效。
      /// 将 “fake” 设置为 true ,然后发送满足订金金额但又不与出价相同的金额是隐藏实际出价的方法。
      /// 同一个地址可以放置多个出价。*
      function bid(bytes32 _blindedBid)
      ** public
      payable**
      onlyBefore(biddingEnd)
      {
      bids[msg.sender].push(Bid({
      blindedBid: _blindedBid,
      deposit: msg.value
      }));
      }

    • /// 披露你的秘密竞拍出价。
      /// 对于所有正确披露的无效出价以及除最高出价以外的所有出价,你都将获得退款。*
      * function* reveal(
      uint[] _values,
      * bool*[] _fake,
      * bytes32*[] _secret
      )
      public
      onlyAfter(biddingEnd)
      onlyBefore(revealEnd)
      {
      * uint* length = bids[msg.sender].length;
      require(_values.length == length);
      require(_fake.length == length);
      require(_secret.length == length);

      * uint* refund;
      * for (uint **i = 0; i <* length; i++**) {
      * var* bid = bids[msg.sender][i];
      var (value, fake, secret)* =*
      (_values[i], _fake[i], _secret[i]);
      if (bid.blindedBid != keccak256(value, fake, secret)) {
      * // 出价未能正确披露
      // 不返还订金*
      continue;
      }
      refund += bid.deposit;
      * if* (!*fake &&* bid.deposit >= value) {
      if (placeBid(msg.sender, value))
      refund -= value;
      }

      • // 使发送者不可能再次认领同一笔订金*
        bid.blindedBid** =**bytes32(0);
        }
        msg.sender.transfer(refund);
        }
    • // 这是一个 “internal” 函数, 意味着它只能在本合约(或继承合约)内被调用*
      * function* placeBid(address bidder, uint value) internal
      ** returns (**bool success)
      {
      * if* (value <= highestBid) {
      * return false;*
      }
      * if* (highestBidder != 0) {

      • // 返还之前的最高出价*
        pendingReturns[highestBidder] += highestBid;
        }
        highestBid = value;
        highestBidder = bidder;
        * return true;*
        }
    • /// 取回出价(当该出价已被超越)*
      function withdraw() public {
      * uint* amount = pendingReturns[msg.sender];
      * if* (amount > 0) {

      • // 这里很重要,首先要设零值。
        // 因为,作为接收调用的一部分,
        // 接收者可以在 transfer 返回之前重新调用该函数。(可查看上面关于‘条件 -> 影响 -> 交互’的标注)*
        pendingReturns[msg.sender] = 0;

        msg.sender.transfer(amount);
        }
        }

  • /// 结束拍卖,并把最高的出价发送给受益人*
    * function* auctionEnd()
    public
    onlyAfter(revealEnd)
    {
    require(**!**ended);
    emit AuctionEnded(highestBidder, highestBid);
    ended = true;
    beneficiary.transfer(highestBid);
    }

安全的远程购买

pragma solidity ^0.4.21;

contract Purchase {
** uint **public value;
address** public** seller;
** address **public buyer;
enum State { Created, Locked, Inactive }
State public state;

  • //确保 msg.value 是一个偶数。
    //如果它是一个奇数,则它将被截断。
    //通过乘法检查它不是奇数。*
    * function* Purchase() public payable {
    seller = msg.sender;
    value = msg.value / 2;
    require((2** * value) ==** msg.value);
    }

    modifier condition(bool _condition) {
    require(_condition);
    _;
    }

    modifier onlyBuyer() {
    require(msg.sender** ==** buyer);
    _;
    }

    modifier onlySeller() {
    require(msg.sender **== **seller);
    _;
    }

    modifier inState(State _state) {
    require(state == _state);
    _;
    }

    event Aborted();
    ** event **PurchaseConfirmed();
    ** event **ItemReceived();

  • ///中止购买并回收以太币。
    ///只能在合约被锁定之前由卖家调用。*
    function abort()
    * public*
    onlySeller
    inState(State.Created)
    {
    emit Aborted();
    state = State.Inactive;
    seller.transfer(this.balance);
    }

  • /// 买家确认购买。
    /// 交易必须包含 2 * value 个以太币。
    /// 以太币会被锁定,直到 confirmReceived 被调用。*
    * function* confirmPurchase()
    public
    inState(State.Created)
    condition(msg.value == (2 * value))
    * payable*
    {
    emit PurchaseConfirmed();
    buyer = msg.sender;
    state = State.Locked;
    }

    */// 确认你(买家)已经收到商品。
    /// 这会释放被锁定的以太币。*
    * function* confirmReceived()
    * public*
    onlyBuyer
    inState(State.Locked)
    {
    emit ItemReceived();

    • // 首先修改状态很重要,否则的话,由 transfer 所调用的合约可以回调进这里(再次接收以太币)。*
      state = State.Inactive;

      • // 注意: 这实际上允许买方和卖方阻止退款 - 应该使用取回模式。*
        buyer.transfer(value);
        seller.transfer(this.balance);
        }

}

微支付通道

To be written.

注:本文为solidity翻译的第三部分《根据例子学习Solidity》,特发布出来邀请solidity爱好者、开发者做公开的审校,您可以添加微信baobaotalk_com,验证输入“solidity”,然后将您的意见和建议发送给我们,也可在文末“留言”区留言,或通过原文链接访问我们的Github。有效的建议我们会收纳并及时改进,同时将送一份小礼物给您以示感谢。

本文内容来源于HiBlock区块链社区翻译小组-以太坊中文社区,感谢全体译者的辛苦工作。

以下是我们的社区介绍,欢迎各种合作、交流、学习:)

image

根据例子学习Solidity 投票例子的部署运行测试 Remix 在线Solidity IDE: https://remix.ethereum.org/   Solidity 学习网站: https://solidity-cn.readthedocs.io/zh/develop/solidity-by-example.html#index-1   投票智能合约例子: https://solidity-cn.readthedocs.io/... 阅读详情

相关推荐

Solidity学习之路(1)——初识Solidity

前言 区块链技术日趋成熟,公司也希望在区块链上有所发展,身为一个上进青年,当然要承担起这个重任。在前端通过使用vue、react与web3.js开发的dapp后,个人对合约的开发越发的感兴趣,既然如此,心动不如行动,那就开始学习吧。在之后的内容中,我将分享我在solidity学习的过程中的每一步,比如遇到的难题,解决的思路等等。希望可以给和我一样刚刚上手的朋友一些帮助。也希望有朋友可以将我理解错误的地方指出。大家互相讨论,共同进步。 正文 1、查找参考文档 身为中国人遇...

ldf_tch的博客 1098

再读Solidity官网文档 1

由于solidity英文描述,所以每次读理解就有点不一样,领会的更多.比如:1. 区块链和交易区块链是一个全局共享的,存储交易的数据库。(精辟) 意味着每个人可以通过加入区块链节点网络读取数据库里面的条目. 如果你想改变数据库里面的某些东西,你不得不创建一个必须被所有其他节点接受的"交易"。交易(Transaction)这个词意味着你想对数据库做的改变要么完全无效,要么被完全接受。进一步说,一旦你的交易被应用到数据库,将不会被其他交易所改变。2.区块。

gridlayout的专栏 1402

【区块链学习最全教程】学习 Solidity,全栈 Web3,Javascript 和区块链开发

Chainlink 开发者社区发布了一个关于全栈 web3,solidity 和区块链开发的完整视频教程。本视频教程由 Chainlink 开发者大使 Patrick Collins 讲解。教程由浅入深讲解了区块链的基础知识,智能合约基础以及流行的开发工具。视频内容覆盖广泛,不论是初学者还是资深工程师,都会从中学习到很多知识。......

ChainlinkO的博客 1870

Solidity 官方文档中文版(一)

中文翻译文档:http://www.tryblockchain.org/Solidity-%E8%AF%AD%E8%A8%80%E4%BB%8B%E7%BB%8D.html英文官方文档:http://solidity.readthedocs.io/en/develop/Solidity是一种智能合约高级语言,运行在Ethereum虚拟机(EVM)之上。Solidity与其它语言相关的特点?它的语法...

xiatiancc的专栏 1万+

Solidity官方文档中文版

以太坊智能合约的高级开发语言Solidity的官方文档的中文版本。必备。

solidity官方文档中文版

github项目合成pdf, 不可用于商业目的,不可用于商业目的。

Solidity一篇就够了

ERC全称是 “”,表示以太坊的意见征求稿,ERC中包含技术和组织等注意事项及标准。这套标准其实不光由以太坊官方提出,还有一些以太坊爱好者提出。是以太坊生态系统中被广泛使用的关键标准。什么叫做代币?彩票卷像美元一样的法定货币在线平台中的信誉积分游戏中一个角色的技能一盎司黄金及更多…ERC-20 提出了一个同质化代币的标准,换句话说,它们具有一种属性,使得每个代币都与另一个代币(在类型和价值上)完全相同。

梅山老妖的博客 1635

ctf.show_VIP题目限免(全)

VIP题目限免源码泄露前台JS绕过手动源码查看ctrl+u或在网站前面加view-source:Burpsuite禁用javascript的方法协议头信息泄露robots后台泄露补phps源码泄露源码压缩包泄露版本控制泄露源码版本控制泄露源码2vim临时文件泄露cookie泄露**注意:用其他浏览器得到的很奇怪** 这题目全英…英语废一个,所以我把题目全部复制过来了 源码泄露 ‎ 您没有访问所请求资源的权限。它要么是受读保护的,要么不能被服务器读取。 题目提示源码…那就找源码吧! 前台JS绕过 提示

BvxiE的博客 6348

Solidity 官方文档中文版(二)

Solidity AssemblySolidity定义了一个汇编语言,可以不同Solidity一起使用。这个汇编语言还可以嵌入到Solidity源码中,以内联汇编的方式使用。下面我们将从内联汇编如何使用着手,介绍其与独立使用的汇编语言的不同,最后再介绍这门汇编语言。文档尚待完善的补充的地方:待补充内联汇编的变量作用域的不同,尤其是使用含internal的函数的库时所引入的复杂度。另外,还需补充,编...

xiatiancc的专栏 9860

科研党必备:用Python+Excel批量下载文献的保姆级教程(附常见错误解决)

本文提供了一套利用Python和Excel实现外文文献批量下载的自动化解决方案。教程详细介绍了如何从数据库导出并清洗DOI信息,编写健壮的Python脚本进行批量下载,并包含错误处理与进阶优化技巧,旨在帮助科研人员将重复性劳动自动化,大幅提升文献收集效率。

weixin_29050513的博客 311

ArcGIS中的Python入门知识点整理

关于Arcpy大家应该都比较熟悉,Python用的好,数据处理快又好!在ArcGIS中ArcPy是一个以成功的arcgisscripting模块为基础并继承了arcgisscripting功能进而构建而成的站点包。目的是为以实用高效的方式通过Python执行地理数据分析、数据转换、数据管理和地图自动化创建基础。ArcPy提供了丰富纯正的Python体验,具有代码自动完成功能。今天我们就看看关于Arcpy相关处理的使用,通过一些简单代码与大家一起认识Arcpy。

xjt921122的博客 1772

Solidity 官方文档中文版(四)

数据位置(Data location)复杂类型,如数组(arrays)和数据结构(struct)在Solidity中有一个额外的属性,数据的存储位置。可选为memory和storage。memory存储位置同我们普通程序的内存一致。即分配,即使用,越过作用域即不可被访问,等待被回收。而在区块链上,由于底层实现了图灵完备,故而会有非常多的状态需要永久记录下来。比如,参与众筹的所有参与者。那么我们就要...

xiatiancc的专栏 4316

Robosuite实战:通过Xbox手柄实现机械臂6-DoF精准控制的完整指南

本文详细介绍了如何通过Xbox手柄实现机械臂的6-DoF精准控制,结合Robosuite仿真环境与MuJoCo物理引擎,提供从环境配置到代码实现的完整指南。文章重点解析了手柄映射原理、核心控制代码以及数据采集优化技巧,帮助开发者高效完成机械臂控制任务。

weixin_29169505的博客 421

Solidity官方文档:根据例子学习Solidity

最近加入了Solidity的官方文档的中文翻译小组,以下是我们翻译的文章,可到我们的官网查看最新的更新:https://solidity-cn.readthedocs.io/zh/develop根据例子学习Solidity投票以下的合约相当复杂,但展示了很多Solidity的功能。它实现了一个投票合约。 当然,电子投票的主要问题是如何将投票权分配给正确的人员以及如何防止被操纵。 我们不会在这里解决

点火三周的专栏 1654

瑞芯微RK3576上手实测:8nm新U配6TOPS NPU,做AIoT项目选它还是RK3588/RK3568?

本文深度评测瑞芯微RK3576芯片在中高端AIoT项目中的表现,对比RK3588和RK3568的性能差异。RK3576采用8nm工艺,配备6TOPS NPU,在解码能力、AI推理效率和功耗控制方面表现均衡,是中端项目的黄金选择。实测数据显示其在多路视频解码和AI加速性能上优势明显,特别适合智能摄像头和工业HMI设备。

weixin_42627853的博客 721

用python提取PDF中各类文本内容的方法

用python提取PDF中各类文本内容的方法

安静的软件工程师 6089

手把手教你学习Solidity|Solidity开发【一】

从零教你学习Solidity智能合约开发

BUG设计师 5234

【Segment Anything Model】十(1):利用SAM做分类任务,方法二,不放过SAM强大特征提取能力,将SAM提取到的ImageEmbedding插入到其他cnn网络中

直接黏贴复制就好'''该类定义了VGG-16的基本结构。features: 代表VGG网络的主体部分,即所有的卷积层和池化层。avgpool: 是自适应平均池化层,将特征图大小调整为7x7。classifier: 是VGG网络的分类部分,由全连接层组成。_initialize_weights(): 初始化权重的方法。

cvxiayixiao的博客 3563

Solidity入门学习笔记3-根据例子学习Solidity-秘密竞拍

//摘自:https://solidity-cn.readthedocs.io/zh/develop/solidity-by-example.html#voting //案例:简单公开拍卖 //结构:每个人都可在投标期内报价,出价包含了以太币,币与出价人绑定,当出现更高出价,币返还, //投标结束后,受益人需要手动调用合约接收他的钱,合约并不能自己激活接收 pragma solidity ^0.4.22; contract SimpleAuction { // 拍卖的参数。 //该参.

的博客 397

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain&#39;s apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath(&#39;DeepLearnToolbox&#39;));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand(&#39;state&#39;,0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W&#39;); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand(&#39;state&#39;,0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = &#39;sigm&#39;;%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, &#39;Too big error&#39;);```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand(&#39;state&#39;,0)sae = saesetup([784 100]);sae.ae{1}.activation_function = &#39;sigm&#39;;sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)&#39;)% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;;nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, &#39;Too big error&#39;);```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x&#39;,28,28,60000))/255;test_x = double(reshape(test_x&#39;,28,28,10000))/255;train_y = double(train_y&#39;);test_y = double(test_y&#39;);%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you&#39;ll get around 1.2% errorrand(&#39;state&#39;,0)cnn.layers = { struct(&#39;type&#39;, &#39;i&#39;) %input layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 6, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %sub sampling layer struct(&#39;type&#39;, &#39;c&#39;, &#39;outputmaps&#39;, 12, &#39;kernelsize&#39;, 5) %convolution layer struct(&#39;type&#39;, &#39;s&#39;, &#39;scale&#39;, 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, &#39;Too big error&#39;);```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, &#39;Too big error&#39;);%% ex2 neural net with L2 weight decayrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex3 neural net with dropoutrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex4 neural net with sigmoid activation functionrand(&#39;state&#39;,0)nn = nnsetup([784 100 10]);nn.activation_function = &#39;sigm&#39;; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex5 plotting functionalityrand(&#39;state&#39;,0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = &#39;softmax&#39;; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand(&#39;state&#39;,0)nn = nnsetup([784 20 10]); nn.output = &#39;softmax&#39;; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, &#39;Too big error&#39;);```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Solidity语言详解

Solidity语言学习学习总结 关于solidity语言我们从三个方面来学习,分别从 文件结构 数据类型 错误处理(独特) 我们在学习一门新语言的时候,通常从基础语法到函数,再到文件、结构体进行学习,最后深入到框架。以上三个点是solidity语言区别于其他语言的三个显著点,所以提出来着重讲。 这是solidity官方文档:https://learnblockchain.cn/docs/solidity/installing-solidity.html#remix 一、合约文件剖析 1.1一个合约文件

令狐_JackieHao的博客 3万+

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Solidity——速通学习

这一讲,我们介绍了什么是函数选择器selector),它和msg.data函数签名的关系,以及如何使用它调用目标函数。在这一讲,我们介绍了如何在Solidity使用try-catch只能用于外部合约调用和合约创建。如果try执行成功,返回变量必须声明,并且与返回的变量类型相同。

qq_46573670的博客 2629

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

官方统计2023年收入最高的编程语言:Solidity学习入门指南:看这一篇就够了 前置工作的方法全部在这里

Solidity:Solidity是一种面向合约的高级编程语言,主要用于编写区块链网络上的智能合约。在2023年的薪资排行榜中,Solidity以平均年薪18.8万美元(约合137万元人民币)的高薪位列第一 测试币领取 这里是常见水龙头的整理 打开网站 翻译一下 然后输入对应的账户 直接就能领取

终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路 2万+

solidity学习——CryptoZombies

合约开发流程:合约代码编写(Solidity)-> 合约编译(solc)-> 合约部署(web3)

m0_60684612的博客 1855
上一篇: 这是全球最权威的区块链行业报告(附中文完整版下载手册)
下一篇: TrueBit白皮书解读
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值