区块链钱包-android篇

​
1：使用Protocol Buffers
 首先根目录gradle中添加依赖：

classpath "com.google.protobuf:protobuf-gradle-plugin:0.8.3"

然后项目文件中添加plugin，添加依赖包：

apply plugin: 'com.google.protobuf'

protobuf {
protoc {
artifact = 'com.google.protobuf:protoc:3.6.1'
}
plugins {
javalite {
artifact = "com.google.protobuf:protoc-gen-javalite:3.0.0"
}
grpc {
artifact = 'io.grpc:protoc-gen-grpc-java:1.17.1'
}
}
generateProtoTasks {
all().each { task ->
task.plugins {
javalite {}
grpc {
// Options added to --grpc_out
option 'lite'
}
}
}
}
configurations {
all*.exclude group: 'com.android.support', module: 'support-v13'
}
}

dependencies {
api 'io.grpc:grpc-okhttp:1.17.1'
api 'io.grpc:grpc-protobuf-lite:1.17.1'
api 'io.grpc:grpc-stub:1.17.1'
}
 最后main下添加proto路径，添加proto文件；

2：tron基础类
       关于tron的基础类，我整理了个lib，使用时直接导入lib即可。

主要包括wallet钱包类，管理类等内容。

这里我主要贴出wallet的代码

package org.tron.walletserver;

import android.os.Build;
import android.support.annotation.RequiresApi;

import org.tron.common.crypto.ECKey;
import org.tron.common.utils.Utils;

import java.math.BigInteger;

public class Wallet {
private ECKey mECKey = null;

private boolean isWatchOnly = false;
private boolean isColdWallet = false;
private String walletName = "";
private String encPassword = "";
private String address = "";
private byte[] encPrivateKey;
private byte[] publicKey;
public Wallet() {
}
public Wallet(boolean generateECKey) {
 if(generateECKey) {
 mECKey = new ECKey(Utils.getRandom());
 }
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public Wallet(String privateKey) {
 setPrivateKey(privateKey);
}
public boolean isOpen() {
 return mECKey != null && mECKey.getPrivKeyBytes() != null;
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public boolean open(String password) {
 if(encPrivateKey != null) {
 setPrivateKey(AddressUtils.decryptPrivateKey(encPrivateKey, password));
 return isOpen();
 } else {
 return false;
 }
}
public byte[] getPublicKey() {
 return mECKey != null ? mECKey.getPubKey() : publicKey;
}
public void setPublicKey(byte[] publicKey) {
 this.publicKey = publicKey;
}
public byte[] getPrivateKey() {
 return mECKey != null ? mECKey.getPrivKeyBytes() : null;
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public void setPrivateKey(String privateKey) {
 if(privateKey != null && !privateKey.isEmpty()) {
 ECKey tempKey = null;
 try {
 BigInteger priK = new BigInteger(privateKey, 16);
 tempKey = ECKey.fromPrivate(priK);
 } catch (Exception ex) {
 ex.printStackTrace();
 }
 mECKey = tempKey;
 } else {
 mECKey = null;
 }
}
public boolean isWatchOnly() {
 return isWatchOnly;
}
public void setWatchOnly(boolean watchOnly) {
 isWatchOnly = watchOnly;
}
public boolean isColdWallet() {
 return isColdWallet;
}
public void setColdWallet(boolean coldWallet) {
 isColdWallet = coldWallet;
}
public String getWalletName() {
 return walletName;
}
public void setWalletName(String walletName) {
 this.walletName = walletName;
}
public String getEncryptedPassword() {
 return encPassword;
}
public void setEncryptedPassword(String password) {
 this.encPassword = password;
}
@RequiresApi(api = Build.VERSION_CODES.KITKAT)
public String getAddress() {
 if(mECKey != null) {
 return AddressUtils.encode58Check(mECKey.getAddress());
 }
 else if (publicKey != null){
 return AddressUtils.encode58Check(ECKey.fromPublicOnly(publicKey).getAddress());
 } else {
 return address;
 }
}
public void setAddress(String address) {
 this.address = address;
}
public ECKey getECKey() {
 return mECKey;
}
public byte[] getEncryptedPrivateKey() {
 return encPrivateKey;
}
public void setEncryptedPrivateKey(byte[] encPrivateKey) {
 this.encPrivateKey = encPrivateKey;
}

}
3：导入钱包

其实就一步操作，就是根据私钥 创建wallet对象。

//根据私钥创建钱包
Wallet wallet = new Wallet(privateKey);
//设置钱包名称，我这里不需要就设置成钱包地址了。
wallet.setWalletName(wallet.getAddress());
//项目存储导入的钱包
TronManager.storeTron(wallet);

4：创建钱包
       创建钱包需要两个参数，一个是钱包名称，一个是设置的密码，钱包名称还好，重要的是密码，因为转账，导出私钥助记词等信息时，都是需要密码验证的。

Wallet wallet = new Wallet(true);
wallet.setWalletName(name);
WalletManager.store(this,wallet, pwd);
store方法是使用SharedPreferences存储当前钱包的信息，其中我们可以通过密码来获取wallet的eckey从而得到钱包的公钥和私钥。

5：钱包信息
      这里主要用到项目中grpcClient类和walletmanager类。

这个类主要封装了对应的网络请求以及钱包管理

grpcClient类的initGrpc需要传入对应的fullnode和soliditynode，这个可以去下面的地址去选择，

documentation/Official_Public_Node.md at master · tronprotocol/documentation · GitHub

查询账户需要用到账户的地址：

Protocol.Account account = WalletManager.queryAccount(address, false);
GrpcAPI.AccountNetMessage accountNetMessage = WalletManager.getAccountNet(address);
GrpcAPI.AccountResourceMessage accountResMessage = WalletManager.getAccountRes(address);
  account可以查询balance和FrozenList；

accountNetMessage 可以查询账户的带宽信息。

具体代码如下：

double balance=mAccount.getBalance()/1000000.0d;
binding.tvWalletAccount.setText(balance+"");

 long frozenTotal = 0;
 for(Protocol.Account.Frozen frozen : mAccount.getFrozenList()) {
 frozenTotal += frozen.getFrozenBalance();
 }
 binding.tvWalletTronWeight.setText((frozenTotal/1000000)+"");
 GrpcAPI.AccountNetMessage accountNetMessage = TronUtil.getAccountNet(getActivity(), wallet.getWalletName());
 long bandwidth = accountNetMessage.getNetLimit() + accountNetMessage.getFreeNetLimit();
 long bandwidthUsed = accountNetMessage.getNetUsed()+accountNetMessage.getFreeNetUsed();
 long bandwidthLeft = bandwidth - bandwidthUsed;
 binding.tvWalletBandwidth.setText(bandwidthLeft+"");

6：转账

byte[] toRaw;
try {
toRaw = WalletManager.decodeFromBase58Check(sendAddress);
} catch (IllegalArgumentException ignored) {
Toast.makeText(this,"请输入一个有效地址",Toast.LENGTH_SHORT).show();
return;
}

 double amount=Double.parseDouble(sendAmount);
 Contract.TransferContract contract = WalletManager.createTransferContract(toRaw, WalletManager.decodeFromBase58Check(mWallet.getAddress()), (long) (amount * 1000000.0d));
 Protocol.Transaction transaction = WalletManager.createTransaction4Transfer(contract);
 byte[] mTransactionBytes = transaction.toByteArray();
 try {
 mTransactionUnsigned = Protocol.Transaction.parseFrom(mTransactionBytes);
 } catch (InvalidProtocolBufferException e) {
 e.printStackTrace();
 }

根据上面的代码，获取到mTransactionUnsigned ，然后输入密码校验密码并获取到wallet的eckey。

设置时间戳，交易签名。

mTransactionSigned = TransactionUtils.setTimestamp(mTransactionUnsigned);
mTransactionSigned = TransactionUtils.sign(mTransactionSigned, mWallet.getECKey());
WalletManager.broadcastTransaction(mTransactionSigned);
最后一步是广播交易。

具体的代码可查看git。

git地址

​

本文由博客一文多发平台 OpenWrite 发布！