From d465fe98db951d9f25a5437d5925fcca75f37ac6 Mon Sep 17 00:00:00 2001 From: chaozhu Date: Thu, 20 Oct 2022 18:54:54 -0700 Subject: [PATCH 1/8] feat(wallet-cli): new stake, add wallet-cli commands --- src/main/java/org/tron/walletcli/Client.java | 225 ++++++++++++++++++ .../org/tron/walletcli/WalletApiWrapper.java | 53 +++++ .../org/tron/walletserver/GrpcClient.java | 21 ++ .../java/org/tron/walletserver/WalletApi.java | 132 ++++++++++ src/main/protos/api/api.proto | 18 ++ src/main/protos/core/Tron.proto | 18 ++ .../core/contract/balance_contract.proto | 30 +++ 7 files changed, 497 insertions(+) diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index f84d5c731..e9cfcee39 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -96,6 +96,7 @@ public class Client { "ExchangeTransaction", "ExchangeWithdraw", "FreezeBalance", + "FreezeBalanceV2", "GenerateAddress", // "GenerateShieldedAddress", "GenerateShieldedTRC20Address", @@ -192,6 +193,7 @@ public class Client { "TriggerContract contractAddress method args isHex fee_limit value", "UnfreezeAsset", "UnfreezeBalance", + "UnfreezeBalanceV2", "UpdateAccount", "UpdateAccountPermission", "UpdateAsset", @@ -201,6 +203,9 @@ public class Client { "UpdateWitness", "VoteWitness", "WithdrawBalance", + "WithdrawExpireUnfreeze", + "DelegateResource", + "UnDelegateResource", }; // note: this is sorted by alpha @@ -1243,6 +1248,45 @@ private void freezeBalance(String[] parameters) } } + private void freezeBalanceV2(String[] parameters) + throws IOException, CipherException, CancelException { + if (parameters == null || !(parameters.length == 2 || parameters.length == 3)) { + System.out.println("Use freezeBalanceV2 command with below syntax: "); + System.out.println("freezeBalanceV2 [OwnerAddress] frozen_balance " + + "[ResourceCode:0 BANDWIDTH,1 ENERGY,2 TRON_POWER]"); + return; + } + + int index = 0; + boolean hasOwnerAddressPara = false; + byte[] ownerAddress = getAddressBytes(parameters[index]); + if (ownerAddress != null) { + index++; + hasOwnerAddressPara = true; + } + + long frozen_balance = Long.parseLong(parameters[index++]); + int resourceCode = 0; + + if ((!hasOwnerAddressPara && (parameters.length == 2)) || + (hasOwnerAddressPara && (parameters.length == 3))) { + try { + resourceCode = Integer.parseInt(parameters[index]); + } catch (NumberFormatException e) { + System.out.println("freezeBalanceV2 [ResourceCode:0 BANDWIDTH,1 ENERGY,2 TRON_POWER]"); + return; + } + } + + boolean result = walletApiWrapper.freezeBalanceV2(ownerAddress, frozen_balance + , resourceCode); + if (result) { + System.out.println("freezeBalanceV2 successful !!!"); + } else { + System.out.println("freezeBalanceV2 failed !!!"); + } + } + private void unfreezeBalance(String[] parameters) throws IOException, CipherException, CancelException { if (parameters == null || parameters.length < 1 || parameters.length > 3) { @@ -1281,6 +1325,167 @@ private void unfreezeBalance(String[] parameters) } } + private void unfreezeBalanceV2(String[] parameters) + throws IOException, CipherException, CancelException { + if (parameters == null || !(parameters.length == 2 || parameters.length == 3)) { + System.out.println("Use unfreezeBalanceV2 command with below syntax: "); + System.out.println( + "unfreezeBalanceV2 [OwnerAddress] unfreezeBalance ResourceCode(0 BANDWIDTH,1 ENERGY,2 TRON_POWER)"); + return; + } + + int index = 0; + byte[] ownerAddress = null; + int unfreezeBalance = 0; + int resourceCode = 0; + if (parameters.length == 2) { + unfreezeBalance = Integer.parseInt(parameters[index++]); + resourceCode = Integer.parseInt(parameters[index++]); + } else if (parameters.length == 3) { + ownerAddress = getAddressBytes(parameters[index]); + if (ownerAddress != null) { + index++; + unfreezeBalance = Integer.parseInt(parameters[index++]); + resourceCode = Integer.parseInt(parameters[index++]); + } else { + System.out.println( + "unfreezeBalanceV2 OwnerAddress is invalid"); + return; + } + } + + boolean result = walletApiWrapper.unfreezeBalanceV2(ownerAddress, unfreezeBalance, resourceCode); + if (result) { + System.out.println("unfreezeBalanceV2 successful !!!"); + } else { + System.out.println("unfreezeBalanceV2 failed !!!"); + } + } + + private void withdrawExpireUnfreeze(String[] parameters) + throws IOException, CipherException, CancelException { + if (parameters == null || !(parameters.length == 0 || parameters.length == 1)) { + System.out.println("Use withdrawExpireUnfreeze command with below syntax: "); + System.out.println( + "withdrawExpireUnfreeze OwnerAddress"); + return; + } + + byte[] ownerAddress = null; + if (parameters.length == 1) { + ownerAddress = getAddressBytes(parameters[0]); + if (ownerAddress == null) { + System.out.println( + "withdrawExpireUnfreeze OwnerAddress is invalid"); + return; + } + } + + boolean result = walletApiWrapper.withdrawExpireUnfreeze(ownerAddress); + if (result) { + System.out.println("withdrawExpireUnfreeze successful !!!"); + } else { + System.out.println("withdrawExpireUnfreeze failed !!!"); + } + } + + private void delegateResource(String[] parameters) + throws IOException, CipherException, CancelException { + if (parameters == null || !(parameters.length == 3 || parameters.length == 4)) { + System.out.println("Use delegateResource command with below syntax: "); + System.out.println( + "delegateResource [OwnerAddress] balance ResourceCode(0 BANDWIDTH,1 ENERGY), ReceiverAddress"); + return; + } + + int index = 0; + byte[] ownerAddress = null; + int balance = 0; + int resourceCode = 0; + byte[] receiverAddress = null; + if (parameters.length == 3) { + balance = Integer.parseInt(parameters[index++]); + resourceCode = Integer.parseInt(parameters[index++]); + receiverAddress = getAddressBytes(parameters[index++]); + if (receiverAddress == null) { + System.out.println( + "delegateResource receiverAddress is invalid"); + return; + } + } else if (parameters.length == 4) { + ownerAddress = getAddressBytes(parameters[index++]); + if (ownerAddress != null) { + balance = Integer.parseInt(parameters[index++]); + resourceCode = Integer.parseInt(parameters[index++]); + receiverAddress = getAddressBytes(parameters[index++]); + if (receiverAddress == null) { + System.out.println( + "delegateResource receiverAddress is invalid"); + return; + } + } if (ownerAddress == null) { + System.out.println( + "delegateResource ownerAddress is invalid"); + return; + } + } + + boolean result = walletApiWrapper.delegateresource(ownerAddress, balance, resourceCode, receiverAddress); + if (result) { + System.out.println("delegateResource successful !!!"); + } else { + System.out.println("delegateResource failed !!!"); + } + } + + private void unDelegateResource(String[] parameters) + throws IOException, CipherException, CancelException { + if (parameters == null || !(parameters.length == 3 || parameters.length == 4)) { + System.out.println("Use unDelegateResource command with below syntax: "); + System.out.println( + "unDelegateResource [OwnerAddress] balance ResourceCode(0 BANDWIDTH,1 ENERGY), ReceiverAddress"); + return; + } + + int index = 0; + byte[] ownerAddress = null; + int balance = 0; + int resourceCode = 0; + byte[] receiverAddress = null; + if (parameters.length == 3) { + balance = Integer.parseInt(parameters[index++]); + resourceCode = Integer.parseInt(parameters[index++]); + receiverAddress = getAddressBytes(parameters[index++]); + if (receiverAddress == null) { + System.out.println( + "unDelegateResource receiverAddress is invalid"); + return; + } + } else if (parameters.length == 4) { + ownerAddress = getAddressBytes(parameters[index++]); + if (ownerAddress != null) { + balance = Integer.parseInt(parameters[index++]); + resourceCode = Integer.parseInt(parameters[index++]); + receiverAddress = getAddressBytes(parameters[index++]); + if (receiverAddress == null) { + System.out.println( + "unDelegateResource receiverAddress is invalid"); + return; + } + } if (ownerAddress == null) { + System.out.println( + "unDelegateResource ownerAddress is invalid"); + return; + } + } + boolean result = walletApiWrapper.undelegateresource(ownerAddress, balance, resourceCode, receiverAddress); + if (result) { + System.out.println("unDelegateResource successful !!!"); + } else { + System.out.println("unDelegateResource failed !!!"); + } + } + private void unfreezeAsset(String[] parameters) throws IOException, CipherException, CancelException { System.out.println("Use UnfreezeAsset command like: "); @@ -4001,10 +4206,30 @@ private void run() { freezeBalance(parameters); break; } + case "freezebalancev2": { + freezeBalanceV2(parameters); + break; + } case "unfreezebalance": { unfreezeBalance(parameters); break; } + case "unfreezebalancev2": { + unfreezeBalanceV2(parameters); + break; + } + case "withdrawexpireunfreeze": { + withdrawExpireUnfreeze(parameters); + break; + } + case "delegateresource": { + delegateResource(parameters); + break; + } + case "undelegateresource": { + unDelegateResource(parameters); + break; + } case "withdrawbalance": { withdrawBalance(parameters); break; diff --git a/src/main/java/org/tron/walletcli/WalletApiWrapper.java b/src/main/java/org/tron/walletcli/WalletApiWrapper.java index 5778eceaa..1b5b7bf66 100644 --- a/src/main/java/org/tron/walletcli/WalletApiWrapper.java +++ b/src/main/java/org/tron/walletcli/WalletApiWrapper.java @@ -482,6 +482,17 @@ public boolean freezeBalance(byte[] ownerAddress, long frozen_balance, long froz receiverAddress); } + public boolean freezeBalanceV2(byte[] ownerAddress, long frozen_balance, + int resourceCode) + throws CipherException, IOException, CancelException { + if (wallet == null || !wallet.isLoginState()) { + System.out.println("Warning: freezeBalanceV2 failed, Please login first !!"); + return false; + } + + return wallet.freezeBalanceV2(ownerAddress, frozen_balance, resourceCode); + } + public boolean buyStorage(byte[] ownerAddress, long quantity) throws CipherException, IOException, CancelException { if (wallet == null || !wallet.isLoginState()) { @@ -523,6 +534,48 @@ public boolean unfreezeBalance(byte[] ownerAddress, int resourceCode, byte[] rec return wallet.unfreezeBalance(ownerAddress, resourceCode, receiverAddress); } + public boolean unfreezeBalanceV2(byte[] ownerAddress, int unfreezeBalance + , int resourceCode) + throws CipherException, IOException, CancelException { + if (wallet == null || !wallet.isLoginState()) { + System.out.println("Warning: unfreezeBalanceV2 failed, Please login first !!"); + return false; + } + + return wallet.unfreezeBalanceV2(ownerAddress, unfreezeBalance, resourceCode); + } + + public boolean withdrawExpireUnfreeze(byte[] ownerAddress) + throws CipherException, IOException, CancelException { + if (wallet == null || !wallet.isLoginState()) { + System.out.println("Warning: withdrawExpireUnfreeze failed, Please login first !!"); + return false; + } + + return wallet.withdrawExpireUnfreeze(ownerAddress); + } + + public boolean delegateresource(byte[] ownerAddress, int balance + , int resourceCode, byte[] receiverAddress) + throws CipherException, IOException, CancelException { + if (wallet == null || !wallet.isLoginState()) { + System.out.println("Warning: delegateresource failed, Please login first !!"); + return false; + } + + return wallet.delegateResource(ownerAddress, balance, resourceCode, receiverAddress); + } + + public boolean undelegateresource(byte[] ownerAddress, int balance + , int resourceCode, byte[] receiverAddress) + throws CipherException, IOException, CancelException { + if (wallet == null || !wallet.isLoginState()) { + System.out.println("Warning: undelegateresource failed, Please login first !!"); + return false; + } + + return wallet.unDelegateResource(ownerAddress, balance, resourceCode, receiverAddress); + } public boolean unfreezeAsset(byte[] ownerAddress) throws CipherException, IOException, CancelException { diff --git a/src/main/java/org/tron/walletserver/GrpcClient.java b/src/main/java/org/tron/walletserver/GrpcClient.java index 2ea3ea9c0..4586ee007 100644 --- a/src/main/java/org/tron/walletserver/GrpcClient.java +++ b/src/main/java/org/tron/walletserver/GrpcClient.java @@ -43,6 +43,7 @@ import org.tron.protos.contract.AssetIssueContractOuterClass.TransferAssetContract; import org.tron.protos.contract.AssetIssueContractOuterClass.UnfreezeAssetContract; import org.tron.protos.contract.AssetIssueContractOuterClass.UpdateAssetContract; +import org.tron.protos.contract.BalanceContract; import org.tron.protos.contract.BalanceContract.FreezeBalanceContract; import org.tron.protos.contract.BalanceContract.TransferContract; import org.tron.protos.contract.BalanceContract.UnfreezeBalanceContract; @@ -263,6 +264,10 @@ public TransactionExtention createTransaction2(FreezeBalanceContract contract) { return blockingStubFull.freezeBalance2(contract); } + public TransactionExtention createTransaction2(BalanceContract.FreezeBalanceV2Contract contract) { + return blockingStubFull.freezeBalanceV2(contract); + } + public Transaction createTransaction(WithdrawBalanceContract contract) { return blockingStubFull.withdrawBalance(contract); } @@ -279,6 +284,22 @@ public TransactionExtention createTransaction2(UnfreezeBalanceContract contract) return blockingStubFull.unfreezeBalance2(contract); } + public TransactionExtention createTransactionV2(BalanceContract.UnfreezeBalanceV2Contract contract) { + return blockingStubFull.unfreezeBalanceV2(contract); + } + + public TransactionExtention createTransactionV2(BalanceContract.WithdrawExpireUnfreezeContract contract) { + return blockingStubFull.withdrawExpireUnfreeze(contract); + } + + public TransactionExtention createTransactionV2(BalanceContract.DelegateResourceContract contract) { + return blockingStubFull.delegateResource(contract); + } + + public TransactionExtention createTransactionV2(BalanceContract.UnDelegateResourceContract contract) { + return blockingStubFull.unDelegateResource(contract); + } + public Transaction createTransaction(UnfreezeAssetContract contract) { return blockingStubFull.unfreezeAsset(contract); } diff --git a/src/main/java/org/tron/walletserver/WalletApi.java b/src/main/java/org/tron/walletserver/WalletApi.java index a000cace5..94db3fbe1 100644 --- a/src/main/java/org/tron/walletserver/WalletApi.java +++ b/src/main/java/org/tron/walletserver/WalletApi.java @@ -123,6 +123,7 @@ import org.tron.protos.contract.AssetIssueContractOuterClass.TransferAssetContract; import org.tron.protos.contract.AssetIssueContractOuterClass.UnfreezeAssetContract; import org.tron.protos.contract.AssetIssueContractOuterClass.UpdateAssetContract; +import org.tron.protos.contract.BalanceContract; import org.tron.protos.contract.BalanceContract.FreezeBalanceContract; import org.tron.protos.contract.BalanceContract.TransferContract; import org.tron.protos.contract.BalanceContract.UnfreezeBalanceContract; @@ -1295,6 +1296,20 @@ public boolean freezeBalance( } } + public boolean freezeBalanceV2( + byte[] ownerAddress, + long frozen_balance, + int resourceCode) + throws CipherException, IOException, CancelException { + BalanceContract.FreezeBalanceV2Contract contract = + createFreezeBalanceContractV2( + ownerAddress, frozen_balance, resourceCode); + + TransactionExtention transactionExtention = rpcCli.createTransaction2(contract); + return processTransactionExtention(transactionExtention); + } + + public boolean buyStorage(byte[] ownerAddress, long quantity) throws CipherException, IOException, CancelException { BuyStorageContract contract = createBuyStorageContract(ownerAddress, quantity); @@ -1342,6 +1357,23 @@ private FreezeBalanceContract createFreezeBalanceContract( return builder.build(); } + private BalanceContract.FreezeBalanceV2Contract createFreezeBalanceContractV2( + byte[] address, + long frozen_balance, + int resourceCode) { + if (address == null) { + address = getAddress(); + } + + BalanceContract.FreezeBalanceV2Contract.Builder builder = BalanceContract.FreezeBalanceV2Contract.newBuilder(); + ByteString byteAddress = ByteString.copyFrom(address); + builder.setOwnerAddress(byteAddress) + .setFrozenBalance(frozen_balance) + .setResourceValue(resourceCode); + + return builder.build(); + } + private BuyStorageContract createBuyStorageContract(byte[] address, long quantity) { if (address == null) { address = getAddress(); @@ -1391,6 +1423,41 @@ public boolean unfreezeBalance(byte[] ownerAddress, int resourceCode, byte[] rec } } + public boolean unfreezeBalanceV2(byte[] ownerAddress, int unfreezeBalance + , int resourceCode) + throws CipherException, IOException, CancelException { + BalanceContract.UnfreezeBalanceV2Contract contract = + createUnfreezeBalanceContractV2(ownerAddress, unfreezeBalance, resourceCode); + TransactionExtention transactionExtention = rpcCli.createTransactionV2(contract); + return processTransactionExtention(transactionExtention); + } + + public boolean withdrawExpireUnfreeze(byte[] ownerAddress) + throws CipherException, IOException, CancelException { + BalanceContract.WithdrawExpireUnfreezeContract contract = + createWithdrawExpireUnfreezeContract(ownerAddress); + TransactionExtention transactionExtention = rpcCli.createTransactionV2(contract); + return processTransactionExtention(transactionExtention); + } + + public boolean delegateResource(byte[] ownerAddress, int balance + ,int resourceCode, byte[] receiverAddress) + throws CipherException, IOException, CancelException { + BalanceContract.DelegateResourceContract contract = + createDelegateResourceContract(ownerAddress, balance, resourceCode, receiverAddress); + TransactionExtention transactionExtention = rpcCli.createTransactionV2(contract); + return processTransactionExtention(transactionExtention); + } + + public boolean unDelegateResource(byte[] ownerAddress, int balance + ,int resourceCode, byte[] receiverAddress) + throws CipherException, IOException, CancelException { + BalanceContract.UnDelegateResourceContract contract = + createUnDelegateResourceContract(ownerAddress, balance, resourceCode, receiverAddress); + TransactionExtention transactionExtention = rpcCli.createTransactionV2(contract); + return processTransactionExtention(transactionExtention); + } + private UnfreezeBalanceContract createUnfreezeBalanceContract( byte[] address, int resourceCode, byte[] receiverAddress) { if (address == null) { @@ -1411,6 +1478,71 @@ private UnfreezeBalanceContract createUnfreezeBalanceContract( return builder.build(); } + private BalanceContract.UnfreezeBalanceV2Contract createUnfreezeBalanceContractV2( + byte[] address, int unfreezeBalance, int resourceCode) { + if (address == null) { + address = getAddress(); + } + + BalanceContract.UnfreezeBalanceV2Contract.Builder builder = + BalanceContract.UnfreezeBalanceV2Contract.newBuilder(); + ByteString byteAddreess = ByteString.copyFrom(address); + builder.setOwnerAddress(byteAddreess).setResourceValue(resourceCode).setUnfreezeBalance(unfreezeBalance); + + return builder.build(); + } + + private BalanceContract.WithdrawExpireUnfreezeContract createWithdrawExpireUnfreezeContract(byte[] address) { + if (address == null) { + address = getAddress(); + } + + BalanceContract.WithdrawExpireUnfreezeContract.Builder builder = + BalanceContract.WithdrawExpireUnfreezeContract.newBuilder(); + ByteString byteAddreess = ByteString.copyFrom(address); + builder.setOwnerAddress(byteAddreess); + + return builder.build(); + } + + private BalanceContract.DelegateResourceContract createDelegateResourceContract( + byte[] address, int balance + ,int resourceCode, byte[] receiver) { + if (address == null) { + address = getAddress(); + } + + BalanceContract.DelegateResourceContract.Builder builder = + BalanceContract.DelegateResourceContract.newBuilder(); + ByteString byteAddreess = ByteString.copyFrom(address); + ByteString byteReceiverAddreess = ByteString.copyFrom(receiver); + builder.setOwnerAddress(byteAddreess) + .setResourceValue(resourceCode) + .setBalance(balance) + .setReceiverAddress(byteReceiverAddreess); + + return builder.build(); + } + + private BalanceContract.UnDelegateResourceContract createUnDelegateResourceContract( + byte[] address, int balance + ,int resourceCode, byte[] receiver) { + if (address == null) { + address = getAddress(); + } + + BalanceContract.UnDelegateResourceContract.Builder builder = + BalanceContract.UnDelegateResourceContract.newBuilder(); + ByteString byteAddreess = ByteString.copyFrom(address); + ByteString byteReceiverAddreess = ByteString.copyFrom(receiver); + builder.setOwnerAddress(byteAddreess) + .setResourceValue(resourceCode) + .setBalance(balance) + .setReceiverAddress(byteReceiverAddreess); + + return builder.build(); + } + public boolean unfreezeAsset(byte[] ownerAddress) throws CipherException, IOException, CancelException { UnfreezeAssetContract contract = createUnfreezeAssetContract(ownerAddress); diff --git a/src/main/protos/api/api.proto b/src/main/protos/api/api.proto index 6cfa57986..b40fba3c5 100644 --- a/src/main/protos/api/api.proto +++ b/src/main/protos/api/api.proto @@ -226,6 +226,10 @@ service Wallet { //Use this function instead of FreezeBalance. rpc FreezeBalance2 (FreezeBalanceContract) returns (TransactionExtention) { } + //Use this function when FreezeBalanceV2. + rpc FreezeBalanceV2 (FreezeBalanceV2Contract) returns (TransactionExtention) { + } + //Please use UnfreezeBalance2 instead of this function. rpc UnfreezeBalance (UnfreezeBalanceContract) returns (Transaction) { option (google.api.http) = { @@ -239,6 +243,20 @@ service Wallet { //Use this function instead of UnfreezeBalance. rpc UnfreezeBalance2 (UnfreezeBalanceContract) returns (TransactionExtention) { } + //Use this function when UnfreezeBalanceV2. + rpc UnfreezeBalanceV2 (UnfreezeBalanceV2Contract) returns (TransactionExtention) { + } + + + rpc WithdrawExpireUnfreeze (WithdrawExpireUnfreezeContract) returns (TransactionExtention) { + } + + rpc DelegateResource (DelegateResourceContract) returns (TransactionExtention) { + } + + rpc UnDelegateResource (UnDelegateResourceContract) returns (TransactionExtention) { + } + //Please use UnfreezeAsset2 instead of this function. rpc UnfreezeAsset (UnfreezeAssetContract) returns (Transaction) { option (google.api.http) = { diff --git a/src/main/protos/core/Tron.proto b/src/main/protos/core/Tron.proto index fcf0e8758..18142cc57 100644 --- a/src/main/protos/core/Tron.proto +++ b/src/main/protos/core/Tron.proto @@ -2,6 +2,7 @@ syntax = "proto3"; import "google/protobuf/any.proto"; import "core/Discover.proto"; +import "core/contract/common.proto"; package protocol; @@ -151,6 +152,18 @@ message Account { Permission owner_permission = 31; Permission witness_permission = 32; repeated Permission active_permission = 33; + + message FreezeV2 { + ResourceCode type = 1; + int64 amount = 2; + } + message UnFreezeV2 { + ResourceCode type = 1; + int64 unfreeze_amount = 3; + int64 unfreeze_expire_time = 4; + } + repeated FreezeV2 frozenV2 = 34; + repeated UnFreezeV2 unfrozenV2 = 35; } @@ -284,6 +297,11 @@ message Transaction { ShieldedTransferContract = 51; MarketSellAssetContract = 52; MarketCancelOrderContract = 53; + FreezeBalanceV2Contract = 54; + UnfreezeBalanceV2Contract = 55; + WithdrawBalanceV2Contract = 56; + DelegateResourceContract = 57; + UnDelegateResourceContract = 58; } ContractType type = 1; google.protobuf.Any parameter = 2; diff --git a/src/main/protos/core/contract/balance_contract.proto b/src/main/protos/core/contract/balance_contract.proto index 82a93d6a3..42acf9024 100644 --- a/src/main/protos/core/contract/balance_contract.proto +++ b/src/main/protos/core/contract/balance_contract.proto @@ -81,3 +81,33 @@ message AccountBalanceResponse { int64 balance = 1; BlockBalanceTrace.BlockIdentifier block_identifier = 2; } + +message FreezeBalanceV2Contract { + bytes owner_address = 1; + int64 frozen_balance = 2; + ResourceCode resource = 3; +} + +message UnfreezeBalanceV2Contract { + bytes owner_address = 1; + int64 unfreeze_balance = 2; + ResourceCode resource = 3; +} + +message WithdrawExpireUnfreezeContract { + bytes owner_address = 1; +} + +message DelegateResourceContract { + bytes owner_address = 1; + ResourceCode resource = 2; + int64 balance = 3; + bytes receiver_address = 4; +} + +message UnDelegateResourceContract { + bytes owner_address = 1; + ResourceCode resource = 2; + int64 balance = 3; + bytes receiver_address = 4; +} \ No newline at end of file From 19197b589ce4d50206ba40edabe9531a47a5aadb Mon Sep 17 00:00:00 2001 From: Asuka Date: Wed, 2 Nov 2022 15:05:03 +0800 Subject: [PATCH 2/8] just for personal use --- .../common/utils/HttpSelfFormatFieldName.java | 1 + .../org/tron/common/utils/JsonFormat.java | 28 ++-- .../java/org/tron/common/utils/Utils.java | 23 ++- .../java/org/tron/demo/ShieldedTRC20Demo.java | 2 +- src/main/java/org/tron/walletcli/Client.java | 157 +++++++++++++++--- .../org/tron/walletcli/WalletApiWrapper.java | 14 +- .../java/org/tron/walletserver/WalletApi.java | 63 ++++--- src/main/protos/core/Tron.proto | 29 +++- 8 files changed, 246 insertions(+), 71 deletions(-) diff --git a/src/main/java/org/tron/common/utils/HttpSelfFormatFieldName.java b/src/main/java/org/tron/common/utils/HttpSelfFormatFieldName.java index e1f5f3463..03f6a1e9d 100644 --- a/src/main/java/org/tron/common/utils/HttpSelfFormatFieldName.java +++ b/src/main/java/org/tron/common/utils/HttpSelfFormatFieldName.java @@ -150,6 +150,7 @@ public class HttpSelfFormatFieldName { //InternalTransaction AddressFieldNameMap.put("protocol.InternalTransaction.caller_address", 1); AddressFieldNameMap.put("protocol.InternalTransaction.transferTo_address", 1); + NameFieldNameMap.put("protocol.InternalTransaction.note", 1); //DelegatedResourceAccountIndex AddressFieldNameMap.put("protocol.DelegatedResourceAccountIndex.account", 1); AddressFieldNameMap.put("protocol.DelegatedResourceAccountIndex.fromAccounts", 1); diff --git a/src/main/java/org/tron/common/utils/JsonFormat.java b/src/main/java/org/tron/common/utils/JsonFormat.java index af1cb7fdc..43ab676a0 100644 --- a/src/main/java/org/tron/common/utils/JsonFormat.java +++ b/src/main/java/org/tron/common/utils/JsonFormat.java @@ -35,6 +35,7 @@ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT import com.google.protobuf.Descriptors.EnumValueDescriptor; import com.google.protobuf.Descriptors.FieldDescriptor; import org.apache.commons.lang3.StringUtils; +import org.tron.protos.Protocol; import org.tron.walletserver.WalletApi; import java.io.IOException; @@ -98,17 +99,22 @@ protected static void print(Message message, JsonGenerator generator, boolean se for (Iterator> iter = message.getAllFields().entrySet() .iterator(); iter.hasNext(); ) { Map.Entry field = iter.next(); + if (field.getKey().isRepeated() + && field.getKey().getName().equals("callValueInfo") + && !((List) field.getValue()).isEmpty()) { + Protocol.InternalTransaction.CallValueInfo callValueInfo = + (Protocol.InternalTransaction.CallValueInfo) ((List) field.getValue()).get(0); + if (callValueInfo.getCallValue() == 0) continue; + } printField(field.getKey(), field.getValue(), generator, selfType); if (iter.hasNext()) { generator.print(","); } } - - // do not print UnknownFields - // if (message.getUnknownFields().asMap().size() > 0) { - // generator.print(", "); - // } - // printUnknownFields(message.getUnknownFields(), generator, selfType); + if (message.getUnknownFields().asMap().size() > 0) { + generator.print(", "); + } + printUnknownFields(message.getUnknownFields(), generator, selfType); } /** @@ -322,9 +328,7 @@ protected static void printUnknownFields(UnknownFieldSet unknownFields, JsonGene } else { generator.print(", "); } - generator.print("\""); generator.print(String.format((Locale) null, "0x%08x", value)); - generator.print("\""); } for (long value : field.getFixed64List()) { if (firstValue) { @@ -332,9 +336,7 @@ protected static void printUnknownFields(UnknownFieldSet unknownFields, JsonGene } else { generator.print(", "); } - generator.print("\""); generator.print(String.format((Locale) null, "0x%016x", value)); - generator.print("\""); } for (ByteString value : field.getLengthDelimitedList()) { if (firstValue) { @@ -750,7 +752,11 @@ static String escapeBytes(ByteString input, final String fliedName, boolean self static String escapeBytesSelfType(ByteString input, final String fliedName) { //Address if (HttpSelfFormatFieldName.isAddressFormat(fliedName)) { - return WalletApi.encode58Check(input.toByteArray()); + byte[] address = input.toByteArray(); + if (address != null && address.length == 20) { + address = ByteUtil.merge(new byte[]{0x41}, address); + } + return WalletApi.encode58Check(address); } //Normal String diff --git a/src/main/java/org/tron/common/utils/Utils.java b/src/main/java/org/tron/common/utils/Utils.java index 079f609d5..5ce691271 100644 --- a/src/main/java/org/tron/common/utils/Utils.java +++ b/src/main/java/org/tron/common/utils/Utils.java @@ -24,6 +24,7 @@ import com.google.protobuf.InvalidProtocolBufferException; import com.google.protobuf.Message; +import com.typesafe.config.Config; import java.io.Console; import java.io.IOException; import java.nio.ByteBuffer; @@ -40,6 +41,7 @@ import org.tron.api.GrpcAPI.*; import org.tron.common.crypto.Hash; import org.tron.common.crypto.Sha256Sm3Hash; +import org.tron.core.config.Configuration; import org.tron.keystore.StringUtils; import org.tron.walletserver.WalletApi; import org.tron.protos.Protocol.Block; @@ -87,6 +89,22 @@ public class Utils { private static SecureRandom random = new SecureRandom(); + public static String getPassword() { + Config config = Configuration.getByPath("config.conf"); + if (config.hasPath("password")) { + return config.getString("password"); + } + return null; + } + + public static String getMe() { + Config config = Configuration.getByPath("config.conf"); + if (config.hasPath("me")) { + return config.getString("me"); + } + return null; + } + public static SecureRandom getRandom() { return random; } @@ -486,6 +504,8 @@ public static JSONObject printTransactionToJSON(Transaction transaction, boolean case CreateSmartContract: CreateSmartContract deployContract = contractParameter.unpack(CreateSmartContract.class); + deployContract = deployContract.toBuilder().setNewContract( + deployContract.getNewContract().toBuilder().clearAbi().build()).build(); contractJson = JSONObject.parseObject(JsonFormat.printToString(deployContract, selfType)); byte[] ownerAddress = deployContract.getOwnerAddress().toByteArray(); @@ -495,6 +515,7 @@ public static JSONObject printTransactionToJSON(Transaction transaction, boolean case TriggerSmartContract: TriggerSmartContract triggerSmartContract = contractParameter.unpack(TriggerSmartContract.class); + System.out.println(JsonFormat.printToString(triggerSmartContract, selfType)); contractJson = JSONObject.parseObject( JsonFormat.printToString(triggerSmartContract, selfType)); @@ -604,7 +625,7 @@ public static JSONObject printTransactionToJSON(Transaction transaction, boolean rawData.put("contract", contracts); jsonTransaction.put("raw_data", rawData); String rawDataHex = ByteArray.toHexString(transaction.getRawData().toByteArray()); - jsonTransaction.put("raw_data_hex", rawDataHex); + //jsonTransaction.put("raw_data_hex", rawDataHex); String txID = ByteArray.toHexString(Sha256Sm3Hash.hash(transaction.getRawData().toByteArray())); jsonTransaction.put("txID", txID); return jsonTransaction; diff --git a/src/main/java/org/tron/demo/ShieldedTRC20Demo.java b/src/main/java/org/tron/demo/ShieldedTRC20Demo.java index bd45dc8ed..a900bafd3 100644 --- a/src/main/java/org/tron/demo/ShieldedTRC20Demo.java +++ b/src/main/java/org/tron/demo/ShieldedTRC20Demo.java @@ -56,7 +56,7 @@ public class ShieldedTRC20Demo { private String rcm = "should generate new rcm when trigger contract"; private ShieldedKey shieldedKey = generateShieldedKey(sk); - private GrpcClient grpcClient = WalletApi.init(); + private GrpcClient grpcClient = null; private BigInteger scalingFactorBi = getScalingFactorBi(); public ShieldedTRC20Demo() throws ZksnarkException { diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index e9cfcee39..0346e5198 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -1,8 +1,11 @@ package org.tron.walletcli; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileInputStream; import java.io.IOException; +import java.io.InputStreamReader; import java.math.BigInteger; -import java.security.SecureRandom; import java.text.SimpleDateFormat; import java.util.*; import java.util.Base64.Decoder; @@ -26,6 +29,7 @@ import org.jline.terminal.TerminalBuilder; import org.tron.api.GrpcAPI.*; import org.tron.common.crypto.Hash; +import org.tron.common.crypto.Sha256Sm3Hash; import org.tron.common.utils.AbiUtil; import org.tron.common.utils.ByteArray; import org.tron.common.utils.ByteUtil; @@ -34,7 +38,6 @@ import org.tron.common.zksnark.LibrustzcashParam; import org.tron.core.exception.CancelException; import org.tron.core.exception.CipherException; -import org.tron.core.exception.EncodingException; import org.tron.core.exception.ZksnarkException; import org.tron.core.zen.ShieldedAddressInfo; import org.tron.core.zen.ShieldedNoteInfo; @@ -57,7 +60,6 @@ import org.tron.protos.Protocol.Account; import org.tron.protos.Protocol.Block; import org.tron.protos.Protocol.ChainParameters; -import org.tron.protos.Protocol.DelegatedResourceAccountIndex; import org.tron.protos.Protocol.Exchange; import org.tron.protos.Protocol.Proposal; import org.tron.protos.contract.SmartContractOuterClass.SmartContract; @@ -138,6 +140,7 @@ public class Client { "GetSpendingKey", "GetTotalTransaction", "GetTransactionApprovedList", + "ById", "GetTransactionById", "GetTransactionCountByBlockNum", "GetTransactionInfoByBlockNum", @@ -166,6 +169,7 @@ public class Client { // "LoadShieldedWallet", "Login", "Logout", + "Init", "LoadShieldedTRC20Wallet", // "LoadShieldedWallet", "MarketCancelOrder", @@ -225,6 +229,7 @@ public class Client { "CreateProposal", "CreateWitness", "DeleteProposal", + "DeployConstantContract", "DeployContract", "ExchangeCreate", "ExchangeInject", @@ -273,6 +278,7 @@ public class Client { "GetSpendingKey", "GetTotalTransaction", "GetTransactionApprovedList", + "ById", "GetTransactionById", "GetTransactionCountByBlockNum", "GetTransactionInfoByBlockNum", @@ -301,6 +307,7 @@ public class Client { "ListWitnesses", "Login", "Logout", + "Init", "LoadShieldedTRC20Wallet", // "LoadShieldedWallet", "MarketCancelOrder", @@ -453,6 +460,34 @@ private void logout() { System.out.println("Logout successful !!!"); } + private void init(String[] parameters) { + if (parameters == null || parameters.length == 0) { + System.out.println("Init parameter error."); + return; + } + switch (parameters[0].toLowerCase()) { + case "main": + WalletApi.init(0); + break; + case "nile": + WalletApi.init(1); + break; + case "shasta": + WalletApi.init(2); + break; + case "local": + WalletApi.init(3); + break; + case "qa": + WalletApi.init(4); + break; + default: + System.out.println("Init parameter error."); + return; + } + System.out.println("Init success: " + parameters[0].toLowerCase()); + } + private void loadShieldedWallet() throws CipherException, IOException { boolean result = ShieldedWrapper.getInstance().loadShieldWallet(); if (result) { @@ -540,6 +575,7 @@ private void getAccount(String[] parameters) { if (account == null) { System.out.println("GetAccount failed !!!!"); } else { + System.out.println("Bytes: " + Hex.toHexString(account.toByteArray())); System.out.println(Utils.formatMessageString(account)); } } @@ -1139,7 +1175,16 @@ private void getBlock(String[] parameters) { System.out.println("No block for num : " + blockNum); return; } + List txs = blockExtention.getTransactionsList(); + blockExtention = blockExtention.toBuilder().clearTransactions().build(); System.out.println(Utils.printBlockExtention(blockExtention)); + txs.forEach(tx -> { + System.out.printf("[%s]: %s - %s%n", + Hex.toHexString(Sha256Sm3Hash.hash( + tx.getTransaction().getRawData().toByteArray())), + tx.getTransaction().getRawData().getContract(0).getType(), + tx.getTransaction().getRet(0).getContractRet()); + }); } else { Block block = walletApiWrapper.getBlock(blockNum); if (block == null) { @@ -1326,7 +1371,7 @@ private void unfreezeBalance(String[] parameters) } private void unfreezeBalanceV2(String[] parameters) - throws IOException, CipherException, CancelException { + throws IOException, CipherException, CancelException { if (parameters == null || !(parameters.length == 2 || parameters.length == 3)) { System.out.println("Use unfreezeBalanceV2 command with below syntax: "); System.out.println( @@ -1390,7 +1435,7 @@ private void withdrawExpireUnfreeze(String[] parameters) } private void delegateResource(String[] parameters) - throws IOException, CipherException, CancelException { + throws IOException, CipherException, CancelException { if (parameters == null || !(parameters.length == 3 || parameters.length == 4)) { System.out.println("Use delegateResource command with below syntax: "); System.out.println( @@ -1439,7 +1484,7 @@ private void delegateResource(String[] parameters) } private void unDelegateResource(String[] parameters) - throws IOException, CipherException, CancelException { + throws IOException, CipherException, CancelException { if (parameters == null || !(parameters.length == 3 || parameters.length == 4)) { System.out.println("Use unDelegateResource command with below syntax: "); System.out.println( @@ -1835,6 +1880,7 @@ private void getTransactionById(String[] parameters) { Optional result = WalletApi.getTransactionById(txid); if (result.isPresent()) { Transaction transaction = result.get(); + System.out.println("RawData Hex: " + Hex.toHexString(transaction.getRawData().toByteArray())); System.out.println(Utils.printTransaction(transaction)); } else { System.out.println("GetTransactionById failed !!"); @@ -2297,7 +2343,7 @@ private void deployContract(String[] parameter) String constructorStr = parameters[idx++]; String argsStr = parameters[idx++]; boolean isHex = Boolean.parseBoolean(parameters[idx++]); - long feeLimit = Long.parseLong(parameters[idx++]); + long feeLimit = parseTRX(parameters[idx++]); long consumeUserResourcePercent = Long.parseLong(parameters[idx++]); long originEnergyLimit = Long.parseLong(parameters[idx++]); if (consumeUserResourcePercent > 100 || consumeUserResourcePercent < 0) { @@ -2315,11 +2361,10 @@ private void deployContract(String[] parameter) codeStr += Hex.toHexString(AbiUtil.encodeInput(constructorStr, argsStr)); } } - long value = 0; - value = Long.valueOf(parameters[idx++]); - long tokenValue = Long.valueOf(parameters[idx++]); + long value = parseTRX(parameters[idx++]); + long tokenValue = Long.parseLong(parameters[idx++]); String tokenId = parameters[idx++]; - if (tokenId == "#") { + if (tokenId.equals("#")) { tokenId = ""; } String libraryAddressPair = null; @@ -2348,6 +2393,14 @@ private void deployContract(String[] parameter) } } + private long parseTRX(String valueStr) throws NumberFormatException { + valueStr = valueStr.toLowerCase(); + if (valueStr.contains("trx")) { + return Long.parseLong(valueStr.replace("trx", "")) * 1_000_000L; + } + return Long.parseLong(valueStr); + } + private void deployConstantContract(String[] parameters) throws IOException, CipherException, CancelException { @@ -2402,7 +2455,7 @@ private void deployConstantContract(String[] parameters) private void triggerContract(String[] parameters) throws IOException, CipherException, CancelException { - if (parameters == null || (parameters.length != 8 && parameters.length != 9)) { + if (parameters == null || (parameters.length != 4 && parameters.length != 8 && parameters.length != 9)) { System.out.println("TriggerContract needs 8 or 9 parameters like: "); System.out.println("TriggerContract [OwnerAddress] contractAddress method args isHex" + " fee_limit value token_value token_id(e.g: TRXTOKEN, use # if don't provided)"); @@ -2422,11 +2475,27 @@ private void triggerContract(String[] parameters) String contractAddrStr = parameters[index++]; String methodStr = parameters[index++]; String argsStr = parameters[index++]; + if (argsStr.equals("data")) { + File file = new File("data"); + if (file.exists()) { + BufferedReader reader = + new BufferedReader(new InputStreamReader(new FileInputStream(file))); + argsStr = reader.readLine(); + reader.close(); + } + } boolean isHex = Boolean.parseBoolean(parameters[index++]); - long feeLimit = Long.parseLong(parameters[index++]); - long callValue = Long.parseLong(parameters[index++]); - long tokenValue = Long.parseLong(parameters[index++]); - String tokenId = parameters[index]; + + long feeLimit = 1000000000; + long callValue = 0; + long tokenValue = 0; + String tokenId = "#"; + if (parameters.length != 4) { + feeLimit = parseTRX(parameters[index++]); + callValue = parseTRX(parameters[index++]); + tokenValue = Long.parseLong(parameters[index++]); + tokenId = parameters[index]; + } if (argsStr.equalsIgnoreCase("#")) { argsStr = ""; @@ -2475,14 +2544,26 @@ private void triggerConstantContract(String[] parameters) } String contractAddressStr = parameters[idx++]; - byte[] contractAddress = WalletApi.decodeFromBase58Check(contractAddressStr); - if (contractAddress == null) { - System.out.println("Invalid Contract Address."); - return; + byte[] contractAddress = null; + if (!"#".equals(contractAddressStr)) { + contractAddress = WalletApi.decodeFromBase58Check(contractAddressStr); + if (contractAddress == null) { + System.out.println("Invalid Contract Address."); + return; + } } String methodStr = parameters[idx++]; String argsStr = parameters[idx++]; + if (argsStr.equals("data")) { + File file = new File("data"); + if (file.exists()) { + BufferedReader reader = + new BufferedReader(new InputStreamReader(new FileInputStream(file))); + argsStr = reader.readLine(); + reader.close(); + } + } boolean isHex = Boolean.parseBoolean(parameters[idx++]); long callValue = 0; long tokenValue = 0; @@ -2504,6 +2585,8 @@ private void triggerConstantContract(String[] parameters) byte[] input = new byte[0]; if (!methodStr.equalsIgnoreCase("#")) { input = Hex.decode(AbiUtil.parseMethod(methodStr, argsStr, isHex)); + } else if (isHex) { + input = Hex.decode(argsStr); } walletApiWrapper.callContract( @@ -4106,6 +4189,10 @@ private void run() { logout(); break; } + case "init": { + init(parameters); + break; + } // case "loadshieldedwallet": { // loadShieldedWallet(); // break; @@ -4338,6 +4425,7 @@ private void run() { getTransactionsToThis(parameters); break; } + case "byid": case "gettransactionbyid": { getTransactionById(parameters); break; @@ -4593,9 +4681,34 @@ private void run() { System.out.println("Exit !!!"); return; } + case "deploy": { + File file = new File("bin"); + if (file.exists()) { + BufferedReader reader = + new BufferedReader(new InputStreamReader(new FileInputStream(file))); + String code = reader.readLine(); + deployContract(new String[]{"Shabi", "[]", code, + "#", "#", "false", "1000000000", "100", "1", "0", "0", "#"}); + reader.close(); + } else { + System.out.println("Bin not exist."); + } + break; + } default: { - System.out.println("Invalid cmd: " + cmd); - help(); + //System.out.println("Invalid cmd: " + cmd); + //help(); + if (cmd.contains("0x") || cmd.contains("0X")) { + cmd = cmd.substring(2); + } + if (cmd.length() == 64) { + getTransactionInfoById(new String[]{cmd}); + } else if (cmd.length() == 34 && cmd.charAt(0) == 'T') { + getContractInfo(new String[]{cmd}); + } else { + deployContract(new String[]{"Shabi", "[]", cmdLowerCase, + "#", "#", "false", "1000000000", "100", "1", "0", "0", "#"}); + } } } } catch (CipherException e) { diff --git a/src/main/java/org/tron/walletcli/WalletApiWrapper.java b/src/main/java/org/tron/walletcli/WalletApiWrapper.java index 1b5b7bf66..65d0d89d9 100644 --- a/src/main/java/org/tron/walletcli/WalletApiWrapper.java +++ b/src/main/java/org/tron/walletcli/WalletApiWrapper.java @@ -118,8 +118,13 @@ public boolean login() throws IOException, CipherException { logout(); wallet = WalletApi.loadWalletFromKeystore(); - System.out.println("Please input your password."); - char[] password = Utils.inputPassword(false); + char[] password; + if (Utils.getPassword() == null) { + System.out.println("Please input your password."); + password = Utils.inputPassword(false); + } else { + password = Utils.getPassword().toCharArray(); + } byte[] passwd = StringUtils.char2Byte(password); StringUtils.clear(password); wallet.checkPassword(passwd); @@ -482,9 +487,8 @@ public boolean freezeBalance(byte[] ownerAddress, long frozen_balance, long froz receiverAddress); } - public boolean freezeBalanceV2(byte[] ownerAddress, long frozen_balance, - int resourceCode) - throws CipherException, IOException, CancelException { + public boolean freezeBalanceV2(byte[] ownerAddress, long frozen_balance, int resourceCode) + throws CipherException, IOException, CancelException { if (wallet == null || !wallet.isLoginState()) { System.out.println("Warning: freezeBalanceV2 failed, Please login first !!"); return false; diff --git a/src/main/java/org/tron/walletserver/WalletApi.java b/src/main/java/org/tron/walletserver/WalletApi.java index 94db3fbe1..f15e52c92 100644 --- a/src/main/java/org/tron/walletserver/WalletApi.java +++ b/src/main/java/org/tron/walletserver/WalletApi.java @@ -167,9 +167,9 @@ public class WalletApi { private static int rpcVersion = 0; private static boolean isEckey = true; - private static GrpcClient rpcCli = init(); + private static GrpcClient rpcCli; - public static GrpcClient init() { + public static void init(int index) { Config config = Configuration.getByPath("config.conf"); String fullNode = ""; @@ -178,7 +178,7 @@ public static GrpcClient init() { solidityNode = config.getStringList("soliditynode.ip.list").get(0); } if (config.hasPath("fullnode.ip.list")) { - fullNode = config.getStringList("fullnode.ip.list").get(0); + fullNode = config.getStringList("fullnode.ip.list").get(index); } if (config.hasPath("net.type") && "mainnet".equalsIgnoreCase(config.getString("net.type"))) { WalletApi.setAddressPreFixByte(CommonConstant.ADD_PRE_FIX_BYTE_MAINNET); @@ -193,7 +193,7 @@ public static GrpcClient init() { isEckey = config.getString("crypto.engine").equalsIgnoreCase("eckey"); System.out.println("WalletApi getConfig isEckey: " + isEckey); } - return new GrpcClient(fullNode, solidityNode); + rpcCli = new GrpcClient(fullNode, solidityNode); } public static String selectFullNode() { @@ -350,7 +350,7 @@ public static File selcetWalletFile() { return null; } - File wallet; + File wallet = null; if (wallets.length > 1) { for (int i = 0; i < wallets.length; i++) { System.out.println("The " + (i + 1) + "th keystore file name is " + wallets[i].getName()); @@ -364,9 +364,19 @@ public static File selcetWalletFile() { try { n = new Integer(num); } catch (NumberFormatException e) { - System.out.println("Invaild number of " + num); - System.out.println("Please choose again between 1 and " + wallets.length); - continue; + if (Utils.getMe() == null) { + System.out.println("Invaild number of " + num); + System.out.println("Please choose again between 1 and " + wallets.length); + continue; + } else { + String me = Utils.getMe(); + for (File w : wallets) { + if (w.getName().contains(me)) { + wallet = w; + } + } + break; + } } if (n < 1 || n > wallets.length) { System.out.println("Please choose again between 1 and " + wallets.length); @@ -465,12 +475,17 @@ private Transaction signTransaction(Transaction transaction) String tipsString = "Please confirm and input your permission id, if input y or Y means " + "default 0, other non-numeric characters will cancel transaction."; - transaction = TransactionUtils.setPermissionId(transaction, tipsString); +// transaction = TransactionUtils.setPermissionId(transaction, tipsString); while (true) { System.out.println("Please choose your key for sign."); WalletFile walletFile = selcetWalletFileE(); - System.out.println("Please input your password."); - char[] password = Utils.inputPassword(false); + char[] password; + if (Utils.getPassword() == null) { + System.out.println("Please input your password."); + password = Utils.inputPassword(false); + } else { + password = Utils.getPassword().toCharArray(); + } byte[] passwd = org.tron.keystore.StringUtils.char2Byte(password); org.tron.keystore.StringUtils.clear(password); if (isEckey) { @@ -1297,19 +1312,18 @@ public boolean freezeBalance( } public boolean freezeBalanceV2( - byte[] ownerAddress, - long frozen_balance, - int resourceCode) - throws CipherException, IOException, CancelException { + byte[] ownerAddress, + long frozen_balance, + int resourceCode) + throws CipherException, IOException, CancelException { BalanceContract.FreezeBalanceV2Contract contract = - createFreezeBalanceContractV2( - ownerAddress, frozen_balance, resourceCode); + createFreezeBalanceContractV2( + ownerAddress, frozen_balance, resourceCode); TransactionExtention transactionExtention = rpcCli.createTransaction2(contract); return processTransactionExtention(transactionExtention); } - public boolean buyStorage(byte[] ownerAddress, long quantity) throws CipherException, IOException, CancelException { BuyStorageContract contract = createBuyStorageContract(ownerAddress, quantity); @@ -1358,18 +1372,19 @@ private FreezeBalanceContract createFreezeBalanceContract( } private BalanceContract.FreezeBalanceV2Contract createFreezeBalanceContractV2( - byte[] address, - long frozen_balance, - int resourceCode) { + byte[] address, + long frozen_balance, + int resourceCode) { if (address == null) { address = getAddress(); } BalanceContract.FreezeBalanceV2Contract.Builder builder = BalanceContract.FreezeBalanceV2Contract.newBuilder(); ByteString byteAddress = ByteString.copyFrom(address); - builder.setOwnerAddress(byteAddress) - .setFrozenBalance(frozen_balance) - .setResourceValue(resourceCode); + builder + .setOwnerAddress(byteAddress) + .setFrozenBalance(frozen_balance) + .setResourceValue(resourceCode); return builder.build(); } diff --git a/src/main/protos/core/Tron.proto b/src/main/protos/core/Tron.proto index 18142cc57..3eacd95f3 100644 --- a/src/main/protos/core/Tron.proto +++ b/src/main/protos/core/Tron.proto @@ -101,6 +101,8 @@ message Account { int64 old_tron_power = 46; Frozen tron_power = 47; + bool asset_optimized = 60; + // this account create time int64 create_time = 0x09; // this last operation time, including transfer, voting and so on. //FIXME fix grammar @@ -129,6 +131,8 @@ message Account { // the identity of this account, case insensitive bytes account_id = 23; + int64 net_window_size = 24; + message AccountResource { // energy resource, get from frozen int64 energy_usage = 1; @@ -146,6 +150,7 @@ message Account { int64 storage_usage = 7; int64 latest_exchange_storage_time = 8; + int64 energy_window_size = 9; } AccountResource account_resource = 26; bytes codeHash = 30; @@ -166,7 +171,6 @@ message Account { repeated UnFreezeV2 unfrozenV2 = 35; } - message Key { bytes address = 1; int64 weight = 2; @@ -331,6 +335,7 @@ message Transaction { JVM_STACK_OVER_FLOW = 12; UNKNOWN = 13; TRANSFER_FAILED = 14; + INVALID_CODE = 15; } int64 fee = 1; code ret = 2; @@ -344,6 +349,10 @@ message Transaction { int64 exchange_withdraw_another_amount = 20; int64 exchange_id = 21; int64 shielded_transaction_fee = 22; + + + bytes orderId = 25; + repeated MarketOrderDetail orderDetails = 26; } message raw { @@ -354,7 +363,7 @@ message Transaction { repeated authority auths = 9; // transaction note bytes data = 10; - //only support size = 1, repeated list here for extension + //only support size = 1, repeated list here for extension repeated Contract contract = 11; // scripts not used bytes scripts = 12; @@ -363,7 +372,7 @@ message Transaction { } raw raw_data = 1; - // only support size = 1, repeated list here for muti-sig extension + // only support size = 1, repeated list here for muti-sig extension repeated bytes signature = 2; repeated Result ret = 5; } @@ -402,6 +411,7 @@ message TransactionInfo { bytes orderId = 25; repeated MarketOrderDetail orderDetails = 26; int64 packingFee = 27; + } message TransactionRet { @@ -520,6 +530,7 @@ enum ReasonCode { TIME_OUT = 0x20; CONNECT_FAIL = 0x21; TOO_MANY_PEERS_WITH_SAME_IP = 0x22; + LIGHT_NODE_SYNC_FAIL = 0x23; UNKNOWN = 0xFF; } @@ -539,6 +550,10 @@ message HelloMessage { BlockId genesisBlockId = 4; BlockId solidBlockId = 5; BlockId headBlockId = 6; + bytes address = 7; + bytes signature = 8; + int32 nodeType = 9; + int64 lowestBlockNum = 10; } message InternalTransaction { @@ -689,20 +704,20 @@ message MarketOrder { bytes prev = 12; bytes next = 13; -} + } message MarketOrderList { repeated MarketOrder orders = 1; -} + } message MarketOrderPairList { repeated MarketOrderPair orderPair = 1; -} + } message MarketOrderPair{ bytes sell_token_id = 1; bytes buy_token_id = 2; -} + } message MarketAccountOrder { bytes owner_address = 1; From 51072da933fb4325202a8af60dad8e8a21fadafe Mon Sep 17 00:00:00 2001 From: Asuka Date: Fri, 23 Dec 2022 11:45:26 +0800 Subject: [PATCH 3/8] fix(merge): lost imports --- src/main/java/org/tron/walletcli/Client.java | 25 ++++---------------- 1 file changed, 5 insertions(+), 20 deletions(-) diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index 020cf5ec7..67370ca49 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -52,6 +52,7 @@ import org.tron.core.zen.address.PaymentAddress; import org.tron.core.zen.address.SpendingKey; import org.tron.keystore.StringUtils; +import org.tron.protos.Protocol; import org.tron.protos.Protocol.MarketOrder; import org.tron.protos.Protocol.MarketOrderList; import org.tron.protos.Protocol.MarketOrderPairList; @@ -1711,9 +1712,9 @@ private void getDelegatedResourceAccountIndex(String[] parameters) { return; } String ownerAddress = parameters[0]; - Optional result = WalletApi.getDelegatedResourceAccountIndex(ownerAddress); + Optional result = WalletApi.getDelegatedResourceAccountIndex(ownerAddress); if (result.isPresent()) { - DelegatedResourceAccountIndex delegatedResourceAccountIndex = result.get(); + Protocol.DelegatedResourceAccountIndex delegatedResourceAccountIndex = result.get(); System.out.println(Utils.formatMessageString(delegatedResourceAccountIndex)); } else { System.out.println("GetDelegatedResourceAccountIndex failed !!!"); @@ -1744,9 +1745,9 @@ private void getDelegatedResourceAccountIndexV2(String[] parameters) { return; } String ownerAddress = parameters[0]; - Optional result = WalletApi.getDelegatedResourceAccountIndexV2(ownerAddress); + Optional result = WalletApi.getDelegatedResourceAccountIndexV2(ownerAddress); if (result.isPresent()) { - DelegatedResourceAccountIndex delegatedResourceAccountIndex = result.get(); + Protocol.DelegatedResourceAccountIndex delegatedResourceAccountIndex = result.get(); System.out.println(Utils.formatMessageString(delegatedResourceAccountIndex)); } else { System.out.println("GetDelegatedResourceAccountIndexV2 failed !!!"); @@ -4459,22 +4460,6 @@ private void run() { unDelegateResource(parameters); break; } - case "unfreezebalancev2": { - unfreezeBalanceV2(parameters); - break; - } - case "withdrawexpireunfreeze": { - withdrawExpireUnfreeze(parameters); - break; - } - case "delegateresource": { - delegateResource(parameters); - break; - } - case "undelegateresource": { - unDelegateResource(parameters); - break; - } case "withdrawbalance": { withdrawBalance(parameters); break; From 52733805bc666b919453f2ba64277cad21787275 Mon Sep 17 00:00:00 2001 From: Asuka Date: Thu, 5 Jan 2023 15:04:24 +0800 Subject: [PATCH 4/8] feat: drop unused println --- src/main/java/org/tron/walletcli/Client.java | 25 ++++++++++++++----- .../java/org/tron/walletserver/WalletApi.java | 10 ++++---- 2 files changed, 24 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index 54495f592..dc27ab611 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -595,7 +595,6 @@ private void getAccount(String[] parameters) { if (account == null) { System.out.println("GetAccount failed !!!!"); } else { - System.out.println("Bytes: " + Hex.toHexString(account.toByteArray())); System.out.println(Utils.formatMessageString(account)); } } @@ -2107,7 +2106,6 @@ private void getTransactionById(String[] parameters) { Optional result = WalletApi.getTransactionById(txid); if (result.isPresent()) { Transaction transaction = result.get(); - System.out.println("RawData Hex: " + Hex.toHexString(transaction.getRawData().toByteArray())); System.out.println(Utils.printTransaction(transaction)); } else { System.out.println("GetTransactionById failed !!"); @@ -2895,6 +2893,7 @@ private void getContract(String[] parameters) { SmartContract contractDeployContract = WalletApi.getContract(addressBytes); if (contractDeployContract != null) { + contractDeployContract = contractDeployContract.toBuilder().clearAbi().build(); System.out.println(Utils.formatMessageString(contractDeployContract)); } else { System.out.println("Query contract failed !!!"); @@ -2917,6 +2916,10 @@ private void getContractInfo(String[] parameters) { SmartContractDataWrapper contractDeployContract = WalletApi.getContractInfo(addressBytes); if (contractDeployContract != null) { + SmartContract contract = contractDeployContract.getSmartContract() + .toBuilder().clearAbi().build(); + contractDeployContract = contractDeployContract + .toBuilder().setSmartContract(contract).build(); System.out.println(Utils.formatMessageString(contractDeployContract)); } else { System.out.println("Query contract failed !!!"); @@ -5011,18 +5014,28 @@ private void run() { break; } default: { - //System.out.println("Invalid cmd: " + cmd); - //help(); if (cmd.contains("0x") || cmd.contains("0X")) { cmd = cmd.substring(2); } if (cmd.length() == 64) { + System.out.println("---[Tx]---"); + getTransactionById(new String[]{cmd}); + System.out.println("---[TxInfo]---"); getTransactionInfoById(new String[]{cmd}); } else if (cmd.length() == 34 && cmd.charAt(0) == 'T') { + System.out.println("---[Contract]---"); getContractInfo(new String[]{cmd}); + System.out.println("---[Account]---"); + getAccount(new String[]{cmd}); } else { - deployContract(new String[]{"Shabi", "[]", cmdLowerCase, - "#", "#", "false", "1000000000", "100", "1", "0", "0", "#"}); + try { + Hex.decode(cmd); + deployContract(new String[]{"Shabi", "[]", cmdLowerCase, + "#", "#", "false", "1000000000", "100", "1", "0", "0", "#"}); + } catch (Exception ignored) { + System.out.println("Invalid cmd: " + cmd); + help(); + } } } } diff --git a/src/main/java/org/tron/walletserver/WalletApi.java b/src/main/java/org/tron/walletserver/WalletApi.java index af0e42fff..1fef86052 100644 --- a/src/main/java/org/tron/walletserver/WalletApi.java +++ b/src/main/java/org/tron/walletserver/WalletApi.java @@ -577,9 +577,9 @@ private boolean processTransactionExtention(TransactionExtention transactionExte return false; } - System.out.println(Utils.printTransactionExceptId(transactionExtention.getTransaction())); - System.out.println("before sign transaction hex string is " + - ByteArray.toHexString(transaction.toByteArray())); +// System.out.println(Utils.printTransactionExceptId(transactionExtention.getTransaction())); +// System.out.println("before sign transaction hex string is " + +// ByteArray.toHexString(transaction.toByteArray())); transaction = signTransaction(transaction); showTransactionAfterSign(transaction); return rpcCli.broadcastTransaction(transaction); @@ -587,8 +587,8 @@ private boolean processTransactionExtention(TransactionExtention transactionExte private void showTransactionAfterSign(Transaction transaction) throws InvalidProtocolBufferException { - System.out.println("after sign transaction hex string is " + - ByteArray.toHexString(transaction.toByteArray())); +// System.out.println("after sign transaction hex string is " + +// ByteArray.toHexString(transaction.toByteArray())); System.out.println("txid is " + ByteArray.toHexString(Sha256Sm3Hash.hash(transaction.getRawData().toByteArray()))); From dfe72858fead644a914157a0c5fe399762d5783c Mon Sep 17 00:00:00 2001 From: Asuka Date: Mon, 24 Apr 2023 12:14:37 +0800 Subject: [PATCH 5/8] fix(abi): do not always set dynamic to true for array type --- src/main/java/org/tron/common/utils/AbiUtil.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/org/tron/common/utils/AbiUtil.java b/src/main/java/org/tron/common/utils/AbiUtil.java index e56aaa6d3..dd310fe46 100644 --- a/src/main/java/org/tron/common/utils/AbiUtil.java +++ b/src/main/java/org/tron/common/utils/AbiUtil.java @@ -79,7 +79,6 @@ static class CoderArray extends Coder { if (length == -1) { this.dynamic = true; } - this.dynamic = true; } @Override From 9775b0cc9d926b60e601f71239a5a8e96229e878 Mon Sep 17 00:00:00 2001 From: Asuka Date: Mon, 24 Apr 2023 12:15:41 +0800 Subject: [PATCH 6/8] func(tx,receipt): adaptation to nodes with more internal transaction information --- src/main/java/org/tron/walletcli/Client.java | 44 +++++++++++++++++++- src/main/protos/core/Tron.proto | 3 ++ 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index dc27ab611..20a7811d4 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -33,6 +33,7 @@ import org.tron.common.utils.AbiUtil; import org.tron.common.utils.ByteArray; import org.tron.common.utils.ByteUtil; +import org.tron.common.utils.FastByteComparisons; import org.tron.common.utils.Utils; import org.tron.common.zksnark.JLibrustzcash; import org.tron.common.zksnark.LibrustzcashParam; @@ -1202,7 +1203,8 @@ private void getBlock(String[] parameters) { Hex.toHexString(Sha256Sm3Hash.hash( tx.getTransaction().getRawData().toByteArray())), tx.getTransaction().getRawData().getContract(0).getType(), - tx.getTransaction().getRet(0).getContractRet()); + tx.getTransaction().getRetCount() == 0 ? "SUCCESS" + : tx.getTransaction().getRet(0).getContractRet()); }); } else { Block block = walletApiWrapper.getBlock(blockNum); @@ -2123,7 +2125,46 @@ private void getTransactionInfoById(String[] parameters) { Optional result = WalletApi.getTransactionInfoById(txid); if (result.isPresent() && !result.get().equals(TransactionInfo.getDefaultInstance())) { TransactionInfo transactionInfo = result.get(); + List interTxs = transactionInfo.getInternalTransactionsList(); + transactionInfo = transactionInfo.toBuilder().clearInternalTransactions().build(); + System.out.println("---[TxInfo]---"); System.out.println(Utils.formatMessageString(transactionInfo)); + System.out.println("---[InternalTx]---"); + final byte[] contract = transactionInfo.getContractAddress().toByteArray(); + int maxPrefix = Integer.MIN_VALUE; + for (Protocol.InternalTransaction tx : interTxs) { + maxPrefix = Math.max(maxPrefix, tx.getDeep() * 4 + tx.getNote().size() + 3); + } + String format = "%-" + (maxPrefix + 3) + "s"; + for (Protocol.InternalTransaction tx : interTxs) { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < tx.getDeep(); i++) { + sb.append(" "); + } + sb.append("|_ "); + sb.append(new String(tx.getNote().toByteArray())); + for (int i = 0; i < tx.getDeep(); i++) { + sb.append("_1"); + } + System.out.printf(format, sb); + System.out.print(WalletApi.encode58Check(tx.getCallerAddress().toByteArray())); + byte[] to = tx.getTransferToAddress().toByteArray(); + if (FastByteComparisons.isEqual(to, contract)) { + System.out.print(" => "); + } else { + System.out.print(" ≠> "); + } + System.out.print(WalletApi.encode58Check(to)); + System.out.print(" " + tx.getEnergyLeft() + " "); + byte[] data = tx.getData().toByteArray(); +// if (data.length > 4) { +// data = Arrays.copyOfRange(data, 0, 4); +// } + System.out.println("0x" + Hex.toHexString(data)); + } + interTxs.forEach(tx -> { + + }); } else { System.out.println("GetTransactionInfoById failed !!!"); } @@ -5020,7 +5061,6 @@ private void run() { if (cmd.length() == 64) { System.out.println("---[Tx]---"); getTransactionById(new String[]{cmd}); - System.out.println("---[TxInfo]---"); getTransactionInfoById(new String[]{cmd}); } else if (cmd.length() == 34 && cmd.charAt(0) == 'T') { System.out.println("---[Contract]---"); diff --git a/src/main/protos/core/Tron.proto b/src/main/protos/core/Tron.proto index b5677e791..d291ec0a1 100644 --- a/src/main/protos/core/Tron.proto +++ b/src/main/protos/core/Tron.proto @@ -576,6 +576,9 @@ message InternalTransaction { bytes note = 5; bool rejected = 6; string extra = 7; + uint32 deep = 8; + uint32 energy_left = 9; + bytes data = 10; } message DelegatedResourceAccountIndex { From dac5d09be20691fbd022ee7803f4810e55d404f9 Mon Sep 17 00:00:00 2001 From: Asuka Date: Tue, 9 May 2023 09:47:59 +0800 Subject: [PATCH 7/8] func(block): print more details for smart contract txs --- .../org/tron/common/utils/JsonFormat.java | 10 ++++--- .../java/org/tron/common/utils/Utils.java | 1 - src/main/java/org/tron/walletcli/Client.java | 27 ++++++++++++++----- 3 files changed, 27 insertions(+), 11 deletions(-) diff --git a/src/main/java/org/tron/common/utils/JsonFormat.java b/src/main/java/org/tron/common/utils/JsonFormat.java index 43ab676a0..f149b4104 100644 --- a/src/main/java/org/tron/common/utils/JsonFormat.java +++ b/src/main/java/org/tron/common/utils/JsonFormat.java @@ -111,10 +111,12 @@ protected static void print(Message message, JsonGenerator generator, boolean se generator.print(","); } } - if (message.getUnknownFields().asMap().size() > 0) { - generator.print(", "); - } - printUnknownFields(message.getUnknownFields(), generator, selfType); + + // do not print UnknownFields + // if (message.getUnknownFields().asMap().size() > 0) { + // generator.print(", "); + // } + // printUnknownFields(message.getUnknownFields(), generator, selfType); } /** diff --git a/src/main/java/org/tron/common/utils/Utils.java b/src/main/java/org/tron/common/utils/Utils.java index 114e48596..2833525e8 100644 --- a/src/main/java/org/tron/common/utils/Utils.java +++ b/src/main/java/org/tron/common/utils/Utils.java @@ -516,7 +516,6 @@ public static JSONObject printTransactionToJSON(Transaction transaction, boolean case TriggerSmartContract: TriggerSmartContract triggerSmartContract = contractParameter.unpack(TriggerSmartContract.class); - System.out.println(JsonFormat.printToString(triggerSmartContract, selfType)); contractJson = JSONObject.parseObject( JsonFormat.printToString(triggerSmartContract, selfType)); diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index 9f985a9b8..82b8f5876 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -1,5 +1,7 @@ package org.tron.walletcli; +import static org.tron.protos.Protocol.Transaction.Contract.ContractType.TriggerSmartContract; + import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; @@ -33,7 +35,6 @@ import org.tron.common.crypto.SignInterface; import org.tron.common.crypto.SignUtils; import org.tron.common.utils.AbiUtil; -import org.tron.common.utils.Base58; import org.tron.common.utils.ByteArray; import org.tron.common.utils.ByteUtil; import org.tron.common.utils.FastByteComparisons; @@ -67,6 +68,7 @@ import org.tron.protos.Protocol.ChainParameters; import org.tron.protos.Protocol.Exchange; import org.tron.protos.Protocol.Proposal; +import org.tron.protos.contract.SmartContractOuterClass; import org.tron.protos.contract.SmartContractOuterClass.SmartContract; import org.tron.protos.Protocol.Transaction; import org.tron.protos.Protocol.TransactionInfo; @@ -74,8 +76,6 @@ import org.tron.walletserver.WalletApi; import org.tron.protos.contract.Common.ResourceCode; - - public class Client { private WalletApiWrapper walletApiWrapper = new WalletApiWrapper(); @@ -1201,14 +1201,29 @@ private void getBlock(String[] parameters) { List txs = blockExtention.getTransactionsList(); blockExtention = blockExtention.toBuilder().clearTransactions().build(); System.out.println(Utils.printBlockExtention(blockExtention)); - txs.forEach(tx -> { - System.out.printf("[%s]: %s - %s%n", + System.out.println("[Txs List]"); + for (int i = 0; i < txs.size(); i++) { + TransactionExtention tx = txs.get(i + 1); + System.out.printf("%3d. [%s]: %s - %s%n", + i, Hex.toHexString(Sha256Sm3Hash.hash( tx.getTransaction().getRawData().toByteArray())), tx.getTransaction().getRawData().getContract(0).getType(), tx.getTransaction().getRetCount() == 0 ? "SUCCESS" : tx.getTransaction().getRet(0).getContractRet()); - }); + Transaction.Contract contract = tx.getTransaction().getRawData().getContract(0); + if (contract.getType() == TriggerSmartContract) { + try { + SmartContractOuterClass.TriggerSmartContract triggerContract = contract.getParameter().unpack( + SmartContractOuterClass.TriggerSmartContract.class); + System.out.printf(" |_ [%s] => [%s]%n", + WalletApi.encode58Check(triggerContract.getOwnerAddress().toByteArray()), + WalletApi.encode58Check(triggerContract.getContractAddress().toByteArray())); + } catch (InvalidProtocolBufferException e) { + throw new RuntimeException(e); + } + } + } } else { Block block = walletApiWrapper.getBlock(blockNum); if (block == null) { From df3cad4f2e922e555e5c10483b785e1b080ea40e Mon Sep 17 00:00:00 2001 From: Asuka Date: Fri, 4 Aug 2023 14:30:01 +0800 Subject: [PATCH 8/8] func(api): do not print asset v2 and its usage for get account --- src/main/java/org/tron/walletcli/Client.java | 1 + 1 file changed, 1 insertion(+) diff --git a/src/main/java/org/tron/walletcli/Client.java b/src/main/java/org/tron/walletcli/Client.java index 82b8f5876..7a5401efa 100755 --- a/src/main/java/org/tron/walletcli/Client.java +++ b/src/main/java/org/tron/walletcli/Client.java @@ -599,6 +599,7 @@ private void getAccount(String[] parameters) { if (account == null) { System.out.println("GetAccount failed !!!!"); } else { + account = account.toBuilder().clearAssetV2().clearFreeAssetNetUsageV2().build(); System.out.println(Utils.formatMessageString(account)); } }