Tokens

• 货币：Token可以作为一种货币形式，其价值通过私人交易来确定。例如，ether或bitcoin。
• 资源：Token可以表示在共享经济或资源共享环境中获得或生成的资源。例如，表示可通过网络共享的资源的存储或CPU的Token。
• 资产：Token可以代表内在或外在，有形或无形资产的所有权。例如，黄金，房地产，汽车，石油，能源等
• 访问：Token可以代表访问权限，可以访问数字或实体资产，例如论坛，专属网站，酒店房间，租车。
• 权益：Token可以代表数字组织（例如DAO）或法律虚拟主体（例如公司）中的股东权益
• 投票：Token可以代表数字或法律系统中的投票权。
• 收藏品：Token可以代表数字（例如CryptoPunks）或物理收藏品（例如绘画）
• 身份：Token可以代表数字（例如头像）或合法身份（例如国家ID）。
• 证明：Token可以代表某些机构或去中心化的信用系统（例如婚姻记录，出生证明，大学学位）的认证或事实证明。
• 实际用途：Token可用于访问或支付服务。

来自Wikipedia:

在经济学中，可互换性是一种商品或商品的财产，其独立单位本质上是可以互换的。

• totalSupply：返回当前存在的Token的总单位。ERC20Token可以有固定或可变的供应量。
• balanceOf：给定一个地址，返回该地址的Token余额。
• transfer：给定一个地址和数量，将该数量的Tokens从执行该方法的地址的余额转移到该地址。
• transferFrom：给定发送者，接收人和数量，将Token从一个帐户转移到另一个帐户。与+approve+结合使用。
• approve：在给定接收者地址和数量的情况下，授权该地址从发布批准的帐户执行多次转账，直到到达指定的数量。
• allowance：给定一个所有者地址和一个消费者地址，返回该消费者被批准从所有者的取款的剩余金额。
• Transfer event：成功转移时触发的事件（调用+transfer+或+transferFrom+）（即使对于零值转移）。
• Approval event：成功调用+approve+时记录的事件。

• name：返回Token的可读名称（例如“US Dollars”）。
• symbol：返回Token的人类可读符号（例如“USD”）。
• decimals：返回用于分割Token数量的小数位数。例如，如果小数为2，则将Token数除以100以获取其用户表示。

• 以下是在Solidity中ERC20接口规范的样子：

  contract ERC20 {
     function totalSupply() constant returns (uint theTotalSupply);
     function balanceOf(address _owner) constant returns (uint balance);
     function transfer(address _to, uint _value) returns (bool success);
     function transferFrom(address _from, address _to, uint _value) returns (bool success);
     function approve(address _spender, uint _value) returns (bool success);
     function allowance(address _owner, address _spender) constant returns (uint remaining);
     event Transfer(address indexed _from, address indexed _to, uint _value);
     event Approval(address indexed _owner, address indexed _spender, uint _value);
  }
  

• Balances: a mapping from address (owner) to amount (balance)

  mapping(address => uint256) balances;
  

• 第二个数据结构是配额的data mapping。正如我们将在ERC20工作流程：“transfer”和“approve 中看到的那样，使用ERC20Token，Token的所有者可以将权限委托给花钱者，允许他们从所有者的余额中花费特定金额（配额）。ERC20合同通过二维映射追踪配额，主关键字是Token所有者的地址，映射到一个花费者地址和配额金额：
• Allowances: a mapping from address (owner) to address (spender) to amount (allowance)

  mapping (address => mapping (address => uint256)) public allowed;
  

• 首先，让我们创建并初始化一个Truffle项目目录，就像我们在[truffle_project_directory]中所做的那样。运行这四个命令并接受任何问题的默认答案：

  $ mkdir METoken
  $ cd METoken
  METoken $ truffle init
  METoken $ npm init
  

• 你现在应该具有以下目录结构：

  METoken/
  ├── contracts
  │   └── Migrations.sol
  ├── migrations
  │   └── 1_initial_migration.js
  ├── package.json
  ├── test
  ├── truffle-config.js
  └── truffle.js
  

• 之后你的目录看起来像：

  METoken/
  ├── contracts
  │   └── Migrations.sol
  ├── migrations
  │   └── 1_initial_migration.js
  ├── package.json
  ├── test
  ├── truffle-config.js
  ├── truffle.js
  └── .env *new file*
  

只能使用不用于在以太坊主网络上持有资金的测试密钥或测试助记符。切勿使用持有真正金钱的钥匙进行测试。

• 对于我们的示例，我们将导入OpenZeppelin StandardContract，它实现了一些重要的安全检查并且易于扩展。让我们导入该库：

  $ npm install zeppelin-solidity
  + zeppelin-solidity@1.6.0
  added 8 packages in 2.504s
  

• zeppelin-solidity 包将在 node_modules +目录下添加约250个文件。OpenZeppelin库包含的不仅仅是ERC20Token，但我们只使用它的一小部分。

• 我们的合同非常简单，因为它继承了OpenZeppelin StandardToken库的所有功能：
• METoken.sol : A Solidity contract implementing an ERC20 Token

  link:code/METoken/contracts/METoken.sol[]
  

• 我们现在使用+truffle+编译+METoken+代码：

  $ truffle compile
  Compiling ./contracts/METoken.sol...
  Compiling ./contracts/Migrations.sol...
  Compiling zeppelin-solidity/contracts/math/SafeMath.sol...
  Compiling zeppelin-solidity/contracts/Token/ERC20/BasicToken.sol...
  Compiling zeppelin-solidity/contracts/Token/ERC20/ERC20.sol...
  Compiling zeppelin-solidity/contracts/Token/ERC20/ERC20Basic.sol...
  Compiling zeppelin-solidity/contracts/Token/ERC20/StandardToken.sol...
  

• 以下是它包含的内容：
• 2_deploy_contracts: Migration to deploy METoken

  link:code/METoken/migrations/2_deploy_contracts.js[]
  var METoken = artifacts.require("METoken");
  module.exports = function(deployer) {
    // Deploy the METoken contract as our only task
    deployer.deploy(METoken);
  };
  

• 一旦 ganache 启动，我们就可以部署我们的METoken合约，看看是否一切都按预期工作：

  $ truffle migrate --network ganache
  Using network 'ganache'.
  Running migration: 1_initial_migration.js
    Deploying Migrations...
    ... 0xb2e90a056dc6ad8e654683921fc613c796a03b89df6760ec1db1084ea4a084eb
    Migrations: 0x8cdaf0cd259887258bc13a92c0a6da92698644c0
  Saving successful migration to network...
    ... 0xd7bc86d31bee32fa3988f1c1eabce403a1b5d570340a3a9cdba53a472ee8c956
  Saving artifacts...
  Running migration: 2_deploy_contracts.js
    Deploying METoken...
    ... 0xbe9290d59678b412e60ed6aefedb17364f4ad2977cfb2076b9b8ad415c5dc9f0
    METoken: 0x345ca3e014aaf5dca488057592ee47305d9b3e10
  Saving successful migration to network...
    ... 0xf36163615f41ef7ed8f4a8f192149a0bf633fe1a2398ce001bf44c43dc7bdda0
  Saving artifacts...
  

• 我们可以使用+Truffle控制台+与我们的+ganache+区块链合同进行互动。这是一个交互式的JavaScript环境，可以访问Truffle环境，并通过Web3访问区块链。在这种情况下，我们将+Truffle控制台+连接到+ganache+区块链：

  $ truffle console --network ganache
  truffle(ganache)>
  

  + truffle(ganache)>+ 提示符表明我们已连接到 +ganache+区块链并准备输入我们的命令。+Truffle控制台+支持所有的Truffle命令，所以我们可以从控制台+compile+和+migrate+。我们已经运行过这些命令，所以让我们直接看看合同本身。METoken合约作为Truffle环境内的JavaScript对象存在。在提示符下键入+METoken+，它将转储整个合约定义：
  

  truffle(ganache)> METoken
  { [Function: TruffleContract]
    _static_methods:
  [...]
  currentProvider:
   HttpProvider {
     host: 'http://localhost:7545',
     timeout: 0,
     user: undefined,
     password: undefined,
     headers: undefined,
     send: [Function],
     sendAsync: [Function],
     _alreadyWrapped: true },
  network_id: '5777' }
  

• +METoken+对象还公开几个属性，例如合同的地址（由+migrate+命令部署）：

  truffle(ganache)> METoken.address
  '0x345ca3e014aaf5dca488057592ee47305d9b3e10'
  

• 如果我们想要与已部署的合同进行交互，我们必须以JavaScript“promise”的形式使用异步调用。我们使用+deployment+函数来获取合约实例，然后调用+totalSupply+函数：

  truffle(ganache)> METoken.deployed().then(instance => instance.totalSupply())
  BigNumber { s: 1, e: 9, c: [ 2100000000 ] }
  

• 接下来，让我们使用由+ganache+创建的账户来检查我们的METoken余额并将一些METoken发送到另一个地址。首先，让我们获取帐户地址：

  truffle(ganache)> let accounts
  undefined
  truffle(ganache)> web3.eth.getAccounts((err,res) => { accounts = res })
  undefined
  truffle(ganache)> accounts[0]
  '0x627306090abab3a6e1400e9345bc60c78a8bef57'
  

• accounts 列表现在包含由+ganache+创建的所有帐户，而+account[0]+是部署了该METoken合约的帐户。它应该有METoken的余额，因为我们的METoken构造函数将全部Token提供给了创建它的地址。让我们检查：

  truffle(ganache)> METoken.deployed().then(instance => { instance.balanceOf(accounts[0]).then(console.log) })
  undefined
  BigNumber { s: 1, e: 9, c: [ 2100000000 ] }
  

• 最后，通过调用合约的 transfer+函数，让我们从+account[0] 向 account[1] 转移1000.00 METoken：

  truffle(ganache)> METoken.deployed().then(instance => { instance.transfer(accounts[1], 100000) })
  undefined
  truffle(ganache)> METoken.deployed().then(instance => { instance.balanceOf(accounts[0]).then(console.log) })
  undefined
  truffle(ganache)> BigNumber { s: 1, e: 9, c: [ 2099900000 ] }
  undefined
  truffle(ganache)> METoken.deployed().then(instance => { instance.balanceOf(accounts[1]).then(console.log) })
  undefined
  truffle(ganache)> BigNumber { s: 1, e: 5, c: [ 100000 ] }
  

METoken具有2位精度的小数，这意味着1个METoken在合同中是100个单位。当我们传输1000个METoken时，我们在传输函数中将该值指定为100,000。

• 首先，我们将其他合约部署到我们的测试环境中。对于这个例子，我们将使用我们的第一个合同+Faucet.sol+。我们将它添加到METoken项目中，方法是将它复制到+contracts+目录。我们的目录应该是这样的：

  METoken/
  ├── contracts
  │   ├── Faucet.sol
  │   ├── METoken.sol
  │   └── Migrations.sol
  

• 我们还会添加一个migration，从+METoken+单独部署+Faucet+：

  var Faucet = artifacts.require("Faucet");
  module.exports = function(deployer) {
    // Deploy the Faucet contract as our only task
    deployer.deploy(Faucet);
  };
  

• 让我们从Truffle控制台编译和迁移合同：

  $ truffle console --network ganache
  truffle(ganache)> compile
  Compiling ./contracts/Faucet.sol...
  Writing artifacts to ./build/contracts
  truffle(ganache)> migrate
  Using network 'ganache'.
  Running migration: 1_initial_migration.js
    Deploying Migrations...
    ... 0x89f6a7bd2a596829c60a483ec99665c7af71e68c77a417fab503c394fcd7a0c9
    Migrations: 0xa1ccce36fb823810e729dce293b75f40fb6ea9c9
  Saving artifacts...
  Running migration: 2_deploy_contracts.js
    Replacing METoken...
    ... 0x28d0da26f48765f67e133e99dd275fac6a25fdfec6594060fd1a0e09a99b44ba
    METoken: 0x7d6bf9d5914d37bcba9d46df7107e71c59f3791f
  Saving artifacts...
  Running migration: 3_deploy_faucet.js
    Deploying Faucet...
    ... 0x6fbf283bcc97d7c52d92fd91f6ac02d565f5fded483a6a0f824f66edc6fa90c3
    Faucet: 0xb18a42e9468f7f1342fa3c329ec339f254bc7524
  Saving artifacts...
  

• 现在让我们将一些MET发送到 Faucet 合约：

  truffle(ganache)> METoken.deployed().then(instance => { instance.transfer(Faucet.address, 100000) })
  truffle(ganache)> METoken.deployed().then(instance => { instance.balanceOf(Faucet.address).then(console.log)})
  truffle(ganache)> BigNumber { s: 1, e: 5, c: [ 100000 ] }
  

• 现在，让我们创建一个新的Faucet合同，称之为+METFaucet.sol+。它看起来像这样：
• METFaucet.sol: a faucet for METoken

  include::code/METoken_METFaucet/contracts/METFaucet.sol
  // Version of Solidity compiler this program was written for
  pragma solidity ^0.4.19;
  import 'zeppelin-solidity/contracts/Token/ERC20/StandardToken.sol';
  // A faucet for ERC20 Token MET
  contract METFaucet {
  	StandardToken public METoken;
  	address public METOwner;
  	// METFaucet constructor, provide the address of METoken contract and
  	// the owner address we will be approved to transferFrom
  	function METFaucet(address _METoken, address _METOwner) public {
  		// Initialize the METoken from the address provided
  		METoken = StandardToken(_METoken);
  		METOwner = _METOwner;
  	}
  	function withdraw(uint withdraw_amount) public {
      	// Limit withdrawal amount to 10 MET
      	require(withdraw_amount <= 1000);
  		// Use the transferFrom function of METoken
  		METoken.transferFrom(METOwner, msg.sender, withdraw_amount);
      }
  	// REJECT any incoming ether
  	function () public payable { revert(); }
  }
  

• 我们在这里声明这两个变量：

  StandardToken public METoken;
  address public METOwner;
  

• 由于我们的Faucet需要使用+METoken+和+METOwner+的正确地址进行初始化，因此我们需要声明一个自定义构造函数：

  // METFaucet constructor, provide the address of METoken contract and
  // the owner address we will be approved to transferFrom
  function METFaucet(address _METoken, address _METOwner) public {
  	// Initialize the METoken from the address provided
  	METoken = StandardToken(_METoken);
  	METOwner = _METOwner;
  }
  

• 下一个改变是+withdraw+函数。METFaucet+使用+METoken+中的+transferFrom+函数，并要求+METoken+将MET传输给Faucet的接收者，而不是调用+transfer。

  // Use the transferFrom function of METoken
  METoken.transferFrom(METOwner, msg.sender, withdraw_amount);
  

• 最后，由于我们的Faucet不再发送ether，我们应该阻止任何人将ether送到+METFaucet+，因为我们不希望它被卡住。我们更改fallback函数以拒绝发进来的ether，使用+revert+功能还原任何收款：

  // REJECT any incoming ether
  function () public payable { revert(); }
  

• 现在我们的+METFaucet.sol+代码已准备就绪，我们需要修改migration脚本来部署它。这个migration脚本会有点复杂，因为+METFaucet+依赖于+METoken+的地址。我们将使用JavaScript promise按顺序部署这两个合约。创建+2_deply_contracts.js+，如下所示：

  var METoken = artifacts.require("METoken");
  var METFaucet = artifacts.require("METFaucet");
  var owner = web3.eth.accounts[0];
  module.exports = function(deployer) {
  	// Deploy the METoken contract first
  	deployer.deploy(METoken, {from: owner}).then(function() {
  		// then deploy METFaucet and pass the address of METoken
  		// and the address of the owner of all the MET who will approve METFaucet
  		return deployer.deploy(METFaucet, METoken.address, owner);
    	});
  }
  

• 现在，我们可以测试Truffle控制台中的所有内容。首先，我们使用+migrate+来部署合同。当+METoken+部署时，它会将所有MET分配给创建它的帐户，web3.eth.accounts[0]。然后，我们在METoken中调用+approve+函数来批准+METFaucet+代表+web3.eth.accounts[0]+发送1000 MET。最后，为了测试我们的Faucet，我们从+web3.eth.accounts[1]+调用+METFaucet.withdraw+并尝试提取10个MET。以下是控制台命令：

  $ truffle console --network ganache
  truffle(ganache)> migrate
  Using network 'ganache'.
  Running migration: 1_initial_migration.js
    Deploying Migrations...
    ... 0x79352b43e18cc46b023a779e9a0d16b30f127bfa40266c02f9871d63c26542c7
    Migrations: 0xaa588d3737b611bafd7bd713445b314bd453a5c8
  Saving artifacts...
  Running migration: 2_deploy_contracts.js
    Replacing METoken...
    ... 0xc42a57f22cddf95f6f8c19d794c8af3b2491f568b38b96fef15b13b6e8bfff21
    METoken: 0xf204a4ef082f5c04bb89f7d5e6568b796096735a
    Replacing METFaucet...
    ... 0xd9615cae2fa4f1e8a377de87f86162832cf4d31098779e6e00df1ae7f1b7f864
    METFaucet: 0x75c35c980c0d37ef46df04d31a140b65503c0eed
  Saving artifacts...
  truffle(ganache)> METoken.deployed().then(instance => { instance.approve(METFaucet.address, 100000) })
  truffle(ganache)> METoken.deployed().then(instance => { instance.balanceOf(web3.eth.accounts[1]).then(console.log) })
  truffle(ganache)> BigNumber { s: 1, e: 0, c: [ 0 ] }
  truffle(ganache)> METFaucet.deployed().then(instance => { instance.withdraw(1000, {from:web3.eth.accounts[1]}) } )
  truffle(ganache)> METoken.deployed().then(instance => { instance.balanceOf(web3.eth.accounts[1]).then(console.log) })
  truffle(ganache)> BigNumber { s: 1, e: 3, c: [ 1000 ] }
  

• 为了检测目标地址是否为契约，ERC223参考实现使用了一小段内联字节码，并采用了一种颇具创造性的方式：

  function isContract(address _addr) private view returns (bool is_contract) {
  	uint length;
  	assembly {
  		  //retrieve the size of the code on target address, this needs assembly
  		  length := extcodesize(_addr)
  	}
  	return (length>0);
  }
  

• ERC223合同接口规范是：

  interface ERC223Token {
    uint public totalSupply;
    function balanceOf(address who) public view returns (uint);
    function name() public view returns (string _name);
    function symbol() public view returns (string _symbol);
    function decimals() public view returns (uint8 _decimals);
    function totalSupply() public view returns (uint256 _supply);
    function transfer(address to, uint value) public returns (bool ok);
    function transfer(address to, uint value, bytes data) public returns (bool ok);
    function transfer(address to, uint value, bytes data, string custom_fallback) public returns (bool ok);
    event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
  }
  

• 提供ERC20兼容性界面
• 使用+send+功能传输Token，类似于ether传输
• 与ERC820兼容Token合同注册
• 合同和地址可以通过在发送之前调用+TokensToSend+函数来控制它们发送的Token
• 通过在接收者中调用+TokensReceived+函数来通知合同和地址
• Token传输交易包含 userData 和 operatorData 字段中的元数据
• 无论是发送到合同还是EOA，都以相同的方式运作

• ERC777合同接口规范是：

  interface ERC777Token {
      function name() public constant returns (string);
      function symbol() public constant returns (string);
      function totalSupply() public constant returns (uint256);
      function granularity() public constant returns (uint256);
      function balanceOf(address owner) public constant returns (uint256);
      function send(address to, uint256 amount) public;
      function send(address to, uint256 amount, bytes userData) public;
      function authorizeOperator(address operator) public;
      function revokeOperator(address operator) public;
      function isOperatorFor(address operator, address TokenHolder) public constant returns (bool);
      function operatorSend(address from, address to, uint256 amount, bytes userData, bytes operatorData) public;
      event Sent(address indexed operator, address indexed from, address indexed to, uint256 amount, bytes userData, bytes operatorData);
      event Minted(address indexed operator, address indexed to, uint256 amount, bytes operatorData);
      event Burned(address indexed operator, address indexed from, uint256 amount, bytes userData, bytes operatorData);
      event AuthorizedOperator(address indexed operator, address indexed TokenHolder);
      event RevokedOperator(address indexed operator, address indexed TokenHolder);
  }
  

牛津词典：

契约：签署和交付的法律文件，尤其是关于财产或合法权利所有权的法律文件。

• 初步建议： https://github.com/ethereum/EIPs/issues/721
• 继续讨论： https://github.com/ethereum/EIPs/pull/841

// Mapping from deed ID to owner
mapping (uint256 => address) private deedOwner;

• ERC721 合同接口规范是：

  interface ERC721 /* is ERC165 */ {
      event Transfer(address indexed _from, address indexed _to, uint256 _deedId);
      event Approval(address indexed _owner, address indexed _approved, uint256 _deedId);
      event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
      function balanceOf(address _owner) external view returns (uint256 _balance);
      function ownerOf(uint256 _deedId) external view returns (address _owner);
      function transfer(address _to, uint256 _deedId) external payable;
      function transferFrom(address _from, address _to, uint256 _deedId) external payable;
      function approve(address _approved, uint256 _deedId) external payable;
      function setApprovalForAll(address _operateor, boolean _approved) payable;
      function supportsInterface(bytes4 interfaceID) external view returns (bool);
  }
  

• 用于元数据的ERC721可选接口是：

  interface ERC721Metadata /* is ERC721 */ {
      function name() external pure returns (string _name);
      function symbol() external pure returns (string _symbol);
      function deedUri(uint256 _deedId) external view returns (string _deedUri);
  }
  

• 用于枚举的ERC721可选接口是：

  interface ERC721Enumerable /* is ERC721 */ {
      function totalSupply() external view returns (uint256 _count);
      function deedByIndex(uint256 _index) external view returns (uint256 _deedId);
      function countOfOwners() external view returns (uint256 _count);
      function ownerByIndex(uint256 _index) external view returns (address _owner);
      function deedOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 _deedId);
  }
  

维基百科“Not Invented Here”（https://en.wikipedia.org/wiki/Not_invented_here）

Not Invented Here是由社会，企业或机构文化采取的立场，由于其外部起源和成本（如版税），避免使用或购买已有产品，研究，标准或知识。

• 燃烧是指Token被转移到不可靠的地址或删除余额并减少供应时故意销毁。
• Minting以可预测的速率添加Token的总供应量的能力，或通过Token创建者的“命令”添加的能力。
• Crowdfunding提供Token销售的能力，例如通过拍卖，市场销售，反向拍卖等。
• 上限总供给的预定义和不可改变的限制，与“minting”功能相反。
• 恢复“后门”恢复资金，反向传输或拆除由指定地址或一组地址激活的Token（多重签名）的功能。
• 白名单限制Token传输仅限于列出的地址的功能。在经过不同司法管辖区的规则审核后，最常用于向“经认可的投资者”提供Token。通常有一种更新白名单的机制。
• 黑名单通过禁止特定地址来限制Token传输的能力。通常有更新黑名单的功能。