賬戶介面 - - 阿里雲

建立賬戶

createAccount

建立賬戶，同步方式調用。

函數原型

public CreateAccountResponse createAccount(CreateAccountRequest request)

請求參數

參數	必選	類型	說明
request	true	`CreateAccountRequest`	建立賬戶的請求

CreateAccountRequest

建立賬戶的參數：

參數名	必選	類型	說明
account	true	`Account`	被建立的賬戶
accountId	true	Identity	建立者的賬戶 ID

Account，具體參數見下表。

參數	必選	類型	說明
id	true	Identity	被建立賬戶的ID
balance	false	BigInteger	賬戶的餘額
authMap	true	`AuthMap`	公開金鑰及其對應的權重資訊
recoverKey	true	`PublicKey`	修復金鑰的公開金鑰
recoverTimestamp	false	long	上一次恢複的時間戳記
status	false	`AccountStatus`	賬戶的狀態： NORMAL(0) FREEZE(1) RECOVERING(2)
encryptionKey	false	byte[]	加密金鑰
hashTypeEnum	false	`HashTypeEnum`	賬戶的hash類型： SHA256（0） SM3（1） Keccak（2）

說明

建立賬戶時balance參數需要填0，如果要進行轉賬，請在建立賬戶成功後，單獨調用轉賬的介面。

返回欄位

返回欄位	欄位類型	說明
result	`CreateAccountResponse`	建立賬戶的響應

CreateAccountResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`TransactionReceipt`	交易收據
blockNumber	BigInteger	區塊號
txIndex	int	交易位移量
txHash	Hash	交易hash
isLocalTransaction	boolean	是否為本地交易

TransactionReceipt，具體參數見下表。

參數	類型	說明
result	long	交易執行結果，0 代表成功，其他值代表失敗
gasUsed	BigInteger	交易執行所花費的gas費用
logs	`List<logEntry>`	交易結果日誌輸出
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	`CreateAccountRequest`	建立賬戶的請求
callback	true	`IAsyncCallback`	回呼函數

CreateAccountRequest，具體參數見下表。

參數名	必選	類型	說明
account	true	`Account`	被建立的賬戶
accountId	true	Identity	建立者的賬戶 ID

其中Account對象的屬性，如下表所示。

參數	必選	類型	說明
id	true	Identity	被建立賬戶的ID
balance	false	BigInteger	賬戶的餘額
authMap	true	`AuthMap`	公開金鑰及其對應的權重資訊
recoverKey	true	`PublicKey`	修復金鑰的公開金鑰
recoverTimestamp	false	long	上一次恢複的時間戳記
status	false	`AccountStatus`	賬戶的狀態： NORMAL(0) FREEZE(1) RECOVERING(2)
encryptionKey	false	byte[]	加密金鑰
hashTypeEnum	false	`HashTypeEnum`	賬戶的hash類型： SHA256（0） SM3（1） Keccak（2）

說明

建立賬戶時balance參數需要填0，如果要進行轉賬，請在建立賬戶成功後，單獨調用轉賬的介面。

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值。

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(CreateAccountResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	交易轉帳的請求

TransferBalanceRequest，具體參數見下表。

參數	必選	類型	說明
id	true	Identity	轉出賬戶
receiverId	true	Identity	轉入賬戶
amount	true	BigInteger	轉賬金額

返回欄位

返回欄位	欄位類型	說明
TransferBalanceResponse	`TransferBalanceResponse`	交易轉賬的響應

TransferBalanceResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`TransferBalanceRequest`	交易轉帳的請求
callback	true	`IAsyncCallback`	回呼函數

TransferBalanceRequest，具體參數見下表。

參數	必選	類型	說明
id	true	Identity	轉出賬戶
receiverId	true	Identity	轉入賬戶
amount	true	BigInteger	轉賬金額

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(TransferBalanceResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	恢複公開金鑰的請求

SetRecoverKeyRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	要設定的賬戶 ID
recoverPubKey	true	PublicKey	新的恢複公開金鑰

返回欄位

返回欄位	欄位類型	說明
response	`SetRecoverKeyResponse`	恢複公開金鑰的響應

SetRecoverKeyResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`SetRecoverKeyRequest`	恢複公開金鑰的請求
callback	true	`IAsyncCallback`	回呼函數

SetRecoverKeyRequest

重設恢複公開金鑰的參數：

參數	必選	類型	說明
acctId	true	Identity	要設定的賬戶 ID
recoverPubKey	true	PublicKey	新的恢複公開金鑰

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(SetRecoverKeyResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	預重設公開金鑰的請求

PreResetPubKeyRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	要預重設的賬戶 ID

返回欄位

返回欄位	欄位類型	說明
response	`PreResetPubKeyResponse`	預重設公開金鑰的響應

PreResetPubKeyResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`PreResetPubKeyRequest`	預重設公開金鑰的請求
callback	true	`IAsyncCallback`	回呼函數

PreResetPubKeyRequest

預重設公開金鑰的參數：

參數	必選	類型	說明
acctId	true	Identity	要預重設的賬戶 ID

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(PreResetPubKeyResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	重設公開金鑰的請求

ResetPubKeyRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	要重設的賬戶 ID
authMap	true	AuthMap	賬戶或者合約的公開金鑰和權重值

返回欄位

返回欄位	欄位類型	說明
response	`ResetPubKeyResponse`	重設公開金鑰的響應

ResetPubKeyResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`ResetPubKeyRequest`	重設公開金鑰的請求
callback	true	`IAsyncCallback`	回呼函數

ResetPubKeyRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	要重設的賬戶 ID
authMap	true	AuthMap	賬戶或者合約的公開金鑰和權重值

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(ResetPubKeyResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	更新權重的請求

UpdateAuthMapRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	要設定的賬戶 ID
authMap	true	AuthMap	新的權重 authmap

返回欄位

返回欄位	欄位類型	說明
response	`UpdateAuthMapResponse`	更新權重的響應

UpdateAuthMapResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`UpdateAuthMapRequest`	更新權重的請求
callback	true	`IAsyncCallback`	回呼函數

UpdateAuthMapRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	要設定的賬戶 ID
authMap	true	AuthMap	新的權重 authmap

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(UpdateAuthMapResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	凍結賬戶的請求

FreezeAccountRequest，具體參數見下表。

參數	必選	類型	說明
id	true	Identity	凍結賬戶的操作者 ID，可以為當前賬戶或者admin賬戶
frozenId	true	Identity	待凍結的賬戶 ID

返回欄位

返回欄位	欄位類型	說明
response	`FreezeAccountResponse`	凍結賬戶的響應

FreezeAccountResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`FreezeAccountRequest`	凍結賬戶的請求
callback	true	`IAsyncCallback`	回呼函數

FreezeAccountRequest，具體參數見下表。

參數	必選	類型	說明
id	true	Identity	凍結賬戶的操作者 ID，可以為當前賬戶或者admin賬戶
frozenId	true	Identity	待凍結的賬戶 ID

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(FreezeAccountResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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`	更新加密金鑰的請求。

UpdateEncryptionKeyRequest，具體參數如下。

參數	必選	類型	說明
acctId	true	Identity	更新密鑰的操作者 ID
encryptionKey	true	byte[]	密鑰

返回欄位

返回欄位	欄位類型	說明
response	`UpdateEncryptionKeyResponse`	更新加密金鑰的響應。

UpdateEncryptionKeyResponse，具體參數見下表。

參數	類型	說明
transactionReceipt	`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	`UpdateEncryptionKeyRequest`	更新加密金鑰的請求。
callback	true	`IAsyncCallback`	回呼函數

UpdateEncryptionKeyRequest，具體參數見下表。

參數	必選	類型	說明
acctId	true	Identity	更新密鑰的操作者 ID
encryptionKey	true	byte[]	密鑰

同步返回欄位

返回欄位	欄位類型	說明
result	int	發送傳回值

非同步返回欄位

返回欄位	欄位類型	說明
errorCode	int	SDK發送訊息返回的錯誤碼，success時為0。
response	`Response`	平台返回的響應，其中 `response.getErrorCode()`是平台返回的錯誤碼。

(UpdateEncryptionKeyResponse)Response，具體參數見下表。

參數	類型	說明
transactionReceipt	`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中已進行了依賴，無需再單獨做處理。