cd Payroll
//安装
npm install pm2 -g
//添加软链接
ln -s /usr/local/node-v6.11.1/bin/pm2 /usr/sbin/
//启动payroll在后台 -n 指定名称
pm2 start scripts/start.js -n payroll
//查看运行的应用
pm2 list
//停止所有应用
pm2 stop all

npm install -g truffle

[root@iZuf6h7yd9haonvv70i74oZ ~]# gcc --version
gcc (GCC) 4.4.7 20120313 (Red Hat 4.4.7-18)
Copyright © 2010 Free Software Foundation, Inc.
本程序是自由软件；请参看源代码的版权声明。本软件没有任何担保；
包括没有适销性和某一专用目的下的适用性担保。
[root@iZuf6h7yd9haonvv70i74oZ ~]#

wget http://gcc.skazkaforyou.com/releases/gcc-5.2.0/gcc-5.2.0.tar.bz2

tar -xf gcc-5.2.0.tar.bz2

cd gcc-5.2.0
./contrib/download_prerequisites

mkdir build_temp
cd build_temp
../configure --enable-checking=release --enable-languages=c,c++ --disable-multilib
make

make install

[root@iZuf6h7yd9haonvv70i74oZ build_temp]# ls /usr/local/bin | grep gcc
gcc
gcc-ar
gcc-nm
gcc-ranlib
i686-pc-linux-gnu-gcc
i686-pc-linux-gnu-gcc-5.2.0
i686-pc-linux-gnu-gcc-ar
i686-pc-linux-gnu-gcc-nm
i686-pc-linux-gnu-gcc-ranlib

/usr/sbin/update-alternatives --install  /usr/bin/gcc gcc /usr/local/bin/i686-pc-linux-gnu-gcc-5.2.0 52

/usr/sbin/update-alternatives --install  /usr/bin/g++ g++ /usr/local/bin/g++ 52

[root@iZuf6h7yd9haonvv70i74oZ ~]# gcc --version
gcc (GCC) 5.2.0
Copyright © 2015 Free Software Foundation, Inc.
本程序是自由软件；请参看源代码的版权声明。本软件没有任何担保；
包括没有适销性和某一专用目的下的适用性担保。

[root@iZuf6h7yd9haonvv70i74oZ ~]# g++ --version
g++ (GCC) 5.2.0
Copyright © 2015 Free Software Foundation, Inc.
本程序是自由软件；请参看源代码的版权声明。本软件没有任何担保；
包括没有适销性和某一专用目的下的适用性担保。
[root@iZuf6h7yd9haonvv70i74oZ ~]#

mkdir ETHWalletGenerator
cd ETHWalletGenerator
npm init

npm install secp256k1
npm install keccak

node ethGenerator.js

contract EIP20Interface {
    /* This is a slight change to the ERC20 base standard.
    function totalSupply() constant returns (uint256 supply);
    is replaced with:
    uint256 public totalSupply;
    This automatically creates a getter function for the totalSupply.
    This is moved to the base contract since public getter functions are not
    currently recognised as an implementation of the matching abstract
    function by the compiler.
    */
    /// total amount of tokens
    uint256 public totalSupply;

    /// @param _owner The address from which the balance will be retrieved
    /// @return The balance
    function balanceOf(address _owner) public view returns (uint256 balance);

    /// @notice send `_value` token to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _value) public returns (bool success);

    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
    /// @param _from The address of the sender
    /// @param _to The address of the recipient
    /// @param _value The amount of token to be transferred
    /// @return Whether the transfer was successful or not
    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);

    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _value The amount of tokens to be approved for transfer
    /// @return Whether the approval was successful or not
    function approve(address _spender, uint256 _value) public returns (bool success);

    /// @param _owner The address of the account owning tokens
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens allowed to spent
    function allowance(address _owner, address _spender) public view returns (uint256 remaining);

    // solhint-disable-next-line no-simple-event-func-name
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}

import "./EIP20Interface.sol";


contract EIP20 is EIP20Interface {

    uint256 constant private MAX_UINT256 = 2**256 - 1;
    mapping (address => uint256) public balances;
    mapping (address => mapping (address => uint256)) public allowed;
    /*
    NOTE:
    The following variables are OPTIONAL vanities. One does not have to include them.
    They allow one to customise the token contract & in no way influences the core functionality.
    Some wallets/interfaces might not even bother to look at this information.
    可选的三个变量信息，分别是Token名称，支持小数点经度，通用的都是18位，Token的简称
    */
    string public name;
    uint8 public decimals;
    string public symbol;

    constructor(
        uint256 _initialAmount,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbols
    ) public {
      //发行总量，要根据小数点精确度来计算，比如发行100个，精确度为2，那么就是10 * 10的2次方
        totalSupply = _initialAmount * 10 ** uint256(_decimalUnits); // Update total supply
      //合约创建者默认拥有所有的token
        balances[msg.sender] = totalSupply;                   // Give the creator all initial tokens
        name = _tokenName;                                   // Set the name for display purposes
        decimals = _decimalUnits;                            // Amount of decimals for display purposes
        symbol = _tokenSymbols;                               // Set the symbol for display purposes
    }

    function transfer(address _to, uint256 _value) public returns (bool success) {
        require(balances[msg.sender] >= _value);
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        //发送Transfer消息事件
        emit Transfer(msg.sender, _to, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        uint256 allowance = allowed[_from][msg.sender];
        require(balances[_from] >= _value && allowance >= _value);
        balances[_to] += _value;
        balances[_from] -= _value;
        if (allowance < MAX_UINT256) {
            allowed[_from][msg.sender] -= _value;
        }
        emit Transfer(_from, _to, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function balanceOf(address _owner) public view returns (uint256 balance) {
        return balances[_owner];
    }

    function approve(address _spender, uint256 _value) public returns (bool success) {
        allowed[msg.sender][_spender] = _value;
        emit Approval(msg.sender, _spender, _value); //solhint-disable-line indent, no-unused-vars
        return true;
    }

    function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
}

import "./EIP20.sol";

pragma solidity ^0.4.21;


contract EIP20Factory {

    mapping(address => address[]) public created; //已经创建的token信息
    mapping(address => bool) public isEIP20; //验证一个合约是不是EIP20标准，并不做代码检查
    bytes public EIP20ByteCode; // EIP20标准的合约代码，用来作对比验证的

    constructor() public {
        //upon creation of the factory, deploy a EIP20 (parameters are meaningless) and store the bytecode provably.
        //构造方法，创建一个token，并且存储下来合约的代码
        address verifiedToken = createEIP20(100000000, "TedToken", 18, "TEC");
        EIP20ByteCode = codeAt(verifiedToken);
    }

    //verifies if a contract that has been deployed is a Human Standard Token.
    //NOTE: This is a very expensive function, and should only be used in an eth_call. ~800k gas
    //验证一个已经部署的合约是不是正常标准的token，
    //提示，这个方法相当的消耗gas，至少得需要800k的gas
    function verifyEIP20(address _tokenContract) public view returns (bool) {
        bytes memory fetchedTokenByteCode = codeAt(_tokenContract);

        if (fetchedTokenByteCode.length != EIP20ByteCode.length) {
            return false; //clear mismatch
        }

      //starting iterating through it if lengths match
        for (uint i = 0; i < fetchedTokenByteCode.length; i++) {
            if (fetchedTokenByteCode[i] != EIP20ByteCode[i]) {
                return false;
            }
        }
        return true;
    }

    //创建EIP20标准的Token
    function createEIP20(uint256 _initialAmount, string _name, uint8 _decimals, string _symbol)
        public
    returns (address) {

        EIP20 newToken = (new EIP20(_initialAmount, _name, _decimals, _symbol));
        created[msg.sender].push(address(newToken));
        isEIP20[address(newToken)] = true;
        //the factory will own the created tokens. You must transfer them.
        //重要提示：如果通过工具类创建的token，默认所有的Token拥有者是工具类合约，所以一定要转出来
        newToken.transfer(msg.sender, (_initialAmount - 100) * 10 ** uint256(_decimals));
        return address(newToken);
    }

    //for now, keeping this internal. Ideally there should also be a live version of this that
    // any contract can use, lib-style.
    //retrieves the bytecode at a specific address.
    function codeAt(address _addr) internal view returns (bytes outputCode) {
        assembly { // solhint-disable-line no-inline-assembly
            // retrieve the size of the code, this needs assembly
            let size := extcodesize(_addr)
            // allocate output byte array - this could also be done without assembly
            // by using outputCode = new bytes(size)
            outputCode := mload(0x40)
            // new "memory end" including padding
            mstore(0x40, add(outputCode, and(add(add(size, 0x20), 0x1f), not(0x1f))))
            // store length in memory
            mstore(outputCode, size)
            // actually retrieve the code, this needs assembly
            extcodecopy(_addr, add(outputCode, 0x20), 0, size)
        }
    }
}

#!/usr/bin/python
class O(object):
    def echo(self):
        print "I am class_O"

class A(O):
    pass

class B(O):
    pass

class C(O):
    pass

class K1(B,A):
    def echo(self):
        print "I am class_K1"

class K2(C,A):
    pass

class Z(K2,K1):
    pass

L(O) := [O]
L(A) := [A] + merge(L(O), [O])
      = [A] + merge([O], [O])
      = [A, O]

L(B) := [B, O]//计算过程类似L(A)
L(C) := [C, O]//计算过程类似L(A)

L(K1) := [K1] + merge(L(B), L(A), [B, A])
       = [K1] + merge([B, O], [A, O], [B, A])
       //取一个序列的第一个元素，是其他序列中的第一个元素，或不在其他序列出现，符合条件是B
       = [K1, B] + merge([O], [A, O], [A])
       = [K1, B, A] + merge([O], [O])
       = [K1, B, A, O]

 L(K2) := [K2, C, A, O]//计算过程类似L(K1)

 L(Z) := [Z] + merge(L(K2), L(K1), [K2, K1])
       = [Z] + merge([K2, C, A, O], [K1, B, A, O], [K2, K1])
       = [Z, K2] + merge([C, A, O], [K1, B, A, O], [K1])
       = [Z, K2, C] + merge([A, O], [K1, B, A, O], [K1])
       = [Z, K2, C, K1] + merge([A, O], [B, A, O])
       = [Z, K2, C, K1, B] + merge([A, O], [A, O])
       = [Z, K2, C, K1, B, A] + merge([O], [O])
       = [Z, K2, C, K1, B, A, O]

print Z.__mro__

$ npm install -g ganache-cli truffle

$ testrpc

ted@MacBook-Pro  ~  mkdir SmartContact
ted@MacBook-Pro  ~  cd SmartContact
ted@MacBook-Pro  ~/SmartContact  mkdir HelloWorld
ted@MacBook-Pro  ~/SmartContact  cd HelloWorld
ted@MacBook-Pro  ~/SmartContact/HelloWorld  truffle init
Downloading...
Unpacking...
Setting up...
Unbox successful. Sweet!

Commands:

  Compile:        truffle compile
  Migrate:        truffle migrate
  Test contracts: truffle test

ted@MacBook-Pro  ~/SmartContact/HelloWorld  ls
contracts         migrations        test              truffle-config.js truffle.js

pragma solidity ^0.4.4;

contract HelloWorld {
  function sayHello() internal pure returns (string) {
    retrun ("Hello World");
  }
}

ted@MacBook-Pro  ~/SmartContract/HelloWorld  truffle compile
Compiling ./contracts/HelloWorld.sol...
Compiling ./contracts/Migrations.sol...
Writing artifacts to ./build/contracts

var HelloWorld = artifacts.require("HelloWorld");

module.exports = function(deployer) {
  deployer.deploy(HelloWorld);
};

 ted@MacBook-Pro  ~/SmartContract/HelloWorld  truffle migrate
Using network 'development'.

Running migration: 1_initial_migration.js
  Deploying Migrations...
  ... 0x3bcee88795e7c924e37cafbc8d45ac4c1366027046b0a862c1eedaef7f52b766
  Migrations: 0xf2922d5da87b0b1db38fa3b97f7f14c8f7addf8a
Saving artifacts...
Running migration: 2_deploy_contracts.js
  Deploying HelloWorld...
  ... 0xda4bed7b7f31caaec9648419fd3cbe92e080c42929e6afdcfd4b113ccd64cbd9
  HelloWorld: 0x58e311f91cae06f7e7d1e86fb8252d5f58c3f5c0
Saving artifacts...
 ted@MacBook-Pro  ~/SmartContract/HelloWorld 

ted@MacBook-Pro  ~/SmartContract/HelloWorld  truffle console

truffle(development)> HelloWorld.deployed().then(instance => contract = instance)
TruffleContract {
//此处省略很多输出内容
//调用sayHello 方法
truffle(development)> contract.sayHello.call()
'Hello World & Ted'

HelloWorld.deployed().then(instance => contract = instance)

HelloWorld.deployed().then(instance => {
    contract = instance
});

HelloWorld.deployed().then(function(instance) {
  hello = instance;
});

geth --datadir data --networkid 12 --rpc --rpccorsdomain "*" --port 33040  console

open -a /Applications/Mist.app --args --rpc /Users/ted/Private/data/geth.ipc

{
"config": {
        "chainId": 123456,
        "homesteadBlock": 0,
        "eip155Block": 0,
        "eip158Block": 0
},
"nonce": "0x0000000000000042",
"difficulty": "0x020000",
"mixhash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"coinbase": "0x0000000000000000000000000000000000000000",
"timestamp": "0x00",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
"gasLimit": "0x4c4b40",
"alloc": {}
}

> personal.newAccount() //创建A账户
Passphrase:
Repeat passphrase:
"0x9d28685f89f56025636a9664ced22befc5d2cf1b"
> personal.newAccount() //创建B账户
Passphrase:
Repeat passphrase:
"0x58b61b8c168e2610cec0081cc6456cb7cd87e7ba"
> eth.accounts //查看所有账户信息
["0x9d28685f89f56025636a9664ced22befc5d2cf1b", "0x58b61b8c168e2610cec0081cc6456cb7cd87e7ba"]
> miner.setEtherbase(eth.accounts[0]) //指定A账户为矿工
true
> eth.coinbase //查看矿工是谁
"0x9d28685f89f56025636a9664ced22befc5d2cf1b"
> miner.start(1) //使用1个线程开始挖矿，第一次挖矿需要时间较长，大概5分钟左右
//直到屏幕出现“🔨 mined potential block number=1 hash=f53358…85e38a”信息时说明挖出矿了
> miner.stop() //停止挖矿
> eth.getBalance(eth.accounts[0]) //查看A账户的余额
125000000000000000000
> eth.getBalance(eth.accounts[1]) //查看B账户的余额
0
> personal.unlockAccount(eth.accounts[0]) //解锁A账户，方便后面转账
Unlock account 0x9d28685f89f56025636a9664ced22befc5d2cf1b
> amount = web3.toWei(5,'ether') //设定转账额度
"5000000000000000000"
> eth.sendTransaction({from:eth.accounts[0],to:eth.accounts[1],value:amount}) //执行转账操作
INFO [12-20|17:51:11] Submitted transaction //输出信息省略
> txpool.status //查看交易池的状态，因为没人挖矿，所以有一笔记录阻塞
{
  pending: 1,
  queued: 0
}
> miner.start(1);admin.sleepBlocks(1);miner.stop(); //重新开始挖矿，挖出一个区块即可停止
> eth.getBalance(eth.accounts[1]) //查看B账户余额，如果有余额，则转账成功
5000000000000000000
> web3.fromWei(eth.getBalance(eth.accounts[1]),'ether')
5