深入理解以太坊区块链的token

interface ERC20 {
    // 方法
    function name() view returns (string name);
    function symbol() view returns (string symbol);
    function decimals() view returns (uint8 decimals);

    function totalSupply() view returns (uint256 totalSupply);
    function balanceOf(address _owner) view returns (uint256 balance);
    function transfer(address _to, uint256 _value) returns (bool success);
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
    function approve(address _spender, uint256 _value) returns (bool success);
    function allowance(address _owner, address _spender) view returns (uint256 remaining);

    // 事件
    event Transfer(address indexed_from, address indexed_to, uint256 _value);
    event Approval(address indexed_owner, address indexed_spender, uint256 _value);
}

contract DetailedERC20 is ERC20 {

    using SafeMath for uint256;
    mapping(address => uint256) public balances;
    mapping(address => mapping(address => uint256)) internal allowed;
    
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply_;
    constructor(string _name, string _symbol, uint8 _decimals) public {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }
    function totalSupply() public view returns (uint256) {
        return totalSupply_;
    }
    function transfer(address _to, uint256 _value) public returns (bool) {
        // 做相关的合法验证
        require(_to != address(0));
        require(_value <= balances[msg.sender]);
        // msg.sender余额中减去额度，_to余额加上相应额度
        balances[msg.sender] = balances[msg.sender].sub(_value);
        balances[_to] = balances[_to].add(_value);
        // 触发Transfer事件
        emit Transfer(msg.sender, _to, _value);
        return true;
    }
}

Transfer(address from, address to,uint256 value)

Approval(address owner, address spender,uint256 value)

contract ERC20 {
  //**********9个函数**********
  //1.代币的名字，如："黑马币"
  function name() constant public returns (string name);
  //2.代币的简称，例如：HMB
  function symbol() public constant returns (string symbol);
  //3.代币的最小分割量 token使用的小数点后几位。比如如果设置为3，就是支持0.001表示function decimals() public constant returns (uint8 decimals);
  //4.token的总量
  function totalSupply() public constant returns (uint totalSupply);
  //5.余额 返回某个地址(账户)的账户余额
  function balanceOf(address _owner) public constant returns (uint balance);
  //6.转账交易代币 从消息发送者账户中往_to账户转数量为_value的token，从代币合约的调用者地址上转移_value的数量token到地址_to【注意:并且必须触发transfer事件】*/
  function transfer(address _to, uint _value) public returns (bool success);
  //7.两个地址转账从账户_from中往账户_to转数量为_value的token，与approve方法配合使用从地址_from发送数量为_value的tokent到地址_to【注意:并且必须触发transfer事件】
  transferFrom方法用于允许合约代理某人转移token。条件是从账户必须经过了approve。*/
  function transferFrom(address _from, address _to, uint _value) public returns (bool success);
  //8.批准_spender能从合约调用账户中转出数量为_value的token
  function approve(address _spender, uint _value) public returns (bool success);
  //9.获取_spender可以从账户_owner中转出token的剩余数量
  function allowance(address _owner, address _spender) public constant returns (uint remaining);
  //**********2个事件**********
  //1.发生转账时必须要触发的事件，transfer 和 transferFrom 成功执行时必须触发的事件event Transfer(address indexed _from, address indexed _to, uint _value);
  //2.当函数approve(address _spender, uint256 _value)成功执行时必须触发的事件event 	Approval(address indexed _owner, address indexed _spender, uint _value);
}

pragma solidity ^0.4.25;

interface tokenRecipient {
    function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}

contract TokenERC20 {
    string public name; // ERC20标准
    string public symbol; // ERC20标准
    uint8 public decimals = 2; // ERC20标准，decimals 可以有的小数点个数，最小的代币单位。18 是建议的默认值
    uint256 public totalSupply; // ERC20标准 总供应量

    // 用mapping保存每个地址对应的余额 ERC20标准
    mapping(address => uint256) public balanceOf;

    // 存储对账号的控制 ERC20标准
    mapping(address => mapping(address => uint256)) public allowance;

    // 事件，用来通知客户端交易发生 ERC20标准
    event Transfer(address indexed from, address indexed to, uint256 value);

    // 事件，用来通知客户端代币被消费 ERC20标准
    event Burn(address indexed from, uint256 value);

    /**
     * 初始化构造
     */
    constructor(uint256 initialSupply, string tokenName, string tokenSymbol) public {
        totalSupply = initialSupply * 10 ** uint256(decimals); // 供应的份额，份额跟最小的代币单位有关，份额 = 币数 * 10 ** decimals。
        balanceOf[msg.sender] = totalSupply;
        name = tokenName;
        symbol = tokenSymbol;
    }

    // 创建者拥有所有的代币
    // 代币名称
    // 代币符号
}

/**
 * 代币交易转移的内部实现
 */
function _transfer(address _from, address _to, uint _value) internal {
  //确保目标地址不为0x0，因为0x0地址代表销毁
  require(_to != 0x0);
  //检查发送者余额
  require(balanceOf[_from] >= _value);
  //确保转移为正数个
  require(balanceOf[_to] + _value > balanceOf[_to]);
  //以下用来检查交易，
  uint previousBalances = balanceOf[_from] + balanceOf[_to];
  //Subtract from the sender
  balanceOf[_from] -= _value;
  //Add the same to the recipient
  balanceOf[_to] += _value;
  Transfer(_from, _to, _value);
  //用assert来检查代码逻辑。
  assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}


/**
* 代币交易转移
* 从自己（创建交易者）账号发送_value个代币到_to账号
* ERC20标准
* @param _to 接收者地址
* @param _value 转移数额
*/
function transfer(address _to, uint256 _value) public {
	_transfer(msg.sender, _to, _value);
}

/**
* 账号之间代币交易转移
* ERC20标准
* @param _from 发送者地址
* @param _to 接收者地址
* @param _value 转移数额
*/
function transferFrom(address _from, address _to, uint256 _value) public returns bool success){
    require(_value <= allowance[_from][msg.sender]); // Check allowance
    allowance[_from][msg.sender] -= _value;
    _transfer(_from, _to, _value);
    return true;
}

/**
* 设置某个地址（合约）可以创建交易者名义花费的代币数。
* 允许发送者`_spender`花费不多于`_value`个代币
* ERC20标准
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public returns (bool success){
    allowance[msg.sender][_spender] = _value;
}

/**
 * 设置允许一个地址（合约）以我（创建交易者）的名义可最多花费的代币数。
 * 非ERC20标准
 * @param _spender 被授权的地址（合约）
 * @param _value 最大可花费代币数
 * @param _extraData 发送给合约的附加数据
 */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
    tokenRecipient spender = tokenRecipient(_spender);
    if (approve(_spender, _value)) {
        // 通知合约
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }
}
/**
 * 销毁我（创建交易者）账户中指定个代币
 * 非ERC20标准
 */
function burn(uint256 _value) public returns (bool success) {
    require(balanceOf[msg.sender] >= _value); // 检查发送者是否有足够的代币
    balanceOf[msg.sender] -= _value; // 从发送者中减去代币
    totalSupply -= _value; // 更新总供应量
    emit Burn(msg.sender, _value);
    return true;
}

const solc = require('solc');
const path = require('path');
const fs = require('fs');

// 1. 合约代码文件路径
const sourceFilePath = path.resolve(__dirname, './TokenERC20.sol');
// 2. 合约编译后的文件路径
const bytecodeFilePath = path.resolve(__dirname, './TokenERC20.bytecode');

// 3. 编译
const result = solc.compile(source, 1);
// console.log(result);

console.log('1. 编译完成：' + sourceFilePath);

fs.writeFileSync(bytecodeFilePath, JSON.stringify(result.contracts[':TokenERC20']), 'utf-8');

console.log('2. 字节文件写入完成：' + bytecodeFilePath);

// 4. 暴露外部访问

module.exports = result.contracts[':TokenERC20'];

// 1.1 导入 编译好的 合约的 字节码 和 api
const path = require('path');
const fs = require('fs');

// 1.2 合约编译后的文件路径
const bytecodeFilePath = path.resolve(__dirname,'./TokenERC20.bytecode');

//读取字节码文件
const bytecodeJsonStr = fs.readFileSync(bytecodeFilePath,'utf-8');
const bytecodeJsonObj = JSON.parse(bytecodeJsonStr);
//const {bytecode,interface} = require('./compilaiCaiPiao');
const bytecode = bytecodeJsonObj.bytecode;
const interface = bytecodeJsonObj.interface;

// 2 导入hd钱包provider
const HDWalletProvider = require("truffle-hdwallet-provider");

// 3 助记词（相当于我们的私钥）
const mnemonic = "jeb... cat beef"; // 12 word mnemonic

// 4 创建 provider, 可以来访问 以太坊真实网络节点
const provider = new HDWalletProvider(
    mnemonic,
    "https://rinkeby.infura.io/v3/3a60f2b160....",1); // 最后的一个 是获取 助记词 的第一个地址

// 5 创建web对象
const Web3 = require('web3');
const web3= new Web3(provider);

async function main(){
    console.log('开始与以太网交互.....');
    const usrAdr = await web3.eth.getAccounts();
    web3.eth.defaultAccount = usrAdr[0];
    console.log('当前调用者的地址：'+ web3.eth.defaultAccount);

    // 6 部署合约到 以太坊节点
    //let contractObj =await deployContract();

    // 7 调用合约
    // 7.0 创建远程智能合约
    const contractObj =await new web3.eth.Contract(JSON.parse(interface),'0x46495b091cd3Fcb789cC336c3B5e9041E28555b0');
    console.log('获取【合约】对象成功!');
}

// 7.1 获取指定地址余额
await getBalanceAt(contractObj, '0x85BCc0F34718e0C332d41C513B72f8640B05249');
await transferTo(contractObj, '0x83E9e99B7f501860930baEC7801555C850D9C5', 1000000);
await approveTo(contractObj, '0x83E9e99B7f501860930baEC7801555C850D9C5', 1000000000);
await allowanceAt(contractObj, '0x85BCc0F34718e0C332d41C513B72f8640B05249', '0x83E9e99B7f501860930baEC7801555C850D9C5');
await transferFrom(contractObj, '0x85BCc0F34718e0C332d41C513B72f8640B05249', '0x737Df786F6e86625258960970c6752Fd7926F752', 1);
await allowanceAt(contractObj, '0x85BCc0F34718e0C332d41C513B72f8640B05249', '0x83E9e99B7f501860930baEC7801555C850D9C5');

//await getBalanceAt(contractObj, '0x737Df786F6e86625258960970c6752Fd7926F752');
////7.2 显示合约账户余额
//await showContracMoney(contractObj);
//查看调用者购买的号码LuckNum(contractObj);
////7.3 开奖+
//await withdrawLottery(contractObj);
////7.4 显示买家账户列表
//await showUsrList(contractObj);
////7.5 重置数据
//await resetContract(contractObj);
//await showManageAddress(contractObj);
//await killContract(contractObj);

// 启动
main();

// 1. 部署合约
async function deployContract() {
  console.log('开始部署合约……');
  let contractObj = await new web3.eth.Contract(JSON.parse(interface))
    .deploy({
      data: bytecode,//TokenERC20(uint256 initialSupply, string tokenName, string tokenSymbol)
      arguments: ['10000000000','梦想零钱','DreamCoin']
    })
    .send({
      from:web3.eth.defaultAccount,
      gas:'1000000'
    });

  console.log('部署成功，合约地址：'+contractObj.options.address);
  return contractObj;
}

// 2. 查询余额
async function getBalanceAt(contractObj,usrAdr) {
  let usrMoney = await contractObj.methods.balanceOf(usrAdr).call();
  console.log('地址['+usrAdr+'']余额:'+usrMoney);
}

//3. 将当前调用者的钱 转 money 金额给 usrAdrTo
async function transferTo(contractObj,usrAdrTo,money) {
  let result = await contractObj.methods.transfer(usrAdrTo,money).send({
    from:web3.eth.defaultAccount,
    gas:'1000000'
  });
  console.log(web3.eth.defaultAccount+'向['+usrAdrTo+']转账['+money+']完毕');
  console.log('转账完毕--记录如下:');
  console.log(result);
}

//4. 授权（当前调用者授权给 spenderAdr 操作额为 money 的代币）
async function approveTo(contractObj,spenderAdr, money){
  let result = await contractObj.methods.approve(spenderAdr,money).send({
    from:web3.eth.defaultAccount,
    gas:'1000000'
  });
  console.log(web3.eth.defaultAccount+'向['+spenderAdr+']授权['+money+']完毕!');
  //console.log(result);
}

//5.查询授权
allowanceAt(contractObj,ownerAdr,spenderAdr) {
  let result = await contractObj.methods.allowance(ownerAdr,spenderAdr).call();
  console.log('查询：['+ownerAdr+']给['+spenderAdr+']剩余授权余額为：'+result);
}

//6.转帐（汇款人地址，收款人地址，金额）
async function transferFrom(contractObj,usrAdrFrom,usrAdrTo,money){
  let result = await contractObj.methods.transferFrom(usrAdrFrom,usrAdrTo,money).send({
    from:web3.eth.defaultAccount,
    gas:'1000000'
  });
  console.log(usrAdrFrom+'向['+usrAdrTo+']转账['+money+']完毕');
  //console.log(result);
}

function mintToken(address _target, uint256 _mintedAmount) onlyOwner
    internal
{
    balanceOf[_target] += _mintedAmount;
    totalSupply += _mintedAmount;
    emit Transfer(address(0), owner, _mintedAmount);
    emit Transfer(owner, _target, _mintedAmount);
}

mapping (address => bool) public frozenAccount;
event FrozenFunds(address target, bool frozen);

function freezeAccount(address target, bool freeze) onlyOwner {
  frozenAccount[target] = freeze;
  FrozenFunds(target, freeze);
}

function transfer(address _to, uint256 _value) {
  require(!frozenAccount[msg.sender]);
  
  ...
}

uint256 public sellPrice;
uint256 public buyPrice;

function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner {
  sellPrice = newSellPrice;
  buyPrice = newBuyPrice;
}

function buy() payable returns (uint amount){
  amount = msg.value / buyPrice; // calculates the amount
  require(balanceOf[this]>=amount); // checks if it has enough to sell
  balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
  balanceOf[this] -= amount; // subtracts amount from seller's balance
  Transfer(this, msg.sender, amount); // execute an event reflecting the change
  return amount; // ends function and returns
}

function buy() payable returns (uint amount){
  amount = msg.value / buyPrice; // calculates the amount
  require(balanceOf[this]>=amount); // checks if it has enough to sell
  balanceOf[msg.sender] += amount; // adds the amount to buyer's balance
  balanceOf[this] -= amount; // subtracts amount from seller's balance
  Transfer(this, msg.sender, amount); // execute an event reflecting the change
  return amount; // ends function and returns
}

uint minBalanceForAccounts;

function setMinBalance(uint minimumBalanceInFinney) onlyOwner {
  minBalanceForAccounts = minimumBalanceInFinney * 1 finney;
}