diff --git a/chainbase/src/main/java/org/tron/core/db2/core/AbstractSnapshot.java b/chainbase/src/main/java/org/tron/core/db2/core/AbstractSnapshot.java index 496a0fd09ac..ba6c77d43a2 100644 --- a/chainbase/src/main/java/org/tron/core/db2/core/AbstractSnapshot.java +++ b/chainbase/src/main/java/org/tron/core/db2/core/AbstractSnapshot.java @@ -15,6 +15,8 @@ public abstract class AbstractSnapshot implements Snapshot { protected WeakReference next; + protected boolean isOptimized; + @Override public Snapshot advance() { return new SnapshotImpl(this); @@ -34,4 +36,9 @@ public void setNext(Snapshot next) { public String getDbName() { return db.getDbName(); } + + @Override + public boolean isOptimized(){ + return isOptimized; + } } diff --git a/chainbase/src/main/java/org/tron/core/db2/core/Snapshot.java b/chainbase/src/main/java/org/tron/core/db2/core/Snapshot.java index e1ca149b207..75545dc29b4 100644 --- a/chainbase/src/main/java/org/tron/core/db2/core/Snapshot.java +++ b/chainbase/src/main/java/org/tron/core/db2/core/Snapshot.java @@ -46,4 +46,8 @@ static boolean isImpl(Snapshot snapshot) { void updateSolidity(); String getDbName(); + + boolean isOptimized(); + + void reloadToMem(); } diff --git a/chainbase/src/main/java/org/tron/core/db2/core/SnapshotImpl.java b/chainbase/src/main/java/org/tron/core/db2/core/SnapshotImpl.java index ae8073f668b..bc31b406b30 100644 --- a/chainbase/src/main/java/org/tron/core/db2/core/SnapshotImpl.java +++ b/chainbase/src/main/java/org/tron/core/db2/core/SnapshotImpl.java @@ -30,6 +30,10 @@ public class SnapshotImpl extends AbstractSnapshot { } previous = snapshot; snapshot.setNext(this); + isOptimized = snapshot.isOptimized(); + if (isOptimized && root == previous) { + Streams.stream(root.iterator()).forEach( e -> put(e.getKey(),e.getValue())); + } } @Override @@ -40,6 +44,7 @@ public byte[] get(byte[] key) { private byte[] get(Snapshot head, byte[] key) { Snapshot snapshot = head; Value value; + while (Snapshot.isImpl(snapshot)) { if ((value = ((SnapshotImpl) snapshot).db.get(Key.of(key))) != null) { return value.getBytes(); @@ -83,6 +88,19 @@ public void merge(Snapshot from) { Streams.stream(fromImpl.db).forEach(e -> db.put(e.getKey(), e.getValue())); } + public void mergeAhead(Snapshot from) { + if (from instanceof SnapshotRoot) { + return ; + } + SnapshotImpl fromImpl = (SnapshotImpl) from; + Streams.stream(fromImpl.db).forEach(e -> { + if (db.get(e.getKey()) == null) { + db.put(e.getKey(), e.getValue()); + } + } + ); + } + @Override public Snapshot retreat() { return previous; @@ -177,4 +195,9 @@ public String getDbName() { public Snapshot newInstance() { return new SnapshotImpl(this); } + + @Override + public void reloadToMem() { + mergeAhead(previous); + } } diff --git a/chainbase/src/main/java/org/tron/core/db2/core/SnapshotManager.java b/chainbase/src/main/java/org/tron/core/db2/core/SnapshotManager.java index f5de96e5587..f0f169ae340 100644 --- a/chainbase/src/main/java/org/tron/core/db2/core/SnapshotManager.java +++ b/chainbase/src/main/java/org/tron/core/db2/core/SnapshotManager.java @@ -221,6 +221,12 @@ public synchronized void commit() { } --activeSession; + + dbs.forEach(db -> { + if (db.getHead().isOptimized()) { + db.getHead().reloadToMem(); + } + }); } public synchronized void pop() { diff --git a/chainbase/src/main/java/org/tron/core/db2/core/SnapshotRoot.java b/chainbase/src/main/java/org/tron/core/db2/core/SnapshotRoot.java index 709e2ae1b62..f95cf68dafe 100644 --- a/chainbase/src/main/java/org/tron/core/db2/core/SnapshotRoot.java +++ b/chainbase/src/main/java/org/tron/core/db2/core/SnapshotRoot.java @@ -38,6 +38,7 @@ public SnapshotRoot(DB db) { if (CACHE_DBS.contains(this.db.getDbName())) { this.cache = CacheManager.allocate(CacheType.findByType(this.db.getDbName())); } + isOptimized = "properties".equalsIgnoreCase(db.getDbName()); } private boolean needOptAsset() { @@ -221,4 +222,7 @@ public String getDbName() { public Snapshot newInstance() { return new SnapshotRoot(db.newInstance()); } + + @Override + public void reloadToMem() { } } diff --git a/common/src/main/java/org/tron/common/logsfilter/trigger/TransactionLogTrigger.java b/common/src/main/java/org/tron/common/logsfilter/trigger/TransactionLogTrigger.java index dec4170efb8..a4fb1fddb79 100644 --- a/common/src/main/java/org/tron/common/logsfilter/trigger/TransactionLogTrigger.java +++ b/common/src/main/java/org/tron/common/logsfilter/trigger/TransactionLogTrigger.java @@ -1,6 +1,8 @@ package org.tron.common.logsfilter.trigger; import java.util.List; +import java.util.Map; + import lombok.Getter; import lombok.Setter; @@ -91,6 +93,10 @@ public class TransactionLogTrigger extends Trigger { @Setter private long energyUnitPrice; + @Getter + @Setter + private Map extMap; + public TransactionLogTrigger() { setTriggerName(Trigger.TRANSACTION_TRIGGER_NAME); } diff --git a/framework/src/main/java/org/tron/common/logsfilter/capsule/TransactionLogTriggerCapsule.java b/framework/src/main/java/org/tron/common/logsfilter/capsule/TransactionLogTriggerCapsule.java index 8600cb6ef8c..ab6ea018cf8 100644 --- a/framework/src/main/java/org/tron/common/logsfilter/capsule/TransactionLogTriggerCapsule.java +++ b/framework/src/main/java/org/tron/common/logsfilter/capsule/TransactionLogTriggerCapsule.java @@ -1,6 +1,7 @@ package org.tron.common.logsfilter.capsule; import static org.tron.protos.Protocol.Transaction.Contract.ContractType.CreateSmartContract; +import static org.tron.protos.contract.Common.ResourceCode.ENERGY; import com.google.protobuf.Any; import com.google.protobuf.ByteString; @@ -26,7 +27,14 @@ import org.tron.protos.Protocol.Transaction.Contract.ContractType; import org.tron.protos.Protocol.TransactionInfo; import org.tron.protos.contract.AssetIssueContractOuterClass.TransferAssetContract; +import org.tron.protos.contract.BalanceContract.CancelAllUnfreezeV2Contract; +import org.tron.protos.contract.BalanceContract.DelegateResourceContract; +import org.tron.protos.contract.BalanceContract.FreezeBalanceV2Contract; import org.tron.protos.contract.BalanceContract.TransferContract; +import org.tron.protos.contract.BalanceContract.UnDelegateResourceContract; +import org.tron.protos.contract.BalanceContract.UnfreezeBalanceContract; +import org.tron.protos.contract.BalanceContract.UnfreezeBalanceV2Contract; +import org.tron.protos.contract.BalanceContract.WithdrawExpireUnfreezeContract; import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract; import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract; @@ -156,6 +164,82 @@ public TransactionLogTriggerCapsule(TransactionCapsule trxCapsule, BlockCapsule StringUtil.encode58Check(createSmartContract.getOwnerAddress().toByteArray())); } break; + case UnfreezeBalanceContract: + UnfreezeBalanceContract unfreezeBalanceContract = contractParameter + .unpack(UnfreezeBalanceContract.class); + + transactionLogTrigger.setFromAddress(StringUtil + .encode58Check(unfreezeBalanceContract.getOwnerAddress().toByteArray())); + if (!ByteString.EMPTY.equals(unfreezeBalanceContract.getReceiverAddress())) { + transactionLogTrigger.setToAddress(StringUtil + .encode58Check(unfreezeBalanceContract.getReceiverAddress().toByteArray())); + } + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setAssetAmount( + transactionInfo.getUnfreezeAmount()); + break; + case FreezeBalanceV2Contract: + FreezeBalanceV2Contract freezeBalanceV2Contract = contractParameter + .unpack(FreezeBalanceV2Contract.class); + + transactionLogTrigger.setFromAddress(StringUtil + .encode58Check(freezeBalanceV2Contract.getOwnerAddress().toByteArray())); + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setAssetAmount(freezeBalanceV2Contract.getFrozenBalance()); + break; + case UnfreezeBalanceV2Contract: + UnfreezeBalanceV2Contract unfreezeBalanceV2Contract = contractParameter + .unpack(UnfreezeBalanceV2Contract.class); + + transactionLogTrigger.setFromAddress(StringUtil + .encode58Check(unfreezeBalanceV2Contract.getOwnerAddress().toByteArray())); + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setAssetAmount( + unfreezeBalanceV2Contract.getUnfreezeBalance()); + break; + case WithdrawExpireUnfreezeContract: + WithdrawExpireUnfreezeContract withdrawExpireUnfreezeContract = contractParameter + .unpack(WithdrawExpireUnfreezeContract.class); + + transactionLogTrigger.setFromAddress(StringUtil.encode58Check( + withdrawExpireUnfreezeContract.getOwnerAddress().toByteArray())); + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setAssetAmount(transactionInfo.getWithdrawExpireAmount()); + break; + case DelegateResourceContract: + DelegateResourceContract delegateResourceContract = contractParameter + .unpack(DelegateResourceContract.class); + + transactionLogTrigger.setFromAddress(StringUtil + .encode58Check(delegateResourceContract.getOwnerAddress().toByteArray())); + transactionLogTrigger.setToAddress(StringUtil + .encode58Check(delegateResourceContract.getReceiverAddress().toByteArray())); + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setAssetAmount( + delegateResourceContract.getBalance()); + break; + case UnDelegateResourceContract: + UnDelegateResourceContract unDelegateResourceContract = contractParameter + .unpack(UnDelegateResourceContract.class); + + transactionLogTrigger.setFromAddress(StringUtil + .encode58Check(unDelegateResourceContract.getOwnerAddress().toByteArray())); + transactionLogTrigger.setToAddress(StringUtil.encode58Check( + unDelegateResourceContract.getReceiverAddress().toByteArray())); + + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setAssetAmount( + unDelegateResourceContract.getBalance()); + break; + case CancelAllUnfreezeV2Contract: + CancelAllUnfreezeV2Contract cancelAllUnfreezeV2Contract = contractParameter + .unpack(CancelAllUnfreezeV2Contract.class); + + transactionLogTrigger.setFromAddress(StringUtil + .encode58Check(cancelAllUnfreezeV2Contract.getOwnerAddress().toByteArray())); + transactionLogTrigger.setAssetName("trx"); + transactionLogTrigger.setExtMap(transactionInfo.getCancelUnfreezeV2AmountMap()); + break; default: break; } @@ -269,4 +353,5 @@ private List getInternalTransactionList( public void processTrigger() { EventPluginLoader.getInstance().postTransactionTrigger(transactionLogTrigger); } + } diff --git a/framework/src/main/java/org/tron/core/services/RpcApiService.java b/framework/src/main/java/org/tron/core/services/RpcApiService.java index 94d5b97decd..b3260306d46 100755 --- a/framework/src/main/java/org/tron/core/services/RpcApiService.java +++ b/framework/src/main/java/org/tron/core/services/RpcApiService.java @@ -1893,6 +1893,7 @@ private void callContract(TriggerSmartContract request, } } + @Override public void getPaginatedAssetIssueList(PaginatedMessage request, StreamObserver responseObserver) { responseObserver.onNext(wallet.getAssetIssueList(request.getOffset(), request.getLimit())); diff --git a/framework/src/test/java/org/tron/common/logsfilter/TransactionLogTriggerCapsuleTest.java b/framework/src/test/java/org/tron/common/logsfilter/TransactionLogTriggerCapsuleTest.java new file mode 100644 index 00000000000..d8da2cc540d --- /dev/null +++ b/framework/src/test/java/org/tron/common/logsfilter/TransactionLogTriggerCapsuleTest.java @@ -0,0 +1,159 @@ +package org.tron.common.logsfilter; + +import static org.tron.core.config.Parameter.ChainConstant.TRX_PRECISION; + +import com.google.protobuf.ByteString; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.logsfilter.capsule.TransactionLogTriggerCapsule; +import org.tron.common.utils.Sha256Hash; +import org.tron.core.capsule.BlockCapsule; +import org.tron.core.capsule.TransactionCapsule; +import org.tron.p2p.utils.ByteArray; +import org.tron.protos.Protocol; +import org.tron.protos.contract.BalanceContract; +import org.tron.protos.contract.Common; + +public class TransactionLogTriggerCapsuleTest { + + private static final String OWNER_ADDRESS = "41548794500882809695a8a687866e76d4271a1abc"; + private static final String RECEIVER_ADDRESS = "41abd4b9367799eaa3197fecb144eb71de1e049150"; + + public TransactionCapsule transactionCapsule; + public BlockCapsule blockCapsule; + + @Before + public void setup() { + blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH, + System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString()); + } + + @Test + public void testConstructorWithUnfreezeBalanceTrxCapsule() { + BalanceContract.UnfreezeBalanceContract.Builder builder2 = + BalanceContract.UnfreezeBalanceContract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))) + .setReceiverAddress(ByteString.copyFrom(ByteArray.fromHexString(RECEIVER_ADDRESS))); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.UnfreezeBalanceContract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getToAddress()); + } + + + @Test + public void testConstructorWithFreezeBalanceV2TrxCapsule() { + BalanceContract.FreezeBalanceV2Contract.Builder builder2 = + BalanceContract.FreezeBalanceV2Contract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))) + .setFrozenBalance(TRX_PRECISION + 100000) + .setResource(Common.ResourceCode.BANDWIDTH); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.FreezeBalanceV2Contract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + Assert.assertEquals("trx", triggerCapsule.getTransactionLogTrigger().getAssetName()); + Assert.assertEquals(TRX_PRECISION + 100000, + triggerCapsule.getTransactionLogTrigger().getAssetAmount()); + } + + @Test + public void testConstructorWithUnfreezeBalanceV2TrxCapsule() { + BalanceContract.UnfreezeBalanceV2Contract.Builder builder2 = + BalanceContract.UnfreezeBalanceV2Contract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))) + .setUnfreezeBalance(TRX_PRECISION + 4000) + .setResource(Common.ResourceCode.BANDWIDTH); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.UnfreezeBalanceV2Contract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + Assert.assertEquals("trx", triggerCapsule.getTransactionLogTrigger().getAssetName()); + Assert.assertEquals(TRX_PRECISION + 4000, + triggerCapsule.getTransactionLogTrigger().getAssetAmount()); + } + + + @Test + public void testConstructorWithWithdrawExpireTrxCapsule() { + BalanceContract.WithdrawExpireUnfreezeContract.Builder builder2 = + BalanceContract.WithdrawExpireUnfreezeContract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.WithdrawExpireUnfreezeContract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + Assert.assertEquals("trx", triggerCapsule.getTransactionLogTrigger().getAssetName()); + Assert.assertEquals(0L, triggerCapsule.getTransactionLogTrigger().getAssetAmount()); + } + + + @Test + public void testConstructorWithDelegateResourceTrxCapsule() { + BalanceContract.DelegateResourceContract.Builder builder2 = + BalanceContract.DelegateResourceContract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))) + .setReceiverAddress(ByteString.copyFrom(ByteArray.fromHexString(RECEIVER_ADDRESS))) + .setBalance(TRX_PRECISION + 2000); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.DelegateResourceContract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getToAddress()); + Assert.assertEquals("trx", triggerCapsule.getTransactionLogTrigger().getAssetName()); + Assert.assertEquals(TRX_PRECISION + 2000, + triggerCapsule.getTransactionLogTrigger().getAssetAmount()); + } + + @Test + public void testConstructorWithUnDelegateResourceTrxCapsule() { + BalanceContract.UnDelegateResourceContract.Builder builder2 = + BalanceContract.UnDelegateResourceContract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))) + .setReceiverAddress(ByteString.copyFrom(ByteArray.fromHexString(RECEIVER_ADDRESS))) + .setBalance(TRX_PRECISION + 10000); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.UnDelegateResourceContract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getToAddress()); + Assert.assertEquals("trx", triggerCapsule.getTransactionLogTrigger().getAssetName()); + Assert.assertEquals(TRX_PRECISION + 10000, + triggerCapsule.getTransactionLogTrigger().getAssetAmount()); + } + + @Test + public void testConstructorWithCancelAllUnfreezeTrxCapsule() { + BalanceContract.CancelAllUnfreezeV2Contract.Builder builder2 = + BalanceContract.CancelAllUnfreezeV2Contract.newBuilder() + .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS))); + transactionCapsule = new TransactionCapsule(builder2.build(), + Protocol.Transaction.Contract.ContractType.CancelAllUnfreezeV2Contract); + + TransactionLogTriggerCapsule triggerCapsule = + new TransactionLogTriggerCapsule(transactionCapsule, blockCapsule); + + Assert.assertNotNull(triggerCapsule.getTransactionLogTrigger().getFromAddress()); + } + +} \ No newline at end of file diff --git a/framework/src/test/java/org/tron/core/db2/SnapshotImplTest.java b/framework/src/test/java/org/tron/core/db2/SnapshotImplTest.java new file mode 100644 index 00000000000..aab6f656b1f --- /dev/null +++ b/framework/src/test/java/org/tron/core/db2/SnapshotImplTest.java @@ -0,0 +1,201 @@ +package org.tron.core.db2; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; + +import java.io.File; +import java.lang.reflect.Constructor; +import org.junit.After; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.application.Application; +import org.tron.common.application.ApplicationFactory; +import org.tron.common.application.TronApplicationContext; +import org.tron.common.utils.FileUtil; +import org.tron.core.Constant; +import org.tron.core.config.DefaultConfig; +import org.tron.core.config.args.Args; +import org.tron.core.db2.core.Snapshot; +import org.tron.core.db2.core.SnapshotImpl; +import org.tron.core.db2.core.SnapshotManager; +import org.tron.core.db2.core.SnapshotRoot; + +public class SnapshotImplTest { + private RevokingDbWithCacheNewValueTest.TestRevokingTronStore tronDatabase; + private TronApplicationContext context; + private Application appT; + private SnapshotManager revokingDatabase; + + @Before + public void init() { + Args.setParam(new String[]{"-d", "output_revokingStore_test"}, Constant.TEST_CONF); + context = new TronApplicationContext(DefaultConfig.class); + appT = ApplicationFactory.create(context); + + tronDatabase = new RevokingDbWithCacheNewValueTest.TestRevokingTronStore( + "testSnapshotRoot-testMerge"); + revokingDatabase = context.getBean(SnapshotManager.class); + revokingDatabase.enable(); + revokingDatabase.add(tronDatabase.getRevokingDB()); + } + + @After + public void removeDb() { + Args.clearParam(); + context.destroy(); + FileUtil.deleteDir(new File("output_revokingStore_test")); + + tronDatabase.close(); + revokingDatabase.shutdown(); + } + + /** + * linklist is: from -> root + * root:key1=>value1, key2=>value2 + * from:key3=>value3, key4=>value4 + * after construct, getSnapshotImplIns(root); + * from: key1=>value1, key2=>value2, key3=>value3, key4=>value4 + * from: get key1 or key2, traverse 0 times + */ + @Test + public void testMergeRoot() { + // linklist is: from -> root + SnapshotRoot root = new SnapshotRoot(tronDatabase.getDb()); + //root.setOptimized(true); + + root.put("key1".getBytes(), "value1".getBytes()); + root.put("key2".getBytes(), "value2".getBytes()); + SnapshotImpl from = getSnapshotImplIns(root); + from.put("key3".getBytes(), "value3".getBytes()); + from.put("key4".getBytes(), "value4".getBytes()); + + byte[] s1 = from.get("key1".getBytes()); + assertEquals(new String("value1".getBytes()), new String(s1)); + byte[] s2 = from.get("key2".getBytes()); + assertEquals(new String("value2".getBytes()), new String(s2)); + } + + /** + * linklist is: from2 -> from -> root + * root: + * from:key1=>value1, key2=>value2 + * from2:key3=>value3,key4=>value4 + * before merge: from2.mergeAhead(from); + * from2: get key1 or key2, traverse 1 times + * after merge + * from2:key1=>value1, key2=>value2, value3=>value3,key4=>value4 + * from2: get key1 or key2, traverse 0 times + * + */ + @Test + public void testMergeAhead() { + + // linklist is: from2 -> from -> root + SnapshotRoot root = new SnapshotRoot(tronDatabase.getDb()); + SnapshotImpl from = getSnapshotImplIns(root); + from.put("key1".getBytes(), "value1".getBytes()); + from.put("key2".getBytes(), "value2".getBytes()); + + SnapshotImpl from2 = getSnapshotImplIns(from); + from2.put("key3".getBytes(), "value3".getBytes()); + from2.put("key4".getBytes(), "value4".getBytes()); + + /* + // before merge get data in from is success,traverse 0 times + byte[] s1 = from.get("key1".getBytes()); + assertEquals(new String("value1".getBytes()), new String(s1)); + byte[] s2 = from.get("key2".getBytes()); + assertEquals(new String("value2".getBytes()), new String(s2)); + // before merge get data in from2 is success, traverse 0 times + byte[] s3 = from2.get("key3".getBytes()); + assertEquals(new String("value3".getBytes()), new String(s3)); + byte[] s4 = from2.get("key4".getBytes()); + assertEquals(new String("value4".getBytes()), new String(s4)); + */ + + // before merge from2 get data is success, traverse 1 times + byte[] s11 = from2.get("key1".getBytes()); + assertEquals(new String("value1".getBytes()), new String(s11)); + byte[] s12 = from2.get("key2".getBytes()); + assertEquals(new String("value2".getBytes()), new String(s12)); + // this can not get key3 and key4 + assertNull(from.get("key3".getBytes())); + assertNull(from.get("key4".getBytes())); + + // do mergeAhead + from2.mergeAhead(from); + /* + // after merge get data in from is success, traverse 0 times + s1 = from.get("key1".getBytes()); + assertEquals(new String("value1".getBytes()), new String(s1)); + s2 = from.get("key2".getBytes()); + assertEquals(new String("value2".getBytes()), new String(s2)); + + // after merge get data in from2 is success, traverse 0 times + s3 = from2.get("key3".getBytes()); + assertEquals(new String("value3".getBytes()), new String(s3)); + s4 = from2.get("key4".getBytes()); + assertEquals(new String("value4".getBytes()), new String(s4)); + */ + + // after merge from2 get data is success, traverse 0 times + byte[] s1 = from2.get("key1".getBytes()); + assertEquals(new String("value1".getBytes()), new String(s1)); + byte[] s2 = from2.get("key2".getBytes()); + assertEquals(new String("value2".getBytes()), new String(s2)); + + // this can not get key3 and key4 + assertNull(from.get("key3".getBytes())); + assertNull(from.get("key4".getBytes())); + } + + /** + * from: key1=>value1, key2=>value2, key3=>value31 + * from2: key3=>value32,key4=>value4 + * after merge: from2.mergeAhead(from); + * from2: key1=>value1, key2=>value2, key3=>value32, key4=>value4 + */ + @Test + public void testMergeOverride() { + // linklist is: from2 -> from -> root + SnapshotRoot root = new SnapshotRoot(tronDatabase.getDb()); + SnapshotImpl from = getSnapshotImplIns(root); + from.put("key1".getBytes(), "value1".getBytes()); + from.put("key2".getBytes(), "value2".getBytes()); + from.put("key3".getBytes(), "value31".getBytes()); + + SnapshotImpl from2 = getSnapshotImplIns(from); + from2.put("key3".getBytes(), "value32".getBytes()); + from2.put("key4".getBytes(), "value4".getBytes()); + // do mergeAhead + from2.mergeAhead(from); + + // after merge from2 get data is success, traverse 0 times + byte[] s1 = from2.get("key1".getBytes()); + assertEquals(new String("value1".getBytes()), new String(s1)); + byte[] s2 = from2.get("key2".getBytes()); + assertEquals(new String("value2".getBytes()), new String(s2)); + byte[] s3 = from2.get("key3".getBytes()); + assertEquals(new String("value32".getBytes()), new String(s3)); + byte[] s4 = from2.get("key4".getBytes()); + assertEquals(new String("value4".getBytes()), new String(s4)); + } + + /** + * The constructor of SnapshotImpl is not public + * so reflection is used to construct the object here. + */ + private SnapshotImpl getSnapshotImplIns(Snapshot snapshot) { + Class clazz = SnapshotImpl.class; + try { + Constructor constructor = clazz.getDeclaredConstructor(Snapshot.class); + constructor.setAccessible(true); + return (SnapshotImpl) constructor.newInstance(snapshot); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + +} diff --git a/framework/src/test/java/org/tron/core/services/RpcApiServicesTest.java b/framework/src/test/java/org/tron/core/services/RpcApiServicesTest.java index 3610d282a20..2f92f49171e 100644 --- a/framework/src/test/java/org/tron/core/services/RpcApiServicesTest.java +++ b/framework/src/test/java/org/tron/core/services/RpcApiServicesTest.java @@ -1,17 +1,23 @@ package org.tron.core.services; import static org.tron.common.parameter.CommonParameter.getInstance; +import static org.tron.common.utils.client.WalletClient.decodeFromBase58Check; +import static org.tron.protos.Protocol.Transaction.Contract.ContractType.TransferContract; +import com.google.protobuf.Any; import com.google.protobuf.ByteString; import io.grpc.ManagedChannel; import io.grpc.ManagedChannelBuilder; import java.io.IOException; +import java.util.Objects; import org.junit.AfterClass; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.Test; import org.junit.rules.TemporaryFolder; +import org.tron.api.GrpcAPI.BlockLimit; +import org.tron.api.GrpcAPI.BlockReq; import org.tron.api.GrpcAPI.BytesMessage; import org.tron.api.GrpcAPI.CanDelegatedMaxSizeRequestMessage; import org.tron.api.GrpcAPI.CanWithdrawUnfreezeAmountRequestMessage; @@ -21,12 +27,12 @@ import org.tron.api.GrpcAPI.IvkDecryptAndMarkParameters; import org.tron.api.GrpcAPI.IvkDecryptParameters; import org.tron.api.GrpcAPI.IvkDecryptTRC20Parameters; -import org.tron.api.GrpcAPI.NfTRC20Parameters; -import org.tron.api.GrpcAPI.NoteParameters; import org.tron.api.GrpcAPI.NumberMessage; import org.tron.api.GrpcAPI.OvkDecryptParameters; import org.tron.api.GrpcAPI.OvkDecryptTRC20Parameters; import org.tron.api.GrpcAPI.PaginatedMessage; +import org.tron.api.GrpcAPI.PrivateParameters; +import org.tron.api.GrpcAPI.PrivateParametersWithoutAsk; import org.tron.api.WalletGrpc; import org.tron.api.WalletGrpc.WalletBlockingStub; import org.tron.api.WalletSolidityGrpc; @@ -39,6 +45,7 @@ import org.tron.core.Constant; import org.tron.core.Wallet; import org.tron.core.capsule.AccountCapsule; +import org.tron.core.capsule.TransactionCapsule; import org.tron.core.config.DefaultConfig; import org.tron.core.config.args.Args; import org.tron.core.db.Manager; @@ -46,26 +53,60 @@ import org.tron.core.services.interfaceOnSolidity.RpcApiServiceOnSolidity; import org.tron.protos.Protocol; import org.tron.protos.Protocol.Account; -import org.tron.protos.contract.ShieldContract.OutputPoint; -import org.tron.protos.contract.ShieldContract.OutputPointInfo; +import org.tron.protos.Protocol.Transaction; +import org.tron.protos.contract.AccountContract.AccountCreateContract; +import org.tron.protos.contract.AccountContract.AccountPermissionUpdateContract; +import org.tron.protos.contract.AccountContract.AccountUpdateContract; +import org.tron.protos.contract.AccountContract.SetAccountIdContract; +import org.tron.protos.contract.AssetIssueContractOuterClass.AssetIssueContract; +import org.tron.protos.contract.AssetIssueContractOuterClass.ParticipateAssetIssueContract; +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.CancelAllUnfreezeV2Contract; +import org.tron.protos.contract.BalanceContract.DelegateResourceContract; +import org.tron.protos.contract.BalanceContract.FreezeBalanceContract; +import org.tron.protos.contract.BalanceContract.FreezeBalanceV2Contract; +import org.tron.protos.contract.BalanceContract.UnDelegateResourceContract; +import org.tron.protos.contract.BalanceContract.UnfreezeBalanceContract; +import org.tron.protos.contract.BalanceContract.UnfreezeBalanceV2Contract; +import org.tron.protos.contract.BalanceContract.WithdrawBalanceContract; +import org.tron.protos.contract.BalanceContract.WithdrawExpireUnfreezeContract; +import org.tron.protos.contract.ExchangeContract.ExchangeCreateContract; +import org.tron.protos.contract.ExchangeContract.ExchangeInjectContract; +import org.tron.protos.contract.ExchangeContract.ExchangeTransactionContract; +import org.tron.protos.contract.ExchangeContract.ExchangeWithdrawContract; +import org.tron.protos.contract.MarketContract.MarketCancelOrderContract; +import org.tron.protos.contract.MarketContract.MarketSellAssetContract; +import org.tron.protos.contract.ProposalContract.ProposalApproveContract; +import org.tron.protos.contract.ProposalContract.ProposalCreateContract; +import org.tron.protos.contract.ProposalContract.ProposalDeleteContract; +import org.tron.protos.contract.SmartContractOuterClass.ClearABIContract; +import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract; +import org.tron.protos.contract.SmartContractOuterClass.TriggerSmartContract; +import org.tron.protos.contract.SmartContractOuterClass.UpdateEnergyLimitContract; +import org.tron.protos.contract.SmartContractOuterClass.UpdateSettingContract; +import org.tron.protos.contract.StorageContract.UpdateBrokerageContract; +import org.tron.protos.contract.WitnessContract.VoteWitnessContract; +import org.tron.protos.contract.WitnessContract.WitnessCreateContract; +import org.tron.protos.contract.WitnessContract.WitnessUpdateContract; public class RpcApiServicesTest { - private static String OWNER_ADDRESS; private static TronApplicationContext context; private static WalletBlockingStub blockingStubFull = null; private static WalletSolidityBlockingStub blockingStubSolidity = null; private static WalletSolidityBlockingStub blockingStubPBFT = null; @ClassRule public static TemporaryFolder temporaryFolder = new TemporaryFolder(); - private static AccountCapsule ownerCapsule; private static ByteString ownerAddress; - private static Manager manager; @BeforeClass public static void init() throws IOException { Args.setParam(new String[]{"-d", temporaryFolder.newFolder().toString()}, Constant.TEST_CONF); - OWNER_ADDRESS = Wallet.getAddressPreFixString() + "548794500882809695a8a687866e76d4271a1abc"; + String OWNER_ADDRESS = Wallet.getAddressPreFixString() + + "548794500882809695a8a687866e76d4271a1abc"; getInstance().setRpcPort(PublicMethod.chooseRandomPort()); getInstance().setRpcOnSolidityPort(PublicMethod.chooseRandomPort()); getInstance().setRpcOnPBFTPort(PublicMethod.chooseRandomPort()); @@ -95,10 +136,10 @@ public static void init() throws IOException { context.getBean(RpcApiServiceOnSolidity.class); RpcApiServiceOnPBFT rpcApiServiceOnPBFT = context.getBean(RpcApiServiceOnPBFT.class); - manager = context.getBean(Manager.class); + Manager manager = context.getBean(Manager.class); ownerAddress = ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)); - ownerCapsule = new AccountCapsule(ByteString.copyFromUtf8("owner"), + AccountCapsule ownerCapsule = new AccountCapsule(ByteString.copyFromUtf8("owner"), ownerAddress, Protocol.AccountType.Normal, 10_000_000_000L); manager.getAccountStore().put(ownerCapsule.createDbKey(), ownerCapsule); manager.getDynamicPropertiesStore().saveAllowShieldedTransaction(1); @@ -405,5 +446,660 @@ public void testScanShieldedTRC20NotesByOvk() { // Assert.assertNotNull(blockingStubPBFT.isShieldedTRC20ContractNoteSpent(message)); // } + // @Test + // public void testGetTriggerInputForShieldedTRC20Contract() { + // ShieldedTRC20TriggerContractParameters message = + // ShieldedTRC20TriggerContractParameters.newBuilder() + // .setAmount("1000") + // .build(); + // Assert.assertNotNull(blockingStubFull.getTriggerInputForShieldedTRC20Contract(message)); + // } + + @Test + public void testUpdateBrokerage() { + UpdateBrokerageContract message = UpdateBrokerageContract.newBuilder() + .setOwnerAddress(ownerAddress).setBrokerage(1).build(); + Assert.assertNotNull(blockingStubFull.updateBrokerage(message)); + } + + @Test + public void testCreateCommonTransaction() { + UpdateBrokerageContract.Builder updateBrokerageContract = UpdateBrokerageContract.newBuilder(); + updateBrokerageContract.setOwnerAddress( + ByteString.copyFrom(Objects + .requireNonNull(decodeFromBase58Check("TN3zfjYUmMFK3ZsHSsrdJoNRtGkQmZLBLz")))) + .setBrokerage(10); + Transaction.Builder transaction = Transaction.newBuilder(); + Transaction.raw.Builder raw = Transaction.raw.newBuilder(); + Transaction.Contract.Builder contract = Transaction.Contract.newBuilder(); + contract.setType(Transaction.Contract.ContractType.UpdateBrokerageContract) + .setParameter(Any.pack(updateBrokerageContract.build())); + raw.addContract(contract.build()); + transaction.setRawData(raw.build()); + Assert.assertNotNull(blockingStubFull.createCommonTransaction(transaction.build())); + } + + @Test + public void testGetTransactionInfoByBlockNum() { + NumberMessage message = NumberMessage.newBuilder().setNum(1).build(); + Assert.assertNotNull(blockingStubFull.getTransactionInfoByBlockNum(message)); + } + + @Test + public void testMarketSellAsset() { + String sellTokenId = "123"; + long sellTokenQuant = 100000000L; + String buyTokenId = "456"; + long buyTokenQuant = 200000000L; + MarketSellAssetContract message = MarketSellAssetContract.newBuilder() + .setOwnerAddress(ownerAddress) + .setBuyTokenQuantity(buyTokenQuant) + .setBuyTokenId(ByteString.copyFrom(buyTokenId.getBytes())) + .setSellTokenQuantity(sellTokenQuant) + .setSellTokenId(ByteString.copyFrom(sellTokenId.getBytes())) + .build(); + Assert.assertNotNull(blockingStubFull.marketSellAsset(message)); + } + + @Test + public void testMarketCancelOrder() { + MarketCancelOrderContract message = MarketCancelOrderContract.newBuilder() + .setOwnerAddress(ownerAddress) + .setOrderId(ByteString.copyFromUtf8("123")) + .build(); + Assert.assertNotNull(blockingStubFull.marketCancelOrder(message)); + } + + @Test + public void testGetMarketOrderByAccount() { + BytesMessage message = BytesMessage.newBuilder().setValue(ownerAddress).build(); + Assert.assertNotNull(blockingStubFull.getMarketOrderByAccount(message)); + Assert.assertNotNull(blockingStubSolidity.getMarketOrderByAccount(message)); + Assert.assertNotNull(blockingStubPBFT.getMarketOrderByAccount(message)); + } + + // @Test + // public void testGetMarketOrderById() { + // BytesMessage message = BytesMessage.newBuilder().setValue(ownerAddress).build(); + // Assert.assertNotNull(blockingStubFull.getMarketOrderById(message)); + // Assert.assertNotNull(blockingStubSolidity.getMarketOrderById(message)); + // Assert.assertNotNull(blockingStubPBFT.getMarketOrderById(message)); + // } + + // @Test + // public void testGetMarketPriceByPair() { + // byte[] sellTokenId = ByteArray.fromString("100"); + // byte[] buyTokenId = ByteArray.fromString("200"); + // byte[] pairKey = MarketUtils.createPairKey(sellTokenId, buyTokenId); + // MarketOrderPair marketOrderPair = MarketUtils.decodeKeyToMarketPair(pairKey); + // Assert.assertNotNull(blockingStubFull.getMarketPriceByPair(marketOrderPair)); + // Assert.assertNotNull(blockingStubSolidity.getMarketPriceByPair(marketOrderPair)); + // Assert.assertNotNull(blockingStubPBFT.getMarketPriceByPair(marketOrderPair)); + // } + + // @Test + // public void testGetMarketOrderListByPair() { + // byte[] sellTokenId = ByteArray.fromString("100"); + // byte[] buyTokenId = ByteArray.fromString("200"); + // byte[] pairKey = MarketUtils.createPairKey(sellTokenId, buyTokenId); + // MarketOrderPair marketOrderPair = MarketUtils.decodeKeyToMarketPair(pairKey); + // Assert.assertNotNull(blockingStubFull.getMarketOrderListByPair(marketOrderPair)); + // Assert.assertNotNull(blockingStubSolidity.getMarketOrderListByPair(marketOrderPair)); + // Assert.assertNotNull(blockingStubPBFT.getMarketOrderListByPair(marketOrderPair)); + // } + + @Test + public void testGetMarketPairList() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getMarketPairList(message)); + Assert.assertNotNull(blockingStubSolidity.getMarketPairList(message)); + Assert.assertNotNull(blockingStubPBFT.getMarketPairList(message)); + } + @Test + public void testGetTransactionFromPending() { + BalanceContract.TransferContract tc = + BalanceContract.TransferContract.newBuilder() + .setAmount(10) + .setOwnerAddress(ByteString.copyFromUtf8("aaa")) + .setToAddress(ByteString.copyFromUtf8("bbb")) + .build(); + TransactionCapsule trx = new TransactionCapsule(tc, TransferContract); + BytesMessage message = BytesMessage.newBuilder() + .setValue(trx.getTransactionId().getByteString()).build(); + Assert.assertNotNull(blockingStubFull.getTransactionFromPending(message)); + } + + @Test + public void testGetTransactionListFromPending() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getTransactionListFromPending(message)); + } + + @Test + public void testGetPendingSize() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getPendingSize(message)); + } + + @Test + public void testGetBlock() { + BlockReq message = BlockReq.newBuilder().setIdOrNum("0").build(); + Assert.assertNotNull(blockingStubFull.getBlock(message)); + Assert.assertNotNull(blockingStubSolidity.getBlock(message)); + Assert.assertNotNull(blockingStubPBFT.getBlock(message)); + } + + // @Test + // public void testGetAccountBalance() { + // AccountIdentifier accountIdentifier = AccountIdentifier.newBuilder() + // .setAddress(ownerAddress).build(); + // BlockIdentifier blockIdentifier = BlockIdentifier.newBuilder() + // .setNumber(1) + // .build(); + // AccountBalanceRequest message = AccountBalanceRequest.newBuilder() + // .setAccountIdentifier(accountIdentifier) + // .setBlockIdentifier(blockIdentifier) + // .build(); + // Assert.assertNotNull(blockingStubFull.getAccountBalance(message)); + // } + + // @Test + // public void testGetBlockBalanceTrace() { + // BlockIdentifier blockIdentifier = BlockIdentifier.newBuilder() + // .setNumber(1) + // .build(); + // Assert.assertNotNull(blockingStubFull.getBlockBalanceTrace(blockIdentifier)); + // } + + @Test + public void testCreateTransaction2() { + BalanceContract.TransferContract transferContract = BalanceContract.TransferContract + .newBuilder() + .setOwnerAddress(ownerAddress) + .setToAddress(ownerAddress) + .setAmount(1000) + .build(); + Assert.assertNotNull(blockingStubFull.createTransaction2(transferContract)); + } + + @Test + public void testGetTransactionSignWeight() { + UpdateBrokerageContract.Builder updateBrokerageContract = UpdateBrokerageContract.newBuilder(); + updateBrokerageContract.setOwnerAddress( + ByteString.copyFrom(Objects + .requireNonNull(decodeFromBase58Check("TN3zfjYUmMFK3ZsHSsrdJoNRtGkQmZLBLz")))) + .setBrokerage(10); + Transaction.Builder transaction = Transaction.newBuilder(); + Transaction.raw.Builder raw = Transaction.raw.newBuilder(); + Transaction.Contract.Builder contract = Transaction.Contract.newBuilder(); + contract.setType(Transaction.Contract.ContractType.UpdateBrokerageContract) + .setParameter(Any.pack(updateBrokerageContract.build())); + raw.addContract(contract.build()); + transaction.setRawData(raw.build()); + Assert.assertNotNull(blockingStubFull.getTransactionSignWeight(transaction.build())); + } + + @Test + public void testGetTransactionApprovedList() { + UpdateBrokerageContract.Builder updateBrokerageContract = UpdateBrokerageContract.newBuilder(); + updateBrokerageContract.setOwnerAddress( + ByteString.copyFrom(Objects + .requireNonNull(decodeFromBase58Check("TN3zfjYUmMFK3ZsHSsrdJoNRtGkQmZLBLz")))) + .setBrokerage(10); + Transaction.Builder transaction = Transaction.newBuilder(); + Transaction.raw.Builder raw = Transaction.raw.newBuilder(); + Transaction.Contract.Builder contract = Transaction.Contract.newBuilder(); + contract.setType(Transaction.Contract.ContractType.UpdateBrokerageContract) + .setParameter(Any.pack(updateBrokerageContract.build())); + raw.addContract(contract.build()); + transaction.setRawData(raw.build()); + Assert.assertNotNull(blockingStubFull.getTransactionApprovedList(transaction.build())); + } + + @Test + public void testCreateAssetIssue() { + AssetIssueContract assetIssueContract = AssetIssueContract.newBuilder() + .build(); + Assert.assertNotNull(blockingStubFull.createAssetIssue(assetIssueContract)); + Assert.assertNotNull(blockingStubFull.createAssetIssue2(assetIssueContract)); + } + + @Test + public void testUnfreezeAsset() { + UnfreezeAssetContract message = UnfreezeAssetContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.unfreezeAsset(message)); + Assert.assertNotNull(blockingStubFull.unfreezeAsset2(message)); + } + + @Test + public void testVoteWitnessAccount() { + VoteWitnessContract message = VoteWitnessContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.voteWitnessAccount(message)); + Assert.assertNotNull(blockingStubFull.voteWitnessAccount2(message)); + } + + @Test + public void testUpdateSetting() { + UpdateSettingContract message = UpdateSettingContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.updateSetting(message)); + } + + @Test + public void testUpdateEnergyLimit() { + UpdateEnergyLimitContract message = UpdateEnergyLimitContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.updateEnergyLimit(message)); + } + + @Test + public void testClearContractABI() { + ClearABIContract message = ClearABIContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.clearContractABI(message)); + } + + @Test + public void testCreateWitness() { + WitnessCreateContract message = WitnessCreateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.createWitness(message)); + Assert.assertNotNull(blockingStubFull.createWitness2(message)); + } + + @Test + public void testCreateAccount() { + AccountCreateContract message = AccountCreateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.createAccount(message)); + Assert.assertNotNull(blockingStubFull.createAccount2(message)); + } + + @Test + public void testUpdateWitness() { + WitnessUpdateContract message = WitnessUpdateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.updateWitness(message)); + Assert.assertNotNull(blockingStubFull.updateWitness2(message)); + } + + @Test + public void testUpdateAccount() { + AccountUpdateContract message = AccountUpdateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.updateAccount(message)); + Assert.assertNotNull(blockingStubFull.updateAccount2(message)); + } + + @Test + public void testSetAccountId() { + SetAccountIdContract message = SetAccountIdContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.setAccountId(message)); + } + + @Test + public void testUpdateAsset() { + UpdateAssetContract message = UpdateAssetContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.updateAsset(message)); + Assert.assertNotNull(blockingStubFull.updateAsset2(message)); + } + + @Test + public void testFreezeBalance2() { + FreezeBalanceContract message = FreezeBalanceContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.freezeBalance2(message)); + } + + @Test + public void testFreezeBalanceV2() { + FreezeBalanceV2Contract message = FreezeBalanceV2Contract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.freezeBalanceV2(message)); + } + + @Test + public void testUnfreezeBalance() { + UnfreezeBalanceContract message = UnfreezeBalanceContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.unfreezeBalance(message)); + Assert.assertNotNull(blockingStubFull.unfreezeBalance2(message)); + } + + @Test + public void testUnfreezeBalanceV2() { + UnfreezeBalanceV2Contract message = UnfreezeBalanceV2Contract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.unfreezeBalanceV2(message)); + } + + @Test + public void testWithdrawBalance() { + WithdrawBalanceContract message = WithdrawBalanceContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.withdrawBalance(message)); + Assert.assertNotNull(blockingStubFull.withdrawBalance2(message)); + } + + @Test + public void testWithdrawExpireUnfreeze() { + WithdrawExpireUnfreezeContract message = WithdrawExpireUnfreezeContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.withdrawExpireUnfreeze(message)); + } + + @Test + public void testDelegateResource() { + DelegateResourceContract message = DelegateResourceContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.delegateResource(message)); + } + + @Test + public void testUnDelegateResource() { + UnDelegateResourceContract message = UnDelegateResourceContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.unDelegateResource(message)); + } + + @Test + public void testCancelAllUnfreezeV2() { + CancelAllUnfreezeV2Contract message = CancelAllUnfreezeV2Contract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.cancelAllUnfreezeV2(message)); + } + + @Test + public void testProposalCreate() { + ProposalCreateContract message = ProposalCreateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.proposalCreate(message)); + } + + @Test + public void testProposalApprove() { + ProposalApproveContract message = ProposalApproveContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.proposalApprove(message)); + } + + @Test + public void testProposalDelete() { + ProposalDeleteContract message = ProposalDeleteContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.proposalDelete(message)); + } + + @Test + public void testExchangeCreate() { + ExchangeCreateContract message = ExchangeCreateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.exchangeCreate(message)); + } + + @Test + public void testExchangeInject() { + ExchangeInjectContract message = ExchangeInjectContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.exchangeInject(message)); + } + + @Test + public void testExchangeWithdraw() { + ExchangeWithdrawContract message = ExchangeWithdrawContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.exchangeWithdraw(message)); + } + + @Test + public void testExchangeTransaction() { + ExchangeTransactionContract message = ExchangeTransactionContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.exchangeTransaction(message)); + } + + @Test + public void testTransferAsset() { + TransferAssetContract message = TransferAssetContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.transferAsset(message)); + Assert.assertNotNull(blockingStubFull.transferAsset2(message)); + } + + @Test + public void testParticipateAssetIssue() { + ParticipateAssetIssueContract message = ParticipateAssetIssueContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.participateAssetIssue(message)); + Assert.assertNotNull(blockingStubFull.participateAssetIssue2(message)); + } + + @Test + public void testGetAssetIssueByAccount() { + Account message = Account.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getAssetIssueByAccount(message)); + } + + @Test + public void testGetAccountNet() { + Account message = Account.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getAccountNet(message)); + } + + @Test + public void testGetAccountResource() { + Account message = Account.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getAccountResource(message)); + } + + @Test + public void testGetBlockById() { + BytesMessage message = BytesMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getBlockById(message)); + } + + @Test + public void testGetProposalById() { + BytesMessage message = BytesMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getProposalById(message)); + } + + @Test + public void testGetBlockByLimitNext() { + BlockLimit message = BlockLimit.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getBlockByLimitNext(message)); + Assert.assertNotNull(blockingStubFull.getBlockByLimitNext2(message)); + } + + @Test + public void testGetBlockByLatestNum() { + NumberMessage message = NumberMessage.newBuilder().setNum(0).build(); + Assert.assertNotNull(blockingStubFull.getBlockByLatestNum(message)); + Assert.assertNotNull(blockingStubFull.getBlockByLatestNum2(message)); + } + + @Test + public void testDeployContract() { + CreateSmartContract message = CreateSmartContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.deployContract(message)); + } + + @Test + public void testTotalTransaction() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.totalTransaction(message)); + } + + @Test + public void testGetNextMaintenanceTime() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getNextMaintenanceTime(message)); + } + + @Test + public void testTriggerContract() { + TriggerSmartContract message = TriggerSmartContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.estimateEnergy(message)); + } + + @Test + public void testEstimateEnergy() { + TriggerSmartContract message = TriggerSmartContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.estimateEnergy(message)); + } + + @Test + public void testTriggerConstantContract() { + TriggerSmartContract message = TriggerSmartContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.triggerConstantContract(message)); + } + + @Test + public void testGetContract() { + BytesMessage message = BytesMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getContract(message)); + } + + @Test + public void testGetContractInfo() { + BytesMessage message = BytesMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getContractInfo(message)); + } + + @Test + public void testListProposals() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.listProposals((message))); + } + + @Test + public void testGetBandwidthPrices() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getBandwidthPrices((message))); + Assert.assertNotNull(blockingStubSolidity.getBandwidthPrices(message)); + Assert.assertNotNull(blockingStubPBFT.getBandwidthPrices(message)); + } + + @Test + public void testGetEnergyPrices() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getEnergyPrices((message))); + Assert.assertNotNull(blockingStubSolidity.getEnergyPrices(message)); + Assert.assertNotNull(blockingStubPBFT.getEnergyPrices(message)); + } + + @Test + public void testGetPaginatedProposalList() { + PaginatedMessage message = PaginatedMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getPaginatedProposalList((message))); + } + + @Test + public void testGetPaginatedExchangeList() { + PaginatedMessage message = PaginatedMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getPaginatedExchangeList((message))); + } + + @Test + public void testGetChainParameters() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getChainParameters((message))); + } + + @Test + public void testGetNodeInfo() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getNodeInfo((message))); + } + + @Test + public void testAccountPermissionUpdate() { + AccountPermissionUpdateContract message = AccountPermissionUpdateContract.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.accountPermissionUpdate((message))); + } + + @Test + public void testCreateShieldedTransaction() { + PrivateParameters message = PrivateParameters.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.createShieldedTransaction((message))); + } + + @Test + public void testCreateShieldedTransactionWithoutSpendAuthSig() { + PrivateParametersWithoutAsk message = PrivateParametersWithoutAsk.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.createShieldedTransactionWithoutSpendAuthSig((message))); + } + + @Test + public void testGetNewShieldedAddress() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getNewShieldedAddress((message))); + } + + @Test + public void testGetSpendingKey() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getSpendingKey((message))); + } + + @Test + public void testGetRcm() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getRcm((message))); + } + + // @Test + // public void testGetExpandedSpendingKey() { + // BytesMessage message = BytesMessage.newBuilder().setValue(ownerAddress).build(); + // Assert.assertNotNull(blockingStubFull.getExpandedSpendingKey((message))); + // } + + // @Test + // public void testGetAkFromAsk() { + // BytesMessage message = BytesMessage.newBuilder().setValue(ownerAddress).build(); + // Assert.assertNotNull(blockingStubFull.getAkFromAsk((message))); + // } + + // @Test + // public void testGetNkFromNsk() { + // BytesMessage message = BytesMessage.newBuilder().setValue(ownerAddress).build(); + // Assert.assertNotNull(blockingStubFull.getNkFromNsk((message))); + // } + + // @Test + // public void testGetIncomingViewingKey() { + // ViewingKeyMessage message = ViewingKeyMessage.newBuilder().build(); + // Assert.assertNotNull(blockingStubFull.getIncomingViewingKey((message))); + // } + + @Test + public void testGetDiversifier() { + EmptyMessage message = EmptyMessage.newBuilder().build(); + Assert.assertNotNull(blockingStubFull.getDiversifier((message))); + } + // @Test + // public void testGetZenPaymentAddress() { + // IncomingViewingKeyDiversifierMessage message = IncomingViewingKeyDiversifierMessage + // .newBuilder().build(); + // Assert.assertNotNull(blockingStubFull.getZenPaymentAddress((message))); + // } + + // @Test + // public void testCreateShieldNullifier() { + // NfParameters message = NfParameters + // .newBuilder().build(); + // Assert.assertNotNull(blockingStubFull.createShieldNullifier((message))); + // } + + // @Test + // public void testCreateSpendAuthSig() { + // SpendAuthSigParameters message = SpendAuthSigParameters + // .newBuilder().build(); + // Assert.assertNotNull(blockingStubFull.createSpendAuthSig((message))); + // } + + // @Test + // public void testGetShieldTransactionHash() { + // Transaction message = Transaction + // .newBuilder().build(); + // Assert.assertNotNull(blockingStubFull.getShieldTransactionHash((message))); + // } + + // @Test + // public void testCreateShieldedContractParameters() { + // PrivateShieldedTRC20Parameters message = PrivateShieldedTRC20Parameters + // .newBuilder().build(); + // Assert.assertNotNull(blockingStubFull.createShieldedContractParameters((message))); + // } + + // @Test + // public void testCreateShieldedContractParametersWithoutAsk() throws ZksnarkException { + // SpendingKey sk = SpendingKey.random(); + // ExpandedSpendingKey expsk = sk.expandedSpendingKey(); + // byte[] ovk = expsk.getOvk(); + // PrivateShieldedTRC20ParametersWithoutAsk message = PrivateShieldedTRC20ParametersWithoutAsk + // .newBuilder() + // .setOvk(ByteString.copyFrom(ovk)) + // .setFromAmount(BigInteger.valueOf(50).toString()) + // .setShieldedTRC20ContractAddress(ownerAddress) + // .build(); + // Assert.assertNotNull(blockingStubFull + // .createShieldedContractParametersWithoutAsk((message))); + // } }