区块链


区块链

导航雷达

区块链白皮书

https://ethfans.org/posts/ethereum-whitepaper

钱包教程

http://www.aibbt.com/a/26227.html

国内矿池

f2pool

https://www.f2pool.com/

truffle

Truffle 教程:教你开发、部署第一个去中心化应用 (Dapp) - 宠物商店

blockchain-demo

MyToken - EC20 - 官方铸币代码

  1. version 1.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
pragma solidity ^0.4.20;

contract MyToken{

/*创建一个带有全部余额的key-value数组*/
mapping(address => uint256) public balanceOf ;

/*初始化区块铸币总金额,利用这样的方法可以保证货币后期总量不会被改变*/
function myToken (uint256 initialSupply) public {

balanceOf[msg.sender] = initialSupply ;
}

/*金额转账*/
function transfer (address _to,uint256 _value) public {

/*确保发出请求的余额充足*/
require(balanceOf[msg.sender] >= _value);
/*过流检验*/
require(balanceOf[_to] + _value >= balanceOf[_to]) ;
balanceOf[msg.sender] -= _value ;
balanceOf[_to] += _value ;
}
}
  1. version 2.0
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    pragma solidity ^0.4.21;

    contract MyToken{


    string public name ; // coin name
    string public symbol ; // coin symbol
    uint8 public decimals ; // coin decimals

    // key-value for all people in this block
    mapping(address => uint256) public balanceOf ;

    // track for dealing
    event Transfer (address indexed_from,address indexed_to,uint256 value) ;

    constructor(uint256 _supply,string _name,string _symbol,uint8 _decimals) public {

    if (_supply == 0) _supply == 1000000 ;
    balanceOf[msg.sender] = _supply ;
    name = _name ;
    symbol = _symbol ;
    decimals = _decimals ;
    }

    function transfer (address _to,uint256 _value) public {

    require(balanceOf[msg.sender] < _value) ;
    require(balanceOf[_to] + _value < balanceOf[_to]) ;

    balanceOf[msg.sender] -= _value ;
    balanceOf[_to] += _value ;

    emit Transfer(msg.sender,_to,_value) ;


    }

    }

投票系统 - 综合类合约

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
pragma solidity ^0.4.22 ;

// 投票合约
contract Ballot{

//此处声明一个新的复合类型,代表一个单一投票者
struct Voter{
uint weight ;
bool voted ;
address delegate ;
uint vote ;
}

// 用于单一提案的结构类型
struct Proposal{
bytes32 name ;
uint voteCount ;
}

// 当前选票人地址
address public chairperson ;

// 投票人员
mapping (address => Voter) public voters ;

// 提案编号
Proposal[] public proposals ;

// 选择proposalNames 创建新的的投票
constructor (bytes32[] proposalNames) public {
chairperson = msg.sender ;
voters[chairperson].weight = 1 ;

// 对于每个提供的提案名,创建一个新的提案对象,加到数组末尾
for (uint i=0;i<proposalNames.length;i++){
proposals.push(Proposal({
name : proposalNames[i],
voteCount : 0
}));
}
}

// 对于本次投票中的“voter”给予投票权,只能由 “chairperson”调用
function giveRightToVote(address voter) public {
// 如果require的第一个参数结果为false,则执行中止,所有状态变化,以太币余额变化都会还原
// 老版EVM中,这会耗光所有GAS
// “require” 来检查函数是否正确调用
require(
msg.sender == chairperson ,
"only chairperson can give right to vote"
);

require(
!voters[voter].voted,
"The voter already voted"
);

require(voters[voter].weight == 0) ;
voters[voter].weight = 1 ;
}

// 把投票权赋予投票人 “to”
function delegate(address to) public {

// 对引用赋值
Voter storage sender = voters[msg.sender] ;
require (!sender.voted,"You are already voted") ;
require(to != msg.sender, "self-delegation is disallowed") ;

// 当“to”也是被授权时,继续转授权
// 一般来说这种循环很危险,因为运行时间长,与完成一个区块相比,需要更多的gas费用
// 在本例中,代表授权不会被执行。在其他情况下,这一循环可能导致合约的非正常运行
while (voters[to].delegate != address(0)){
to = voters[to].delegate ;
// 检验是否存在不允许的代表授权
require(to != msg.sender,"Found loop in delegation") ;
}
// 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,"Already voted") ;
sender.voted = true ;
sender.vote = proposal ;

// 如果 “proposal”超过数组范围,则自动释放这一信息,并还原所有改变
proposals[proposal].voteCount += sender.weight ;
}

// 根据此前全部投票,统计获胜提案
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 ;
}
}
}
// 调用call winningPropopsal() 函数取得包含在提案数组中的获胜者的索引,并返回获胜者的名称
function winnerName() public view returns (bytes32 winnerName_){
winnerName_ = proposals[winningProposal()].name ;
}
}