【我的区块链之路】- ERC系列协议标准详解
【转载请标明出处】：https://blog.csdn.net/qq_25870633/article/details/80884646
在以太坊中，发布智能合约是自由的;但是，很多第三方想要做的事情可能有所类似，故延伸出来了ERC系列协议；
基于以太坊的区块链平台的数字资产分为原生令牌（硬币）和代币（令牌）两大类，原生的自然就是以太坊（ETH），令牌是通过智能合约创设的数字资产。代币则是按ERC创设协议分类，主流类别有ERC20代币，ERC223代币，ERC721代币，另外还有一些小众类别，包括ERC621，ERC721和ERC827等。
ERC代表“Etuereum征求意见”，这是Ethereum版的意见征求稿（RFC），ERC是由以太坊开发者为以太坊社区编写，ERC后面的数字是议案的编号。当开发人员提交了一个以太坊改进方案（EIP），该方案一旦EIP被委员会批准并最终确定后，一个新的以太坊开发标准就形成了，它包括协议规范和合约标准;【注：好多新人都不知道这个.ERC =以太坊请求评论，你要看EIP这个项目，应该去看问题.ERC20，就是问题＃20，ERC721，就是问题＃721。并不是所有的ERC都是标准，最终被采纳的问题才会被收进EIP ; EIP的readme里边有目前的状态网站链接https://eips.ethereum.org】具体表现可以用抽象合约表现出来【注意：ERC并不是指某些特定的合约，而是指合约应该符合某些规范】;根据具备某些特征归类目前有ERC20，ERC223，ERC664，ERC667，ERC721，ERC875，ERC1155及ERC156等等合约协议规 范;下面我们先从大家最常用的ERC20铸币合约标准开始说，以下为一个标准的ERC20的解析：
pragma solidity ^0.4.16;
/**
ERC20标准
*/
contract ERC20 {
/**
代币的名字，例如"Gavin token"
*/
function name() constant public returns (string name);
/**
代币的简称，例如：GAVC
也是我们一般在代币交易所看到的名字
*/
function symbol() public constant returns (string symbol);
/**
代币的最小分割量
token使用的小数点后几位。比如如果设置为3，就是支持0.001表示
*/
function decimals() public constant returns (uint8 decimals);
/**
token的总量
*/
function totalSupply() public constant returns (uint totalSupply);
/**
【余额】
返回某个地址(账户)的账户余额
*/
function balanceOf(address _owner) public constant returns (uint balance);
/**
【转账】
交易代币
从消息发送者账户中往_to账户转数量为_value的token
从代币合约的调用者地址上转移 _value的数量token到的地址 _to，并且必须触发Transfer事件
*/
function transfer(address _to, uint _value) public returns (bool success);
/**
【替某人个别人转账】
从账户_from中往账户_to转数量为_value的token，与approve方法配合使用
从地址 _from发送数量为 _value的token到地址 _to,必须触发Transfer事件。
transferFrom方法用于允许合约代理某人转移token。条件是from账户必须经过了approve。这个后面会举例说明
*/
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
/**
【允许量值】
限定_spender能从合约调用账户中转出数量为_value的token
*/
function approve(address _spender, uint _value) public returns (bool success);
/**
【限额】
获取账户_spender可以从账户_owner中转出token的数量
*/
function allowance(address _owner, address _spender) public constant returns (uint remaining);
/**
发生转账时必须要触发的事件
一般位于 transfer 和 transferFrom 函数中
*/
event Transfer(address indexed _from, address indexed _to, uint _value);
/**
当函数approve(address _spender, uint256 _value)成功执行时必须触发的事件
*/
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
上述就是传说中的ERC20 标准接口总共分为三大类: 常量、功能函数及事件
【常量】
<1> name: 代币名称,就是一串指定的字符串,如: "GavinNetToken"
<2> symbol: 代币的代号，由3-4个大写字母组成, 如: "GVTC"
<3> decimals: 小数点后几位,表示该代币支持最小的小数位是多少,默认为18 (ETH也是18，之所以需要有小数位字段是因为EVM 不支持小数点运算,需要在做计算的时候先转成整型,最后根据小数位把运算结果转换会对应的小数位)
【功能函数】
<4> totalSupply(): 总供应量；表示该代币的总发行量 [后期并没有承诺不会被更改]
<5> balanceOf(address _owner): 查询余额；根据账户地址查询该地址的余额，为无符号整数常量
<6> transfer(address _to, uint _value): 转账；表示合约的调用者 转移_value 数量的token至 _to 目标账户地址
<7> transferFrom(address _from, address _to, uint _value): 替别人转账；合约调用者代替_from给_to转账 _value数目,【该方法需要有approve()方法的先决条件，即是说 需要_from 先用approve() 给当前合约的调用者 设置课允许当前合约调用者 代替自己(即: _from)给_to转账_value数目】
<8> approve(address _spender, uint _value): 给某人赋予多少转账数目权限；当前合约调用者给予_spender账户有替代自己给别人转账 总额为_value数目 【注意,这个方法会对一个全局的 map[最终花钱者(approve()方法的调用者)][替代自己拿着自己的钱去花者] 进行设置，后续transferFrom函数每次转账后都需要更新该Map中记载的被给予转账的余额；allowance()方法会查询这个map中的值】
<9> allowance(address _owner, address _spender): 查询限额的数目；查询_spender还可以从_owner拿多少数目去花销【底层读取的是 approve()方法中设置的那个全局的map的值】
【事件】
<10> event Transfer : 每次调用 function transfer时最末尾都需要调用的事件,用于捕获交易的日志
<11> event Approval : 每次调用 function approve时最末尾都需要调用的事件,用于捕获给予第三方代替自己做交易事件的日志
至此ERC20标准的各项方法说明已经写完；下面我们来看看ERC223标准:
各位币圈大佬都知道，现有的 ETH 代币基本上都基于 ERC20 标准实现，而 ERC20 存在某些严重问题【ERC-20标准还有待完善。其中一个障碍是，将令牌直接发送给令牌的智能合同将导致资金损失】
根据 ERC20 标准，交易(transaction)可以有两种处理方式：通过transfer函数和通过approve+transferFrom，
对于开发来说，事件处理（Event Handling）是一个标准性的操作，我们所说的交易也可以被当做一种事件进行考虑。
但是很遗憾，在 ERC20 标准中，缺乏事件处理机制，也就是说，当交易发生的时候，收款人并不会得知这一消息。
在 ERC20 标准中，我们要求用户向合约发送代币的时候，必须使用approve+transferFrom模式进行代币转账，
与此同时，如果收件人是一个账户地址，就必须使用transfer函数完成交易。
如果用户搞错了，这些代币就会由于合约无法识别交易而被困在合约中。而合约没有提供一个可以把这些困住的代币提取出来的方法。
到目前为止，大概有 $3,000,000 的损失已经发生了；
ERC223 是 ERC20 的一个升级版本。ERC223 标准提供了更安全的方法用于完成交易。
在 ERC223 标准中，交易发起方无需关注接收方到底是合约还是钱包地址，使代币交易更接近 ETH 交易。
相对比 ERC20 标准，ERC223 通过全新的transfer函数，自动回滚向不支持代币的合约发送代币的行为。
它的实现方法是定义一个接收器(receiver)，接受方合约必须通过它来正确地处理收到的代币，否则就会有异常抛出。
就好像你在发送 ETH 到一个没有payable关键字的合约一样；其实就是 【它与之前的ERC20相比，该标准更注重保护合约本身和防止您的数字代币丢失。作为ERC20的升级方案，该标准有不允许代币转到不支持代币接收和处理的合约中的功能；ERC223标准允许用户发送代币到钱包或合同地址，从而消除了丢失代币的危险性。同时ERC223中的转让合同功能让其合同的gas消耗比ERC20少。简而言之，ERC223更侧重于安全，被誉为取代ERC20的标准】，下面我们先看看具体的ERC223标准 首先我们需要有2个*.sol文件；先看看
ERC223_Interface.sol
文件的内容
contract ERC223 {
uint public totalSupply;
/**
代币名称 【同ERC20】
*/
function name() public constant returns (string _name);
/**
代币的标识符 【同ERC20】
*/
function symbol() public constant returns (string _symbol);
/**
小数点后几位 【同ERC20】
*/
function decimals() public constant returns (uint8 _decimals);
/**
代币总发行量 【同ERC20】
*/
function totalSupply() public constant returns (uint256 _supply);
/**
查询某地址余额 【同ERC20】
*/
function balanceOf(address who) public constant returns (uint);
/**
转账给 某个外部账户 【同ERC20】
*/
function transfer(address to, uint value) public returns (bool ok);
/**
转账给合约 该合约必须是实现了 名为: tokenFallback的函数
data可以附加到这个令牌交易中，它将永远保持在块状（需要更多的gas）。 _data可以是空的
*/
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);
}
另外
Receiver_Interface.sol
文件的内容为：
pragma solidity ^0.4.16;
/* * Contract that is working with ERC223 tokens */
contract ContractReceiver {
struct TKN {
address sender; //调用合约的人
uint value;
bytes data;
bytes4 sig; //签名
}
/**
该函数表明了当调用了 transfer交易函数由A(可以使任何账户) 向合约B交易token时时,函数中的逻辑必须是
_from是令牌发送者，_value是传入令牌的数量，
_data是附加的数据，类似于Ether事务中的数据。 适用于以太交易的回退功能，并且不返回任何内容。
【注意】: 过滤哪些令牌（通过token合约的账户地址）发送可以被发送很重要。
令牌发送者（谁发起了代币交易的人）将_from传入tokenFallback函数内。
【重要】: 这个函数必须命名为tokenFallback，并使用参数地址uint256，字节来匹配函数签名0xc0ee0b8a
*/
function tokenFallback(address _from, uint _value, bytes _data) public {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
/* tkn变量是Ether交易的msg变量的模拟 * tkn.sender是发起这个令牌交易的人（类似于msg.sender） * tkn.value发送的令牌数（msg.value的类比） * tkn.data是令牌交易的数据（类似于msg.data） * tkn.sig是4字节的功能签名 */
}
}
【注意:】将在接收方合约中调用的token备用功能的函数必须命名为tokenFallback，并使用参数address, uint256,bytes。 此函数必须具有0xc0ee0b8a签名[bytes4(keccak256('tonken(address,uint256,bytes)')) == c0ee0b8a ？？]
然后，当我们需要来说一说怎么用这两个文件【这些代码都是网上抄的,原作者估计也是翻译的 注释写的牛头不对马嘴，我已经建议他回去学小学语文了，因为我比较懒 也搬运了下，但是我自己知道这说的是些什么鬼！！】下面演示一个ERC223的token代币合约示例
ERC223_Token.sol
文件内容:
pragma solidity ^0.4.16;
import "./Receiver_Interface.sol";
import "./ERC223_Interface.sol";
/** * ERC223 token by Dexaran * * https://github.com/Dexaran/ERC223-token-standard */
/* https://github.com/LykkeCity/EthereumApiDotNetCore/blob/master/src/ContractBuilder/contracts/token/SafeMath.sol */
contract SafeMath {
uint256 constant public MAX_UINT256 =
0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
function safeAdd(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (x > MAX_UINT256 - y) revert();
return x + y;
}
function safeSub(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (x < y) revert();
return x - y;
}
function safeMul(uint256 x, uint256 y) constant internal returns (uint256 z) {
if (y == 0) return 0;
if (x > MAX_UINT256 / y) revert();
return x * y;
}
}
/**
ERC223示例的智能合约代码
*/
contract ERC223Token is ERC223, SafeMath {
mapping(address => uint) balances;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
// 获取token的名称
function name() public view returns (string) {
return name;
}
// 获取token的符号
function symbol() public view returns (string) {
return symbol;
}
// 获取token精确到小数点后的位数
function decimals() public view returns (uint8) {
return decimals;
}
// 获取token的发布总量
function totalSupply() public view returns (uint256) {
return totalSupply;
}
// 当用户或其他合同想要转移资金时调用的功能。
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
//如果to是合约
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert(); //如果当前的余额不够就抛出
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);//发送者的余额做减法
balances[_to] = safeAdd(balanceOf(_to), _value); //接收者的余额做加法
ContractReceiver receiver = ContractReceiver(_to); //初始化接收合约，构造函数参数为接收者的合约地址
receiver.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
// 当用户或其他合同想要转移资金时调用的功能。
function transfer(address _to, uint _value, bytes _data) public returns (bool success) {
if(isContract(_to)) {
return transferToContract(_to, _value, _data);
}
else {
return transferToAddress(_to, _value, _data);
}
}
// 类似于ERC20传输的标准功能传输，没有_data。
// 由于向后兼容性原因而增加。
function transfer(address _to, uint _value) public returns (bool success) {
//类似于没有_data的ERC20传输的标准功能传输
//由于向后兼容性原因而增加
bytes memory empty;
if(isContract(_to)) {//如果是合约
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
/**
判断某账户地址是EOA地址还是合约地址
组装定地址字节码。 如果存在字节码，那么_addr是一个合约。
*/
function isContract(address _addr) private returns (bool is_contract) {
uint length;
Assembly {
//检索目标地址上的代码大小，这需要汇编
length := extcodesize(_addr)
}
return (length>0);
}
/**
当传递目标是一个地址【即: 外部账户】时调用函数
*/
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
/**
当传递目标是一个合约【合约账户】时调用函数
【注意】token接收者是合约的话,需要调用 自定义的具备了 tokenFallback函数的 合约对象的tokenFallback函数 【要求接受token的合约必须具备了tokenFallback函数】
*/
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data); //必须要调用这个回调
Transfer(msg.sender, _to, _value, _data);
return true;
}
//得到_owner的余额
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}以上ERC223标准的token发币合约示例表示，当需要调用交易函数把ERC223标准token交易给某个合约地址时，要求合约必须具备tokenFallback函数【合约开发人员希望他们的合约使用指定的token，那么合约开发人员必须实现tokenFallback，并使用参数address,uint256，bytes。 此函数必须具有0xc0ee0b8a签名】，否则转账失败；现有的代币肯定是大部分基于 ERC20 标准的，迁移难度很大，毕竟这个事情需要大家一起动。至于新的代币，很多已经开始使用 ERC223 标准了，目前已经超过了三万种(某位网上的吊毛说的，不是我说的。。。)
好了，以上我们介绍了两种可以发行 【可代替性通证】的合约,(可代替性就是可以代替所有没有唯一性的事物，如：钱、积分等)；下面我们开始研究研究下针对【不可代替性的事物】的一些合约标准，【CryptoKitties 以太猫】相信大家都对这款曾经让以太坊网络一度瘫痪的 猫科动物繁殖类无聊烧钱游戏有一点点耳闻吧?好了，废话不多说，先上代码:
pragma solidity ^0.4.16;
/**
以太猫使用的ERC721的合约标准
*/
contract ERC721 {
// Required method
function totalSupply() public constant returns (uint256 totalSupply);
function balanceOf(address _owner) public constant returns (uint256 balance);
/**
根据代币Id查询代币持有者
*/
function ownerOf(uint256 _tokenId) public constant returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
/**
在Approve 允许的条件下, 交易方msg.sender 调用该函数可以指定_tokenId的代币从他人那转至自己名下
类似于ERC20的 transferFrom
*/
function takeOwnership(uint256 _tokenId) public;
// Optional method
function name() public constant returns (string name);
function symbol() public constant returns (string symbol);
/**
根据持有者和索引查询所持有的代币
*/
function tokenOfOwnerByIndex(address _owner, uint256 _index) public constant returns (uint tokenId);
/**
查看代币的元数据
根据代币Id查询到元数据对应的URL, 里面包含了 代币名称,图像和描述等
*/
function tokenMetadata(uint256 _tokenId) public constant returns (string infoUrl);
// Events
event Transfer(address indexed _from, address indexed _to, uint256 _tokenId);
event Approval(address indexed _owner, address indexed _approved, uint256 _tokenId);
}
我们可以看到ERC721协议其实和ERC20协议还是很类似的，代币名称、代币符号、代币支持的小数位等等，然后在这基础上做了点改动，因为在ERC721中每个代币都将是唯一的一串Hash码，且代币是可以在各个持有者间相互转让的；所以有具备查询代币持有者地址的ownerOf函数、有根据持有者及索引查询持有的某个代币的tokenOfOwnerByIndex函数等等以上在代码里面都有所说明，这里就不做赘述；
好了现在我们来看看一个叫做ERC1155的标准；首先，我们要说下不管是ERC20系【可替代性通证】还是ERC721系【不可替代性通证】的token都具备的一个问题，对于一个项目中如果有几万种完全不同性质的东西，比如: 钱是钱、积分是积分、收藏品是收藏品那么我们需要部署几万种token的合约【不管是ERC20的还是ERC721的】那么问题来了，首先这几万种合约里面必然有大量的重复代码，但是矿工们依然会把这几万种合约都上链，【注意我说的是在一个项目里面，比如: 游戏项目】，所以给每一个不同的物品设立一个独立的合约，这产生的巨大成本和之后带来的管理费用，都将是几乎让人无法承受的，那么ERC1155就是为了解决这种问题而生的，现在『物品』（可能包含ERC20的token或ERC721的token或两者都有）可以被单一的一个合约（打包处理）来定义了。合约里包含区别token们所需的最小量的数据。好比，后来出现的视频压缩技术，后一帧只记录了与前一帧的不同之处，所以极大的压缩了整个视频的体积（老板说你确定你举得这个栗子真的能更好更简单的说明这个问题？？）合约的状态包含了每个token ID的配置信息和管理收集的所有行为。ERC-1155的灵活性更强，它使得开发者可以自行选择是批量生成某一种特定的token，还是构建不可被复制的惟一元数据；说白点就是说ERC1155可以把一种token换成为另外一种token，最大进步就是可以融合不同token（可能是『可替换』的代币与『不可替换』的代币的混合体）进行『打包处理』；好了废话不多说，我们上代码，下面是一个ERC1155的合约标准
pragma solidity ^0.4.16;
/**
针对 可替代token的
https://github.com/ethereum/EIPs/issues/1155
*/
contract ERC1155 {
// Events
event Approval(address indexed _owner, address indexed _spender, uint256 indexed _itemId, uint256 _value);
event Transfer(address indexed _from, address indexed _to, uint256 indexed _itemId, uint256 _value);
// Required Functions
/**
【两个方法一个处理单个的一个批量处理】 【请参照 ERC20的transfer函数】
将每个itemId[]的数量转移到指定的地址。
每个参数数组应该是相同的长度，每个索引都是相关的。
必须触发 Transfer事件
itemId 可以看做是某个特定的tokenId
*/
function transfer(address _to, uint256 _itemId, uint256 _value) external;
function batchTransfer(address _to, uint256[] _itemIds, uint256[] _values) external;
/**
【两个方法一个处理单个的一个批量处理】 【请参照 ERC20的transferFrom函数】
将每一个itemId[]的数量从一个或多个地址转移到指定地址。
每个参数数组应该是相同的长度，每个索引都是相关的
必须触发 Transfer事件
itemId 可以看做是某个特定的tokenId
*/
function transferFrom(address _from, address _to, uint256 _itemId, uint256 _value) external;
function batchTransferFrom(address _from, address _to, uint256[] _itemIds, uint256[] _values) external;
/**
【两个方法一个处理单个的一个批量处理】 【请参照 ERC20的approve函数】
批准一个帐户可以替代表另一个帐户（使用转账）转移最大数量的多个itemId数目
必须触发 Approval事件
*/
function approve(address _spender, uint256 _itemId, uint256 _value) external;
function batchApprove(address _spender, uint256[] _itemIds, uint256[] _values) external;
/**
增加一个或多个itemId的余量，而不需要重置为0 【及变更approve函数指定的允许转移量？？】
必须触发 Approval事件
*/
function increaseApproval(address _spender, uint256 _itemId, uint256 _addedValue) external;
function batchIncreaseApproval(address _spender, uint256[] _itemIds, uint256[] _addedValues) external;
/**
减少一个或多个itemId的余量，而不需要重置为0
必须触发 Approval事件
*/
function decreaseApproval(address _spender, uint256 _itemId, uint256 _subtractedValue) external;
function batchDecreaseApproval(address _spender, uint256[] _itemIds, uint256[] _subtractedValues) external;
// Required View Functions
function totalSupply(uint256 _itemId) external view returns (uint256);
/**
根据对应的tokenId查看余额
*/
function balanceOf(uint256 _itemId, address _owner) external view returns (uint256);
/**
根据对应的tokenId及拥有者及代替拥有者花钱者(注意 钱还是话拥有者的,只是拥有者给予某些权力给 第三者可以挪用她的部分资金) 具体参照ERC20 自明
*/
function allowance(uint256 _itemId, address _owner, address _spender) external view returns (uint256);
// Optional View Functions
function name(uint256 _itemId) external view returns (string);
function symbol(uint256 _itemId) external view returns (string);
function decimals(uint256 _itemId) external view returns (uint8);
}
/**
针对不可替代token的拓展
*/
contract ERC1155NonFungible {
// Optional Functions for Non-Fungible Items
/**
For NFTs, this returns the owner of a specific _itemId.
在【 Non-Fungible Items】，返回当前tokenId 所属者 【参照ERC721】
*/
function ownerOf(uint256 _itemId) external view returns (address);
/**
返回当前tokenId的描述的URL 【参照ERC721】
*/
function itemURI(uint256 _itemId) external view returns (string);
/**
列举可用的Non-Fungible Items
*/
function itemByIndex(uint256 _itemId, uint128 _index) external view returns (uint256);
/**
列举分配给所有者的Non-Fungible Items
*/
function itemOfOwnerByIndex(uint256 _itemId, address _owner, uint128 _index) external view returns (uint256);
}
基本上就是ERC1155的注释说明。还有最后说一个ERC165标准，废话少说上代码，自己看注释就知道ERC165是干什么的了，顺便说一下CryptoKities合约里面有实现了ERC165的，实在懒得编了
/**
这个才是 ERC165 标准
就是一个接口 里面就一个方法
创建标准方法以发布和检测智能合约实现的接口
ERC165同样是一个合约标准，这个标准要求合约提供其实现了哪些接口，
这样再与合约进行交互的时候可以先调用此接口进行查询。
interfaceID为函数选择器，计算方式有两种，
如：bytes4(keccak256('supportsInterface(bytes4)'));
或ERC165.supportsInterface.selector，多个函数的接口ID为函数选择器的异或值
此功能必须返回一个bool并使用最多30,000gas
*/
interface ERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return 'true' if the contract implements 'interfaceID' and
/// 'interfaceID' is not 0xffffffff, 'false' otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}
OK〜那么我们ERC系列都就暂时写到这里，因为这一些列的问题实在是太多了如果想看，请自行去gayhub【github上我自己习惯叫gayhub】Ethereum的EIPs里面的issue里面去看吧，（注：想看什么标准就看问是否有，我们可以这样看https://github.com/ethereum/EIPs/issues/XXX,其中XXX就是ERCXXX里面的数字也就是ERC20就看https：/ /github.com/ethereum/EIPs/issues/20）
好了，夜深了，各位晚安〜