转载

使用 Web3J 发个以太坊 ERC20 Token

ERC20 为 Ethereum 上的 Token 合约标准规范，遵守该规范的 Token 合约可以被各种以太坊钱包、以及相关的平台和项目支持，如在 etherscan 上可以查看遵守 ERC20 规范的 Token 信息和交易记录。

如下为 ERC20 Token 标准接口：

 // ----------------------------------------------------------------------------
 // ERC20 Token Standard Interface
 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20-token-standard.md
 // ----------------------------------------------------------------------------
contract ERC20 {
      function name() constant returns (string name)
      function symbol() constant returns (string symbol)
      function decimals() constant returns (uint8 decimals)
      function totalSupply() constant returns (uint totalSupply);
      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);
}

其中各个接口方法：

name ：返回 ERC20 token 的名称，如：Steven Ocean Token；
symbol ：返回 ERC20 token 的简称，如：SOT；
decimals ：返回 token 使用小数点的后几位，如设置为3，表示支持 0.001；
totalSupply ：总的 token 供应量；
balanceOf ：获取指定账户(address)的余额（token 拥有量）；
transfer ：token 转账，从 token 合约的调用者账户(address)上转移（输入参数）_value 的 token 数到指定的账户(address) _to 上，并且触发 Transfer 事件；
transferFrom ：从账户地址 _from 发送数量为 _value 的 token 到账户地址 _to，且触发Transfer 事件；transferFrom 方法用于允许 Contract 代理某个账号来转移 token，条件是from 账户必须经过了 approve；
approve ：允许 _spender 多次提取发起账户中最多为 _value 个 token，如果再次调用此函数，它将以本次 _value 覆盖当前的余量；
allowance ：返回仍然允许 _spender 从 _owner 账户中提取的 token 余量；

如下两个为 event，会产生对应的 event log：

Transfer ：该事件是在 token 发生转移时触发的，包括 0 个 token 转移也会触发；
Approve ：该事件是在成功调用 approve 方法后触发；

使用 Solidity 编写 ERC20 Token

支持在以太坊上编写智能合约的语言主要有 Solidity、Serpent、LLL 和 Mutan，其中 Solidity 语法类似 Javascript，也是目前最主要的语言，Solidity 是静态类型的面向对象的编程语言，用其编写的智能合约需要通过 solc 编译器或者 IDE 环境编译成 EVM 字节码格式才能在 EVM 中执行。当编译好的合约发送到以太坊网络之后，就可以通过 web3.js 或者 web3.js API 来调用了，从而构建一个与之交互的应用。

我们下面使用在线 IDE Remix 来编写我们的智能合约：简单的发行 31415926 个 SOT tokens，支持简单的合约转账功能。

Remix 是以太坊官方推荐和维护的 IDE 环境，支持浏览器在线开发、调试、编译，也支持本地部署该 IDE 环境。

下图为使用 Remix 开发 SOT 合约的环境：

在 Remix 的 Editor 编辑器主要（通过 tab）显示了正在打开的一个或多个合约源码文件，Remix 也会自动编译合约代码，如果有编译错误，会在左边的 compile tab 页面显示。

remix 的官方文档详细介绍了 remix 的使用。

具体的合约代码如下：

pragma solidity 0.4.21;

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

contract StandardToken is Token {
    function transfer(address _to, uint256 _value) public returns (bool success) {
        if (balances[msg.sender] >= _value && _value > 0) {
            balances[msg.sender] -= _value;
            balances[_to] += _value;
            emit Transfer(msg.sender, _to, _value);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
        if (balances[_to] + _value < balances[_to]) revert(); // Check for overflows
        if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
            balances[_to] += _value;
            balances[_from] -= _value;
            allowed[_from][msg.sender] -= _value;
            emit Transfer(_from, _to, _value);
            return true;
        } else {
            return false;
        }
    }

    function balanceOf(address _owner) public constant 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);
        return true;
    }

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

    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;
}

contract SOT is StandardToken {
    string public constant name = "Steven Ocean Token";
    string public constant symbol = "SOT";
    uint256 public constant decimals = 18;
    uint256 public constant total = 31415926 * 10**decimals;

    function SOT() public {
        totalSupply = total;
        balances[msg.sender] = total;
    }

    function () public payable {
        revert();
    }
}

上述代码支持基本的合约转账和合约代理转账功能，主要围绕两个数据成员 balances 和 allowed 来实现，其中：

balance ：主要使用 map 结构缓存账号的 token 余额；
allowed ：采用二级 map 结构缓存 owner（一级 map key）授权给哪些 spender（二级 map key）可提取的 token 数 value；

编译和编码合约为 Java 代码

因为我们希望能够通过在 Java 代码中实现合约的部署和转账等功能，因为我们需要将合约转换成 Java 代码，这里采用 web3j 来转换。

web3j 转换需要提供合约的 .abi 和 .bin 文件，我们先用 solc 编译器来生成 sot.abi 和 sot.bin 文件，如下命令：

➜  sot solc sot.sol --abi --bin --optimize -o ./
➜  sot ll
total 48
-rw-r--r--  1 steven  staff   2.4K  4  7 16:30 SOT.abi
-rw-r--r--  1 steven  staff   2.9K  4  7 16:30 SOT.bin
-rw-r--r--  1 steven  staff   1.7K  4  7 16:30 StandardToken.abi
-rw-r--r--  1 steven  staff   2.1K  4  7 16:30 StandardToken.bin
-rw-r--r--  1 steven  staff   1.7K  4  7 16:30 Token.abi
-rw-r--r--  1 steven  staff     0B  4  7 16:30 Token.bin
-rw-r--r--@ 1 steven  staff   2.6K  4  7 16:29 sot.sol
➜  sot

可以看到针对每个 contract 类都生成了对应的 .abi 和 .bin 文件。

Remix IDE 中也可以通过查看 details 来获取对应的 abi 和 bin 文件。如下图：

接下来使用 web3j 将合约转换为 Java 文件：

➜  sot web3j solidity generate --javaTypes SOT.bin SOT.abi -o ./src/main/java -p io.github.stevenocean.contracts

              _      _____ _     _
             | |    |____ (_)   (_)
__      _____| |__      / /_     _   ___
/ / // / / _ / '_ /     / / |   | | / _ /
 / V  V /  __/ |_) |.___/ / | _ | || (_) |
  /_//_/ /___|_.__/ /____/| |(_)|_| /___/
                         _/ |
                        |__/

Generating io.github.stevenocean.contracts.SOT ... File written to ./src/main/java

➜  sot tree src/main/java
src/main/java
└── io
    └── github
        └── stevenocean
            └── contracts
                └── SOT.java

4 directories, 1 file
➜  sot

生成的 SOT.java 文件中生成了一个派生于 Contract 类的 SOT 合约类，该类中实现了 ERC20 token 规范的那些方法，代码摘略如下：

public class SOT extends Contract {
    private static final String BINARY = "606060......10029";

    protected SOT(String contractAddress, Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
        super(BINARY, contractAddress, web3j, credentials, gasPrice, gasLimit);
    }

    public RemoteCall<BigInteger> totalSupply() {
        final Function function = new Function("totalSupply", 
                Arrays.<Type>asList(), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
        return executeRemoteCallSingleValueReturn(function, BigInteger.class);
    }

    public RemoteCall<BigInteger> total() {
        final Function function = new Function("total", 
                Arrays.<Type>asList(), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
        return executeRemoteCallSingleValueReturn(function, BigInteger.class);
    }

    public RemoteCall<BigInteger> balanceOf(String _owner) {
        final Function function = new Function("balanceOf", 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(_owner)), 
                Arrays.<TypeReference<?>>asList(new TypeReference<Uint256>() {}));
        return executeRemoteCallSingleValueReturn(function, BigInteger.class);
    }

    public RemoteCall<TransactionReceipt> transfer(String _to, BigInteger _value) {
        final Function function = new Function(
                "transfer", 
                Arrays.<Type>asList(new org.web3j.abi.datatypes.Address(_to), 
                new org.web3j.abi.datatypes.generated.Uint256(_value)), 
                Collections.<TypeReference<?>>emptyList());
        return executeRemoteCallTransaction(function);
    }

    public static RemoteCall<SOT> deploy(Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
        return deployRemoteCall(SOT.class, web3j, credentials, gasPrice, gasLimit, BINARY, "");
    }

    public static SOT load(String contractAddress, Web3j web3j, Credentials credentials, BigInteger gasPrice, BigInteger gasLimit) {
        return new SOT(contractAddress, web3j, credentials, gasPrice, gasLimit);
    }
        
    // ...

    public static class TransferEventResponse {
        public Log log;
        public String _from;
        public String _to;
        public BigInteger _value;
    }

    public static class ApprovalEventResponse {
        public Log log;
        public String _owner;
        public String _spender;
        public BigInteger _value;
    }
}

后续可以将生成的 SOT.java 文件导入至 Java 项目中。

solidity 编译器的安装参考
web3j 安装参考

使用 Web3j 部署合约

部署合约之前先要有个自己的钱包账号的，这个账号可以用 web3j 的 WalletUtils.generateLightNewWalletFile 来创建，如下：

/// password: 提供一个生成 keystore 的密码
/// destinationDirectory: 存放 keystore 文件的路径
public static String generateLightNewWalletFile(String password, File destinationDirectory)
            throws NoSuchAlgorithmException, NoSuchProviderException,
            InvalidAlgorithmParameterException, CipherException, IOException {
        return generateNewWalletFile(password, destinationDirectory, false);
    }

刚创建好的钱包账号中的余额为 0，而部署合约是需要消耗一定的 ether 的，因此我们得先申请一点 ether，当然我们只能在测试环境下申请，在 rinkeby testnet 中，因为采用的是 PoA(clique) 共识机制，可以通过 faucet 提交如下三个支持的社交媒体的帖子URL，而对应的帖子内容中包括你需要申请 ether 的账号地址：

A public tweet on Twitter
A public Facebook post
A public Google+ link

具体的申请内容和方式请参考 How to get on Rinkeby Testnet in less than 10 minutes 的 Step 4。

申请成功之后，我们的钱包账号中就可以查到余额了，如下为在 etherscan rinkeby testnet 中查看到的账号信息：

其中 Transactions Tab 中第一条交易记录就是在 faucet 申请的 ether 的账号。

好了，ether 来了，开始使用 web3j 部署 SOT 合约，如下代码：

SOT contract = SOT.deploy(
        web3, finalCredentials,
        ManagedTransaction.GAS_PRICE,
        Contract.GAS_LIMIT).send();
String contractAddress = contract.getContractAddress();

其中 web3 为使用 Web3jFactory.build 构建的实例，如下代码为连接到 rinkeby 测试网络：

final Web3j web3 = Web3jFactory.build(
        new HttpService("https://rinkeby.infura.io/xxxxsyt4bzKIGsctxxxx"));

finalCredentials为通过 WalletUtils.loadCredentials 从本地 keystore 加载的凭证，如下代码：

/// password: 为 keystore 密码
/// source: keystore 文件路径
public static Credentials loadCredentials(String password, String source)
        throws IOException, CipherException {
    return loadCredentials(password, new File(source));
}

contract.getContractAddress()在部署成功 SOT 合约之后返回对应的合约地址。

部署成功之后，我们可以查看到对应的合约信息，如下图：

该合约信息页面中显示了合约创建者(Contract Creator)，ERC20 Token Contract 名称为 Steven Ocean Token(SOT) ，以及交易列表中显示了关联的首笔交易（ To 显示的为 Contract Creation ），交易信息如下图：

在交易信息的 Input Data 中其实承载的是 SOT 合约的 BIN 代码。

另外，可以查看 SOT token 页面，如下图：

其中显示了 SOT token 的很多信息，包括如下几个关键信息：

Total Supply ：token 总的供应量，这里为我们发行了 31415926 个 SOT；
ERC20 Contract ：展示了 SOT token 对应的合约地址，即我们在上面看到的那个截图；
Token Holders ：Token 持有者，下面的列表展示了持有 SOT 的账户地址列表；

注：上图中的 Token Transfers 中的记录是在下一步（合约转账）中完成之后出现的。

合约转账 - 给好基友转点币

我是 SOT token 的创建者，我给自己发行了 31415926 个 token，下面给好基友转点过去。继续使用 web3j 如下代码：

// 调用 SOT.transfer 方法
Function function = new Function(
        "transfer",
        Arrays.<Type>asList(new Address(friendAddress),
                new Uint256(new BigInteger("128000000000000000000"))),
        Collections.<TypeReference<?>>emptyList());
String encodedFunction = FunctionEncoder.encode(function);

// 创建 tx 管理器，并通过 txManager 来发起合约转账
RawTransactionManager txManager = new RawTransactionManager(web3, finalCredentials);
EthSendTransaction transactionResponse = txManager.sendTransaction(
        ManagedTransaction.GAS_PRICE, Contract.GAS_LIMIT, 
        contractAddress, encodedFunction, BigInteger.ZERO);

// 获取 TxHash
String transactionHash = transactionResponse.getTransactionHash();

调用成功后，会提交到以太坊网络中，在交易被确认之前，为 pending 状态，如下图：