创建账户
体验链暂不支持调用接口的方式来创建账户,仅支持在控制台进行创建。
createAccount
创建账户,同步方式调用。
函数原型
public CreateAccountResponse createAccount(CreateAccountRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 创建账户的请求 |
CreateAccountRequest
创建账户的参数:
参数名 | 必选 | 类型 | 说明 |
account | true |
| 被创建的账户 |
accountId | true | Identity | 创建者的账户 ID |
Account,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
id | true | Identity | 被创建账户的ID |
balance | false | BigInteger | 账户的余额 |
authMap | true |
| 公钥及其对应的权重信息 |
recoverKey | true |
| 恢复密钥的公钥 |
recoverTimestamp | false | long | 上一次恢复的时间戳 |
status | false |
| 账户的状态:
|
encryptionKey | false | byte[] | 加密密钥 |
hashTypeEnum | false |
| 账户的hash类型:
|
创建账户时balance
参数需要填0
,如果要进行转账,请在创建账户成功后,单独调用转账的接口。
返回字段
返回字段 | 字段类型 | 说明 |
result |
| 创建账户的响应 |
CreateAccountResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt |
| 交易收据 |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
TransactionReceipt,具体参数见下表。
参数 | 类型 | 说明 |
result | long | 交易执行结果,0 代表成功,其他值代表失败 |
gasUsed | BigInteger | 交易执行所花费的gas费用 |
logs |
| 交易结果日志输出 |
output | byte[] | 交易的输出,此处为虚拟机的执行结果 |
LogEntry,具体参数见下表。
参数 | 类型 | 说明 |
from | Identity | 交易结果日志中的字段,代表交易发送者 |
to | Identity | 交易结果日志中的字段,代表交易接收者 |
topics | List<String> | 交易结果日志中的字段,交易执行的事件主题 |
logData | byte[] | 交易结果日志中的字段,交易执行中的日志数据 |
示例
public void createAccount() throws IOException {
// build account
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Account account = new Account();
account.setIdentity(userIdentity);
account.setBalance(BigInteger.ZERO);
account.setStatus(AccountStatus.NORMAL);
AuthMap authMap = new AuthMap();
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
//从src/main/resource目录下user.key文件中读取内容,user.key内容的生成方式,见本文档底部的附录内容
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/user.key")), keyPassword);
account.setAuthMap(authMap.updateAuth(new PublicKey(keypair), 100));
//从src/main/resource目录下recovery_user.key文件中读取内容,recovery_user.key内容的生成方式,见本文档底部的附录内容
Keypair keypairRecovery = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/recovery_user.key")), keyPassword);
account.setRecoverKey(new PublicKey(keypairRecovery));
CreateAccountRequest createAccountRequest = new CreateAccountRequest(Utils.getIdentityByName("Administrator"), account);
// create testAccount
CreateAccountResponse createAccountResponse = sdk.getAccountService().createAccount(createAccountRequest);
if (!createAccountResponse.isSuccess()) {
logger.error("createAccount failed, errorCode :{}, errorDesc: {}", createAccountResponse.getErrorCode().getErrorCode(), createAccountResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = createAccountResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("createAccount failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("createAccount success.返回信息: {}", transactionReceipt.toString());
}
}
}
asyncCreateAccount
创建账户,异步方式调用。
函数原型
public int asyncCreateAccount(CreateAccountRequest request, IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 创建账户的请求 |
callback | true |
| 回调函数 |
CreateAccountRequest,具体参数见下表。
参数名 | 必选 | 类型 | 说明 |
account | true |
| 被创建的账户 |
accountId | true | Identity | 创建者的账户 ID |
其中Account对象的属性,如下表所示。
参数 | 必选 | 类型 | 说明 |
id | true | Identity | 被创建账户的ID |
balance | false | BigInteger | 账户的余额 |
authMap | true |
| 公钥及其对应的权重信息 |
recoverKey | true |
| 恢复密钥的公钥 |
recoverTimestamp | false | long | 上一次恢复的时间戳 |
status | false |
| 账户的状态:
|
encryptionKey | false | byte[] | 加密密钥 |
hashTypeEnum | false |
| 账户的hash类型:
|
创建账户时balance
参数需要填0
,如果要进行转账,请在创建账户成功后,单独调用转账的接口。
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值。 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(CreateAccountResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
示例
public void asyncCreateAccount() throws IOException {
// build account
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Account account = new Account();
account.setIdentity(userIdentity);
account.setBalance(BigInteger.ZERO);
account.setStatus(AccountStatus.NORMAL);
AuthMap authMap = new AuthMap();
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
//从src/main/resource目录下user.key文件中读取内容,user.key内容的生成方式,见本文档底部的附录内容
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/user.key")), keyPassword);
account.setAuthMap(authMap.updateAuth(new PublicKey(keypair), 100));
//从src/main/resource目录下recovery_user.key文件中读取内容,recovery_user.key内容的生成方式,见本文档底部的附录内容
Keypair keypairRecovery = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/recovery_user.key")), keyPassword);
account.setRecoverKey(new PublicKey(keypairRecovery));
// 构建request
CreateAccountRequest createAccountRequest = new CreateAccountRequest(adminAccount.getIdentity(), account);
// 创建账号
int result = sdk.getAccountService().asyncCreateAccount(
createAccountRequest, new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
CreateAccountResponse createAccountResponse = (CreateAccountResponse) response;
if (!createAccountResponse.isSuccess()) {
logger.error("createAccount failed, errorCode :{}, errorDesc: {}", createAccountResponse.getErrorCode().getErrorCode(), createAccountResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = createAccountResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("createAccount failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("createAccount success.返回信息: {}", transactionReceipt.toString());
}
}
}
});
}
转账
transferBalance
交易转帐,同步方式调用。
函数原型
public TransferBalanceResponse transferBalance(TransferBalanceRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 交易转帐的请求 |
TransferBalanceRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
id | true | Identity | 转出账户 |
receiverId | true | Identity | 转入账户 |
amount | true | BigInteger | 转账金额 |
返回字段
返回字段 | 字段类型 | 说明 |
TransferBalanceResponse |
| 交易转账的响应 |
TransferBalanceResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void transferBalance() {
// identity 账号ID
String accountName = "tester";
Identity toIdentity = Utils.getIdentityByName(accountName);
BigInteger transferAmount = BigInteger.valueOf(100);
TransferBalanceRequest transferBalanceRequest = new TransferBalanceRequest(adminAccount.getIdentity(), toIdentity, transferAmount);
// transfer balance
// 参考错误信息说明文档,检查返回的数据
TransferBalanceResponse transferBalanceResponse = sdk.getAccountService().transferBalance(transferBalanceRequest);
if (!transferBalanceResponse.isSuccess()) {
logger.error("transferBalance failed, errorCode :{}, errorDesc: {}", transferBalanceResponse.getErrorCode().getErrorCode(), transferBalanceResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = transferBalanceResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("transferBalance failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("transferBalance success.返回信息: {}", transactionReceipt.toString());
}
}
}
asyncTransferBalance
交易转帐,异步方式调用。
函数原型
public int asyncTransferBalance(TransferBalanceRequest request, IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 交易转帐的请求 |
callback | true |
| 回调函数 |
TransferBalanceRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
id | true | Identity | 转出账户 |
receiverId | true | Identity | 转入账户 |
amount | true | BigInteger | 转账金额 |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(TransferBalanceResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncTransferBalance() {
// identity 账号ID
String accountName = "tester";
Identity toIdentity = Utils.getIdentityByName(accountName);
BigInteger transferAmount = BigInteger.valueOf(100);
TransferBalanceRequest transferBalanceRequest = new TransferBalanceRequest(adminAccount.getIdentity(), toIdentity, transferAmount);
// async transfer balance
int result = sdk.getAccountService().asyncTransferBalance(transferBalanceRequest, new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
TransferBalanceResponse transferBalanceResponse = (TransferBalanceResponse) response;
if (!transferBalanceResponse.isSuccess()) {
logger.error("transferBalance failed, errorCode :{}, errorDesc: {}", transferBalanceResponse.getErrorCode().getErrorCode(), transferBalanceResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = transferBalanceResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("transferBalance failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("transferBalance success.返回信息: {}", transactionReceipt.toString());
}
}
}
});
}
设置恢复公钥
setRecoverKey
设置恢复公钥,同步方式调用。
函数原型
public SetRecoverKeyResponse setRecoverKey(SetRecoverKeyRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 恢复公钥的请求 |
SetRecoverKeyRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要设置的账户 ID |
recoverPubKey | true | PublicKey | 新的恢复公钥 |
返回字段
返回字段 | 字段类型 | 说明 |
response |
| 恢复公钥的响应 |
SetRecoverKeyResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void setRecoverKey() throws IOException {
// identity 账号ID
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/tester.key")), keyPassword);
PublicKey recoverKey = new PublicKey(keypair);
SetRecoverKeyRequest request = new SetRecoverKeyRequest(userIdentity, recoverKey);
SetRecoverKeyResponse setRecoverKeyResponse = sdk.getAccountService().setRecoverKey(request);
if (!setRecoverKeyResponse.isSuccess()) {
logger.error("setRecoverKey failed, errorCode :{}, errorDesc: {}", setRecoverKeyResponse.getErrorCode().getErrorCode(), setRecoverKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = setRecoverKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("setRecoverKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("setRecoverKey success.返回信息: {}", transactionReceipt.toString());
}
}
}
asyncSetRecoverKey
设置恢复公钥,异步方式调用。
函数原型
public int asyncSetRecoverKey(SetRecoverKeyRequest request, IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 恢复公钥的请求 |
callback | true |
| 回调函数 |
SetRecoverKeyRequest
重置恢复公钥的参数:
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要设置的账户 ID |
recoverPubKey | true | PublicKey | 新的恢复公钥 |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(SetRecoverKeyResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncSetRecover() throws IOException {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/tester.key")), keyPassword);
PublicKey recoverKey = new PublicKey(keypair);
SetRecoverKeyRequest request = new SetRecoverKeyRequest(userIdentity, recoverKey);
int result = sdk.getAccountService().asyncSetRecoverKey(
request,
new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
SetRecoverKeyResponse setRecoverKeyResponse = (SetRecoverKeyResponse) response;
if (!setRecoverKeyResponse.isSuccess()) {
logger.error("transferBalance failed, errorCode :{}, errorDesc: {}", setRecoverKeyResponse.getErrorCode().getErrorCode(), setRecoverKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = setRecoverKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("transferBalance failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("transferBalance success.返回信息: {}", transactionReceipt.toString());
}
}
}
});
}
预重置公钥
preResetPubKey
预重置公钥,同步方式调用。
函数原型
public PreResetPubKeyResponse preResetPubKey(PreResetPubKeyRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 预重置公钥的请求 |
PreResetPubKeyRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要预重置的账户 ID |
返回字段
返回字段 | 字段类型 | 说明 |
response |
| 预重置公钥的响应 |
PreResetPubKeyResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void preResetPubKey() throws IOException {
// 获取账号权重
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Account account = sdk.getQueryService().queryAccount(userIdentity).getAccount();
AuthMap beforeAuthMap = account.getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
beforeAuthMap.updateAuth(entry.getKey(), entry.getValue() + 10);
}
// pre reset
PreResetPubKeyRequest preResetPubKeyRequest = new PreResetPubKeyRequest(userIdentity);
// sign resetPubKeyRequest
long ts = sdk.getNetwork().getSystemTimestamp();
preResetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + preResetPubKeyRequest.getTransaction().hashCode())), true);
preResetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
ArrayList<SignerBase> signers = new ArrayList<>();
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/tester.key")), keyPassword);
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, preResetPubKeyRequest);
PreResetPubKeyResponse preResetPubKeyResponse = sdk.getAccountService().preResetPubKey(preResetPubKeyRequest);
// 账户状态将改为RECOVERING
if (!preResetPubKeyResponse.isSuccess()) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", preResetPubKeyResponse.getErrorCode().getErrorCode(), preResetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = preResetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("preResetPubKey success.返回信息: {}", transactionReceipt.toString());
}
}
// reset
ResetPubKeyRequest resetPubKeyRequest = new ResetPubKeyRequest(userIdentity, beforeAuthMap);
// sign resetPubKeyRequest
ts = sdk.getNetwork().getSystemTimestamp();
resetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + resetPubKeyRequest.getTransaction().hashCode())), true);
resetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
signers = new ArrayList<>();
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, resetPubKeyRequest);
ResetPubKeyResponse resetPubKeyResponse = sdk.getAccountService().resetPublicKey(resetPubKeyRequest);
// 账户状态恢复为NORMAL
if (!resetPubKeyResponse.isSuccess()) {
logger.error("resetPublicKey failed, errorCode :{}, errorDesc: {}", resetPubKeyResponse.getErrorCode().getErrorCode(), resetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = resetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("resetPublicKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("resetPublicKey success.返回信息: {}", transactionReceipt.toString());
}
}
AuthMap afterAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
if (beforeAuthMap.getAuthMap().get(entry.getKey()).equals(afterAuthMap.getAuthMap().get(entry.getKey()))) {
logger.info("重置结果正确");
}
}
}
asyncPreResetPubKey
预重置公钥,异步方式调用。
函数原型
public int asyncPreResetPubKey(PreResetPubKeyRequest request, IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 预重置公钥的请求 |
callback | true |
| 回调函数 |
PreResetPubKeyRequest
预重置公钥的参数:
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要预重置的账户 ID |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(PreResetPubKeyResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncPreResetPubKey() throws InterruptedException, IOException {
// 获取账号权重
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Account account = sdk.getQueryService().queryAccount(userIdentity).getAccount();
AuthMap beforeAuthMap = account.getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
beforeAuthMap.updateAuth(entry.getKey(), entry.getValue() + 10);
}
// pre reset
PreResetPubKeyRequest preResetPubKeyRequest = new PreResetPubKeyRequest(userIdentity);
// sign resetPubKeyRequest
long ts = sdk.getNetwork().getSystemTimestamp();
preResetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + preResetPubKeyRequest.getTransaction().hashCode())), true);
preResetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
ArrayList<SignerBase> signers = new ArrayList<>();
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/tester.key")), keyPassword);
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, preResetPubKeyRequest);
CountDownLatch countDownLatch = new CountDownLatch(2);
int result = sdk.getAccountService().asyncPreResetPubKey(preResetPubKeyRequest, new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
PreResetPubKeyResponse preResetPubKeyResponse = (PreResetPubKeyResponse) response;
// 账户状态将改为RECOVERING
if (!preResetPubKeyResponse.isSuccess()) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", preResetPubKeyResponse.getErrorCode().getErrorCode(), preResetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = preResetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("preResetPubKey success.返回信息: {}", transactionReceipt.toString());
}
}
countDownLatch.countDown();
}
});
// reset
ResetPubKeyRequest resetPubKeyRequest = new ResetPubKeyRequest(userIdentity, beforeAuthMap);
// sign resetPubKeyRequest
ts = sdk.getNetwork().getSystemTimestamp();
resetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + resetPubKeyRequest.getTransaction().hashCode())), true);
resetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
signers = new ArrayList<>();
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, resetPubKeyRequest);
int response = sdk.getAccountService().asyncResetPubKey(
resetPubKeyRequest,
new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
ResetPubKeyResponse resetPubKeyResponse = (ResetPubKeyResponse) response;
// 账户状态恢复为NORMAL
if (!resetPubKeyResponse.isSuccess()) {
logger.error("resetPubKey failed, errorCode :{}, errorDesc: {}", resetPubKeyResponse.getErrorCode().getErrorCode(), resetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = resetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("resetPubKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("resetPubKey success.返回信息: {}", transactionReceipt.toString());
}
}
countDownLatch.countDown();
}
});
countDownLatch.await(3, TimeUnit.SECONDS);
AuthMap afterAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
if (beforeAuthMap.getAuthMap().get(entry.getKey()).equals(afterAuthMap.getAuthMap().get(entry.getKey()))) {
logger.info("重置结果正确");
}
}
}
重置公钥
resetPublicKey
重置公钥,同步方式调用。
函数原型
public ResetPubKeyResponse resetPublicKey(ResetPubKeyRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 重置公钥的请求 |
ResetPubKeyRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要重置的账户 ID |
authMap | true | AuthMap | 账户或者合约的公钥和权重值 |
返回字段
返回字段 | 字段类型 | 说明 |
response |
| 重置公钥的响应 |
ResetPubKeyResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void preResetPubKey() throws IOException {
// 获取账号权重
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Account account = sdk.getQueryService().queryAccount(userIdentity).getAccount();
AuthMap beforeAuthMap = account.getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
beforeAuthMap.updateAuth(entry.getKey(), entry.getValue() + 10);
}
// pre reset
PreResetPubKeyRequest preResetPubKeyRequest = new PreResetPubKeyRequest(userIdentity);
// sign resetPubKeyRequest
long ts = sdk.getNetwork().getSystemTimestamp();
preResetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + preResetPubKeyRequest.getTransaction().hashCode())), true);
preResetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
ArrayList<SignerBase> signers = new ArrayList<>();
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/tester.key")), keyPassword);
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, preResetPubKeyRequest);
PreResetPubKeyResponse preResetPubKeyResponse = sdk.getAccountService().preResetPubKey(preResetPubKeyRequest);
// 账户状态将改为RECOVERING
if (!preResetPubKeyResponse.isSuccess()) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", preResetPubKeyResponse.getErrorCode().getErrorCode(), preResetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = preResetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("preResetPubKey success.返回信息: {}", transactionReceipt.toString());
}
}
// reset
ResetPubKeyRequest resetPubKeyRequest = new ResetPubKeyRequest(userIdentity, beforeAuthMap);
// sign resetPubKeyRequest
ts = sdk.getNetwork().getSystemTimestamp();
resetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + resetPubKeyRequest.getTransaction().hashCode())), true);
resetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
signers = new ArrayList<>();
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, resetPubKeyRequest);
ResetPubKeyResponse resetPubKeyResponse = sdk.getAccountService().resetPublicKey(resetPubKeyRequest);
// 账户状态恢复为NORMAL
if (!resetPubKeyResponse.isSuccess()) {
logger.error("resetPublicKey failed, errorCode :{}, errorDesc: {}", resetPubKeyResponse.getErrorCode().getErrorCode(), resetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = resetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("resetPublicKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("resetPublicKey success.返回信息: {}", transactionReceipt.toString());
}
}
AuthMap afterAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
if (beforeAuthMap.getAuthMap().get(entry.getKey()).equals(afterAuthMap.getAuthMap().get(entry.getKey()))) {
logger.info("重置结果正确");
}
}
}
asyncResetPubKey
重置公钥,异步方式调用。
函数原型
public int asyncResetPubKey(ResetPubKeyRequest request,IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 重置公钥的请求 |
callback | true |
| 回调函数 |
ResetPubKeyRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要重置的账户 ID |
authMap | true | AuthMap | 账户或者合约的公钥和权重值 |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(ResetPubKeyResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncPreResetPubKey() throws InterruptedException, IOException {
// 获取账号权重
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
Account account = sdk.getQueryService().queryAccount(userIdentity).getAccount();
AuthMap beforeAuthMap = account.getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
beforeAuthMap.updateAuth(entry.getKey(), entry.getValue() + 10);
}
// pre reset
PreResetPubKeyRequest preResetPubKeyRequest = new PreResetPubKeyRequest(userIdentity);
// sign resetPubKeyRequest
long ts = sdk.getNetwork().getSystemTimestamp();
preResetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + preResetPubKeyRequest.getTransaction().hashCode())), true);
preResetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
ArrayList<SignerBase> signers = new ArrayList<>();
Pkcs8KeyOperator pkcs8KeyOperator = new Pkcs8KeyOperator();
Keypair keypair = pkcs8KeyOperator.load(IOUtil.inputStreamToByte(this.getClass().getClassLoader().getResourceAsStream("/tester.key")), keyPassword);
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, preResetPubKeyRequest);
CountDownLatch countDownLatch = new CountDownLatch(2);
int result = sdk.getAccountService().asyncPreResetPubKey(preResetPubKeyRequest, new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
PreResetPubKeyResponse preResetPubKeyResponse = (PreResetPubKeyResponse) response;
// 账户状态将改为RECOVERING
if (!preResetPubKeyResponse.isSuccess()) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", preResetPubKeyResponse.getErrorCode().getErrorCode(), preResetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = preResetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("preResetPubKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("preResetPubKey success.返回信息: {}", transactionReceipt.toString());
}
}
countDownLatch.countDown();
}
});
// reset
ResetPubKeyRequest resetPubKeyRequest = new ResetPubKeyRequest(userIdentity, beforeAuthMap);
// sign resetPubKeyRequest
ts = sdk.getNetwork().getSystemTimestamp();
resetPubKeyRequest.setTxTimeNonce(ts, BaseFixedSizeUnsignedInteger.Fixed64BitUnsignedInteger.valueOf(RandomUtil.randomize(ts + resetPubKeyRequest.getTransaction().hashCode())), true);
resetPubKeyRequest.complete();
//重置账户权限公钥(必须使用恢复密钥对应的私钥来进行签名,from与to必须相同,value为0)
signers = new ArrayList<>();
signers.add(MyCrypto.getInstance().createSigner(keypair));
sdk.getAccountService().signRequest(signers, resetPubKeyRequest);
int response = sdk.getAccountService().asyncResetPubKey(
resetPubKeyRequest,
new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
ResetPubKeyResponse resetPubKeyResponse = (ResetPubKeyResponse) response;
// 账户状态恢复为NORMAL
if (!resetPubKeyResponse.isSuccess()) {
logger.error("resetPubKey failed, errorCode :{}, errorDesc: {}", resetPubKeyResponse.getErrorCode().getErrorCode(), resetPubKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = resetPubKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("resetPubKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("resetPubKey success.返回信息: {}", transactionReceipt.toString());
}
}
countDownLatch.countDown();
}
});
countDownLatch.await(3, TimeUnit.SECONDS);
AuthMap afterAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
if (beforeAuthMap.getAuthMap().get(entry.getKey()).equals(afterAuthMap.getAuthMap().get(entry.getKey()))) {
logger.info("重置结果正确");
}
}
}
更新权重
updateAuthMap
更新权重,同步方式调用。
函数原型
public UpdateAuthMapResponse updateAuthMap(UpdateAuthMapRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 更新权重的请求 |
UpdateAuthMapRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要设置的账户 ID |
authMap | true | AuthMap | 新的权重 authmap |
返回字段
返回字段 | 字段类型 | 说明 |
response |
| 更新权重的响应 |
UpdateAuthMapResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void updateAuthMap() {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
AuthMap beforeAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
beforeAuthMap.updateAuth(entry.getKey(), entry.getValue() + 10);
}
UpdateAuthMapRequest updateAuthMapRequest = new UpdateAuthMapRequest(userIdentity, beforeAuthMap);
// 参考错误信息说明文档,检查返回的数据
UpdateAuthMapResponse updateAuthMapResponse = sdk.getAccountService().updateAuthMap(updateAuthMapRequest);
if (!updateAuthMapResponse.isSuccess()) {
logger.error("updateAuthMap failed, errorCode :{}, errorDesc: {}", updateAuthMapResponse.getErrorCode().getErrorCode(), updateAuthMapResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = updateAuthMapResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("updateAuthMap failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("updateAuthMap success.返回信息: {}", transactionReceipt.toString());
}
}
AuthMap afterAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
if (beforeAuthMap.getAuthMap().get(entry.getKey()).equals(afterAuthMap.getAuthMap().get(entry.getKey()))) {
logger.info("updateAuthMap 正确");
}
}
}
asyncUpdateAuthMap
更新权重,异步方式调用。
函数原型
public int asyncUpdateAuthMap(UpdateAuthMapRequest request,IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 更新权重的请求 |
callback | true |
| 回调函数 |
UpdateAuthMapRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 要设置的账户 ID |
authMap | true | AuthMap | 新的权重 authmap |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(UpdateAuthMapResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncUpdateAuthMap() throws InterruptedException {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
AuthMap beforeAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
beforeAuthMap.updateAuth(entry.getKey(), entry.getValue() + 10);
}
UpdateAuthMapRequest updateAuthMapRequest = new UpdateAuthMapRequest(userIdentity, beforeAuthMap);
CountDownLatch countDownLatch = new CountDownLatch(1);
int result = sdk.getAccountService().asyncUpdateAuthMap(
updateAuthMapRequest,
new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
UpdateAuthMapResponse updateAuthMapResponse = (UpdateAuthMapResponse) response;
if (!updateAuthMapResponse.isSuccess()) {
logger.error("updateAuthMap failed, errorCode :{}, errorDesc: {}", updateAuthMapResponse.getErrorCode().getErrorCode(), updateAuthMapResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = updateAuthMapResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("updateAuthMap failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("updateAuthMap success.返回信息: {}", transactionReceipt.toString());
}
}
countDownLatch.countDown();
}
});
countDownLatch.await(2, TimeUnit.SECONDS);
AuthMap afterAuthMap = sdk.getQueryService().queryAccount(userIdentity).getAccount().getAuthMap();
for (Map.Entry<PublicKey, Integer> entry : beforeAuthMap.getAuthMap().entrySet()) {
if (beforeAuthMap.getAuthMap().get(entry.getKey()).equals(afterAuthMap.getAuthMap().get(entry.getKey()))) {
logger.info("updateAuthMap 正确");
}
}
}
冻结账户
freezeAccount
冻结账户,同步方式调用。
函数原型
public FreezeAccountResponse freezeAccount(FreezeAccountRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 冻结账户的请求 |
FreezeAccountRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
id | true | Identity | 冻结账户的操作者 ID,可以为当前账户或者admin账户 |
frozenId | true | Identity | 待冻结的账户 ID |
返回字段
返回字段 | 字段类型 | 说明 |
response |
| 冻结账户的响应 |
FreezeAccountResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void freezeAccount() {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
FreezeAccountRequest freezeAccountRequest = new FreezeAccountRequest(userIdentity, userIdentity);
FreezeAccountResponse freezeAccountResponse = sdk.getAccountService().freezeAccount(freezeAccountRequest);
if (!freezeAccountResponse.isSuccess()) {
logger.error("freezeAccount failed, errorCode :{}, errorDesc: {}", freezeAccountResponse.getErrorCode().getErrorCode(), freezeAccountResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = freezeAccountResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("freezeAccount failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("freezeAccount success.返回信息: {}", transactionReceipt.toString());
}
}
}
asyncFreezeAccount
冻结账户,异步方式调用。
函数原型
public int asyncFreezeAccount(FreezeAccountRequest request,IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 冻结账户的请求 |
callback | true |
| 回调函数 |
FreezeAccountRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
id | true | Identity | 冻结账户的操作者 ID,可以为当前账户或者admin账户 |
frozenId | true | Identity | 待冻结的账户 ID |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(FreezeAccountResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncFreezeAccount() {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
FreezeAccountRequest freezeAccountRequest = new FreezeAccountRequest(userIdentity, userIdentity);
int result = sdk.getAccountService().asyncFreezeAccount(
freezeAccountRequest
, new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
FreezeAccountResponse freezeAccountResponse = (FreezeAccountResponse) response;
if (!freezeAccountResponse.isSuccess()) {
logger.error("freezeAccount failed, errorCode :{}, errorDesc: {}", freezeAccountResponse.getErrorCode().getErrorCode(), freezeAccountResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = freezeAccountResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("freezeAccount failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("freezeAccount success.返回信息: {}", transactionReceipt.toString());
}
}
}
});
}
更新加密密钥
updateEncryptionKey
更新加密密钥,同步方式调用。
函数原型
public UpdateEncryptionKeyResponse updateEncryptionKey(UpdateEncryptionKeyRequest request)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 更新加密密钥的请求。 |
UpdateEncryptionKeyRequest,具体参数如下。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 更新密钥的操作者 ID |
encryptionKey | true | byte[] | 密钥 |
返回字段
返回字段 | 字段类型 | 说明 |
response |
| 更新加密密钥的响应。 |
UpdateEncryptionKeyResponse,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void updateEncryptionKey() {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
UpdateEncryptionKeyRequest updateEncryptionKeyRequest = new UpdateEncryptionKeyRequest(userIdentity, new byte[10]);
UpdateEncryptionKeyResponse updateEncryptionKeyResponse = sdk.getAccountService().updateEncryptionKey(updateEncryptionKeyRequest);
if (!updateEncryptionKeyResponse.isSuccess()) {
logger.error("updateEncryptionKey failed, errorCode :{}, errorDesc: {}", updateEncryptionKeyResponse.getErrorCode().getErrorCode(), updateEncryptionKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = updateEncryptionKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("updateEncryptionKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("updateEncryptionKey success.返回信息: {}", transactionReceipt.toString());
}
}
}
asyncUpdateEncryptionKey
更新加密密钥,异步方式调用。
函数原型
public int asyncUpdateEncryptionKey(UpdateEncryptionKeyRequest request,IAsyncCallback callback)
请求参数
参数 | 必选 | 类型 | 说明 |
request | true |
| 更新加密密钥的请求。 |
callback | true |
| 回调函数 |
UpdateEncryptionKeyRequest,具体参数见下表。
参数 | 必选 | 类型 | 说明 |
acctId | true | Identity | 更新密钥的操作者 ID |
encryptionKey | true | byte[] | 密钥 |
同步返回字段
返回字段 | 字段类型 | 说明 |
result | int | 发送返回值 |
异步返回字段
返回字段 | 字段类型 | 说明 |
errorCode | int | SDK发送消息返回的错误码,success时为0。 |
response |
| 平台返回的响应,其中 |
(UpdateEncryptionKeyResponse)Response,具体参数见下表。
参数 | 类型 | 说明 |
transactionReceipt | 交易收据 | |
blockNumber | BigInteger | 区块号 |
txIndex | int | 交易偏移量 |
txHash | Hash | 交易hash |
isLocalTransaction | boolean | 是否为本地交易 |
示例
public void asyncUpdateEncryptionKey() {
String accountName = "tester";
Identity userIdentity = Utils.getIdentityByName(accountName);
UpdateEncryptionKeyRequest updateEncryptionKeyRequest = new UpdateEncryptionKeyRequest(userIdentity, new byte[10]);
int result = sdk.getAccountService().asyncUpdateEncryptionKey(
updateEncryptionKeyRequest,
new IAsyncCallback() {
@Override
public void onResponse(int errorCode, Response response) {
// 参考错误信息说明文档,检查返回的数据
UpdateEncryptionKeyResponse updateEncryptionKeyResponse = (UpdateEncryptionKeyResponse) response;
if (!updateEncryptionKeyResponse.isSuccess()) {
logger.error("updateEncryptionKey failed, errorCode :{}, errorDesc: {}", updateEncryptionKeyResponse.getErrorCode().getErrorCode(), updateEncryptionKeyResponse.getErrorCode().getErrorDesc());
} else {
// 交易收据
TransactionReceipt transactionReceipt = updateEncryptionKeyResponse.getTransactionReceipt();
if (transactionReceipt.getResult() != 0) {
logger.error("updateEncryptionKey failed, errorCode :{}, errorDesc: {}", ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorCode(), ErrorCode.valueOf((int) transactionReceipt.getResult()).getErrorDesc());
} else {
logger.info("updateEncryptionKey success.返回信息: {}", transactionReceipt.toString());
}
}
}
});
}
附录:user.key和recovery_user.key的内容生成
以下为user.key和recovery_user.key的内容生成方式,用户可以新建一个名为user.key和recovery_user.key的文件,将下面获取的内容复制进去,放置在项目中使用。
Demo
私钥为ecc编码格式。
import com.alipay.demo.util.CryptUtils;
import java.io.ByteArrayOutputStream;
import java.security.KeyPair;
/**
* @Description: 生成user.key和recovery_user.key
*/
public class UserKeyGen {
public static void main(String[] args) throws Exception {
//是否是国密链
boolean isSm = false;
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ByteArrayOutputStream byteArrayOutputStreamRec = new ByteArrayOutputStream();
KeyPair keyPair;
KeyPair keyPairRec;
String userKeyPassword = "123abc";
String recoverKeyPassword = "1234abc"; //推荐和userKeyPassword不一样
if (isSm) {
//国密链的写法
keyPair = CryptUtils.generateEncryptedSmPrivateKey(userKeyPassword, true, byteArrayOutputStream);
keyPairRec = CryptUtils.generateEncryptedSmPrivateKey(recoverKeyPassword, true, byteArrayOutputStreamRec);
} else {
//普通合约链的写法
keyPair = CryptUtils.generateEncryptedEcck1PrivateKey(userKeyPassword, true, byteArrayOutputStream);
keyPairRec = CryptUtils.generateEncryptedEcck1PrivateKey(recoverKeyPassword, true, byteArrayOutputStreamRec);
}
System.out.println("user.key: \n" + new String(byteArrayOutputStream.toByteArray()));
System.out.println("pub.txt: \n" + new String(CryptUtils.getPublicKeyString(keyPair).getBytes()));
System.out.println("recovery_user.key: \n" + new String(byteArrayOutputStreamRec.toByteArray()));
System.out.println("recovery_pub.txt: \n" + new String(CryptUtils.getPublicKeyString(keyPairRec).getBytes()));
}
}
CryptUtils
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.asn1.pkcs.RSAPrivateKey;
import org.bouncycastle.asn1.pkcs.RSAPublicKey;
import org.bouncycastle.asn1.sec.ECPrivateKey;
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
import org.bouncycastle.cert.X509CertificateHolder;
import org.bouncycastle.jcajce.util.DefaultJcaJceHelper;
import org.bouncycastle.jce.ECNamedCurveTable;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.jce.spec.ECNamedCurveParameterSpec;
import org.bouncycastle.openssl.*;
import org.bouncycastle.openssl.jcajce.*;
import org.bouncycastle.operator.ContentSigner;
import org.bouncycastle.operator.InputDecryptorProvider;
import org.bouncycastle.operator.OutputEncryptor;
import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
import org.bouncycastle.pkcs.PKCS10CertificationRequest;
import org.bouncycastle.pkcs.PKCS10CertificationRequestBuilder;
import org.bouncycastle.pkcs.PKCS8EncryptedPrivateKeyInfo;
import org.bouncycastle.pkcs.jcajce.JcaPKCS10CertificationRequestBuilder;
import org.bouncycastle.pkcs.jcajce.JcePKCSPBEInputDecryptorProviderBuilder;
import org.bouncycastle.util.encoders.Hex;
import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemReader;
import org.bouncycastle.util.io.pem.PemWriter;
import sun.security.x509.X509CertImpl;
import javax.security.auth.x500.X500Principal;
import java.io.*;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
*
*/
public class CryptUtils {
static{
Security.addProvider(new BouncyCastleProvider());
}
/**
*
* @param privateKey
* @param password
* @param outputStream
* @throws Exception
*/
public static void writePkcs1(PrivateKey privateKey, String password, OutputStream outputStream) throws Exception {
PemWriter pemWriter = new PemWriter(new OutputStreamWriter(outputStream));
final PEMEncryptor pemEncryptor = new JcePEMEncryptorBuilder("AES-256-CBC").build(password.toCharArray());
JcaMiscPEMGenerator gen = new JcaMiscPEMGenerator(privateKey, pemEncryptor);
PemObject obj = gen.generate();
pemWriter.writeObject(obj);
pemWriter.close();
}
/**
*
* @param privateKey
* @param password
* @param outputStream
* @throws Exception
*/
public static void writePkcs8(PrivateKey privateKey, String password, OutputStream outputStream) throws Exception {
PemWriter pemWriter = new PemWriter(new OutputStreamWriter(outputStream));
JceOpenSSLPKCS8EncryptorBuilder encryptorBuilder = new JceOpenSSLPKCS8EncryptorBuilder(
PKCS8Generator.PBE_SHA1_3DES);
encryptorBuilder.setRandom(new SecureRandom());
encryptorBuilder.setPasssword(password.toCharArray());
OutputEncryptor oe = encryptorBuilder.build();
JcaPKCS8Generator gen = new JcaPKCS8Generator(privateKey, oe);
pemWriter.writeObject(gen.generate());
pemWriter.close();
}
/**
*
* @param password
* @param isPkcs8
* @param outputStream
* @return
* @throws Exception
*/
public static KeyPair generateEncryptedSmPrivateKey(String password, Boolean isPkcs8, OutputStream outputStream)
throws Exception {
ECNamedCurveParameterSpec ecNamedCurveParameterSpec = ECNamedCurveTable.getParameterSpec("sm2p256v1");
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC");
keyPairGenerator.initialize(ecNamedCurveParameterSpec, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
if (!isPkcs8) {
writePkcs1(keyPair.getPrivate(), password, outputStream);
} else {
writePkcs8(keyPair.getPrivate(), password, outputStream);
}
return keyPair;
}
/**
*
* @param password
* @param isPkcs8
* @param outputStream
* @return
* @throws Exception
*/
public static KeyPair generateEncryptedEcck1PrivateKey(String password, Boolean isPkcs8, OutputStream outputStream)
throws Exception {
ECNamedCurveParameterSpec ecParameterSpec = ECNamedCurveTable.getParameterSpec("secp256k1");
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ECDSA", "BC");
keyPairGenerator.initialize(ecParameterSpec, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
if (!isPkcs8) {
writePkcs1(keyPair.getPrivate(), password, outputStream);
} else {
writePkcs8(keyPair.getPrivate(), password, outputStream);
}
return keyPair;
}
/**
*
* @param keyPair
* @return
* @throws Exception
*/
public static String getPublicKeyString(KeyPair keyPair) throws Exception {
ECPrivateKey ecPrivateKey = ECPrivateKey.getInstance(
PrivateKeyInfo.getInstance(keyPair.getPrivate().getEncoded()).parsePrivateKey());
byte[] originalBytes = ecPrivateKey.getPublicKey().getBytes();
byte[] transform = new byte[originalBytes.length - 1];
System.arraycopy(originalBytes, 1, transform, 0, transform.length);
return Hex.toHexString(transform);
}
}
此工具类需要依赖以下两个JAR包,在Mychain Java SDK中已进行了依赖,无需再单独做处理。